Ответ 1
Примечание. Я понял ваш вопрос следующим образом: вы хотите присоединиться к этим двум массивам и сгладить результат в один новый массив, содержащий конкатенацию их элементов.
Вы можете достичь своей цели тремя концепциями С++ 11 +:
Вы начинаете с создания шаблона (пустой оболочки), чтобы начать разработку функции выравнивания списка рекурсивных моделей:
template<unsigned N1, unsigned N2>
constexpr std::array<int, N1+N2> concat(const std::array<int, N1>& a1, const std::array<int, N2>& a2){
// TODO
}
пока что так хорошо: спецификатор constexpr подскажет компилятору время компиляции оценивать эту функцию каждый раз, когда это возможно.
Теперь для интересной части: std:: array имеет (с С++ 1y) a constexpr перегрузка для оператора [], это означает, что вы можете написать что-то вроде
template<unsigned N1, unsigned N2>
constexpr std::array<int, N1+N2> concat(const std::array<int, N1>& a1, const std::array<int, N2>& a2){
return std::array<int,N1+N2>{a1[0],a1[1],a1[2],a2[0],a2[1]};
}
(обратите внимание на aggregate-initialization для инициализации объекта из целого ряда значений)
Очевидно, что жесткое кодирование вручную всех обращений к значениям этих двух массивов не лучше, чем просто объявление самого конкатенированного массива. Концепция, которая сохранит этот день, следующая: Пакеты параметров. Пакет параметров шаблона является параметром шаблона, который принимает 0 или более аргументов шаблона. Шаблон с хотя бы одним пакетом параметров называется вариационным шаблоном.
Приятная вещь - это возможность расширения пакета параметров в определенные места, например:
#include <iostream>
#include <array>
template<unsigned... Num>
std::array<int, 5> function(const std::array<int,5>& source) {
return std::array<int,5>{source[Num]...};
}
int main() {
std::array<int,5> source{7,8,9,10,11};
std::array<int,5> res = function<0,1,2,3,4>(source);
for(int i=0; i<res.size(); ++i)
std::cout << res[i] << " "; // 7 8 9 10 11
return 0;
}
Итак, единственное, что нам нужно прямо сейчас - это возможность компиляции-времени генерировать "индексный ряд", например
std::array<int,5> res = function<0,1,2,3,4>(source);
^ ^ ^ ^ ^
В этот момент мы снова можем воспользоваться пакетами параметров в сочетании с механизмом наследования: идея состоит в том, чтобы иметь глубоко вложенную иерархию классов derived : base : other_base : another_base : ..., которая "накапливает" индексы в пакете параметров и завершает "рекурсия", когда индекс достигает 0. Если вы не поняли предыдущее предложение, не волнуйтесь и посмотрите на следующий пример:
std::array<int, 3> a1{42,26,77};
// goal: having "Is" = {0,1,2} i.e. a1 valid indices
template<unsigned... Is> struct seq;
мы можем сгенерировать последовательность индексов следующим образом:
template<unsigned N, unsigned... Is>
struct gen_seq : gen_seq<N-1, Is...>{}; // each time decrement the index and go on
template<unsigned... Is>
struct gen_seq<0 /*stops the recursion*/, Is...> : /* generate the sequence */seq<Is...>{};
std::array<int, 3> a1{42,26,77};
gen_seq<3>{};
В любом случае чего-то не хватает: приведенный выше код начинается с gen_seq < 3, (nothing) > и создает экземпляр указанного шаблона, который будет создавать экземпляр gen_seq < 2, (nothing) > в качестве базового класса, который будет создавать экземпляр gen_seq < 1, (nothing) > в качестве своего базового класса, который будет создавать экземпляр gen_seq < 0, (nothing) > в качестве базового класса, который будет создавать последовательность seq < (nothing) > в качестве окончательной последовательности.
Последовательность "(ничего)", что-то не так.
Чтобы "скопировать" индексы в пакет параметров, вам нужно "добавить копию" уменьшенного индекса в пакет параметров при каждой рекурсии:
template<unsigned N, unsigned... Is>
struct gen_seq : gen_seq<N-1, /*This copy goes into the parameter pack*/ N-1, Is...>{};
template<unsigned... Is>
struct gen_seq<0 /*Stops the recursion*/, Is...> : /*Generate the sequence*/seq<Is...>{};
template<unsigned... Is> struct seq{};
// Using '/' to denote (nothing)
gen_seq<3,/> : gen_seq<2, 2,/> : gen_seq<1, 1,2,/> : gen_seq<0, 0,1,2,/> : seq<0,1,2,/> .
так что теперь мы сможем вспомнить все части вместе и сгенерировать две последовательности индексов: одну для первого массива и одну для второго массива и объединить их вместе в новый возвращаемый массив, который будет удерживать объединенное и сплющенное объединение из двух массивов (например, присоединяющих их вместе).
Следующий код на данном этапе должен быть легко понятным:
#include <iostream>
#include <array>
template<unsigned... Is> struct seq{};
template<unsigned N, unsigned... Is>
struct gen_seq : gen_seq<N-1, N-1, Is...>{};
template<unsigned... Is>
struct gen_seq<0, Is...> : seq<Is...>{};
template<unsigned N1, unsigned... I1, unsigned N2, unsigned... I2>
// Expansion pack
constexpr std::array<int, N1+N2> concat(const std::array<int, N1>& a1, const std::array<int, N2>& a2, seq<I1...>, seq<I2...>){
return { a1[I1]..., a2[I2]... };
}
template<unsigned N1, unsigned N2>
// Initializer for the recursion
constexpr std::array<int, N1+N2> concat(const std::array<int, N1>& a1, const std::array<int, N2>& a2){
return concat(a1, a2, gen_seq<N1>{}, gen_seq<N2>{});
}
int main() {
constexpr std::array<int, 3> a1 = {1,2,3};
constexpr std::array<int, 2> a2 = {4,5};
constexpr std::array<int,5> res = concat(a1,a2);
for(int i=0; i<res.size(); ++i)
std::cout << res[i] << " "; // 1 2 3 4 5
return 0;
}
Литература: