Действительно ли возможно создать и инициализировать массив шаблонного метапрограммирования использования значений?

Вы можете использовать это для массивов фиксированного размера:

int a[] = { foo<0>::value, foo<1>::value, ... };

Массивы произвольного размера, однако не могут быть выполнены без метапрограммирования препроцессора - здесь может помочь Boost.Preprocessor .

Еще одна вещь, которую вы, возможно, захотите изучить, - это последовательности интегральных констант во время компиляции, например using Boost.MPL :

template<int n>
struct squares {
    typedef typename squares<n-1>::type seq;
    typedef typename boost::mpl::integral_c<int, n*n>::type val;    
    typedef typename boost::mpl::push_back<seq, val>::type type;
};

template<>
struct squares<1> {
    typedef boost::mpl::vector_c<int, 1>::type type;
};

// ...
typedef squares<3>::type sqr;
std::cout << boost::mpl::at_c<sqr, 0>::type::value << std::endl; // 1
std::cout << boost::mpl::at_c<sqr, 1>::type::value << std::endl; // 4
std::cout << boost::mpl::at_c<sqr, 2>::type::value << std::endl; // 9

(Обратите внимание, что это, вероятно, можно было бы сделать более элегантно, используя алгоритмы MPL)

Если вам больше интересно узнать о теме времени компиляции, книги "Modern C ++ Design » (основы TMP) и « Метапрограммирование шаблонов C ++ » (в основном, MPL подробно объясняется) заслуживают внимания.

Возможно, более разумно использовать специализации, чем фактический массив. Это становится запутанным ... Я сделал это для алгоритма хеширования строк, который я использовал с метапрограммированием шаблонов. В части алгоритма использовалась большая таблица поиска, которая в итоге выглядела так:

template <> struct CrcTab<0x00> { enum { value = 0x00000000 }; };
template <> struct CrcTab<0x01> { enum { value = 0x77073096 }; };
template <> struct CrcTab<0x02> { enum { value = 0xee0e612c }; };

. Доступ к ней был таким:

CrcTab<index>::value

Преимущество этого заключается в том, что вы можете использовать результаты в метапрограмме, где вы не сможете для доступа к массиву.

Для значения квадрата аргумента вам даже не нужно специализироваться. Предупреждение: компилятор не удобен ...

template <uint32_t N> struct Square { enum { value = N*N }; };

На самом деле это подчеркивает недостаток этого подхода, вы не можете индексировать с помощью переменной ... только константы.

Я не уверен, хотите ли вы увидеть, как это делается, или найти библиотеку, которая просто сделает это за вас. Я полагаю, что первая.

template<int N>
struct SqArr {
    static inline void fill(int arr[]) {
        arr[N-1] = (N-1)*(N-1);
        SqArr<N-1>::fill(arr);
    }
};

template<>
struct SqArr<0> {
    static inline void fill(int arr[]) { }
};

Теперь давайте попробуем использовать это чудовище:

#include <iostream>
#include <algorithm>
#include <iterator>

using namespace std;

int main(int argc, char* argv[])
{
    int arr[10];
    SqArr<10>::fill(arr);
    cout << endl;
    copy(arr, arr+10, ostream_iterator<int>(cout, "\t"));
    cout << endl;
    return 0;
}

Примечание (исповедь): Это не вычисления во время компиляции. Чтобы мотивировать это, можно попробовать изменить четвертую строку с SqArr::fill(arr); на SqArr::fill(arr);, чтобы рекурсия была бесконечной, и вы увидите, что это прекрасно компилируется (когда компилятор на самом деле должен рекурсировать бесконечно, или жаловаться на бесконечную рекурсию).

В метапрограммировании это называется Static Table Generation.

#include <iostream>

const int ARRAY_SIZE = 5;

template <int N, int I=N-1>
class Table : public Table<N, I-1>
{
public:
    static const int dummy;
};

template <int N>
class Table<N, 0>
{
public:
    static const int dummy;
    static int array[N];
};

template <int N, int I>
const int Table<N, I>::dummy = Table<N, 0>::array[I] = I*I + 0*Table<N, I-1>::dummy;

template <int N>
int Table<N, 0>::array[N];

template class Table<ARRAY_SIZE>;

int main(int, char**)
{
    const int *compilerFilledArray = Table<ARRAY_SIZE>::array;
    for (int i=0; i < ARRAY_SIZE; ++i)
        std::cout<<compilerFilledArray[i]<<std::endl;
}

Мы используем явное инстанцирование шаблона и фиктивную переменную, чтобы заставить компилятор заполнить массив квадратами индексов. Часть после I*I - это трюк, необходимый для рекурсивного присвоения каждого элемента массива.