Использование массивов:

Учитывая таблицу с уникальными записями от 0 до dim ^ 2-1, вы можете написать constexpr функции поиска для i и j данной записи таблицы:

constexpr unsigned get_x_comp(unsigned index, unsigned i=0, unsigned j=0) 
{ return table[i][j] == index ? i : get_x_comp(index, ((j+1)%dim ? i : i+1), (j+1)%dim); }

constexpr unsigned get_y_comp(unsigned index, unsigned i=0, unsigned j=0) 
{ return table[i][j] == index ? j : get_y_comp(index, ((j+1)%dim ? i : i+1), (j+1)%dim); }

Они будут рекурсивно вызывать себя, перебирая таблицу и ища index. Рекурсия в конечном итоге закончится, когда данный индекс будет найден и будет возвращено _4 _ / _ 5_ этого индекса.

Объедините это с C ++ 14 std::integer_sequence, упомянутым Джонатаном, для инициализации массивов:

template<unsigned... I>
constexpr auto make_x_comp(std::integer_sequence<unsigned, I...>) -> std::array<unsigned, sizeof...(I)> { return {get_x_comp(I)...}; }

Использование метафункций вместо массивов:

В некоторых случаях массивы могут даже не понадобиться. Я предполагаю, что вы хотите, чтобы table содержал последовательные индексы от 0 до dim ^ 2-1. В этом случае table, x_comp и y_comp - это только простые функции времени компиляции со следующими атрибутами:

• table(i,j) := i*dim + j
• x_comp(index) := index / dim (целочисленное деление)
• y_comp(index) := index % dim

В зависимости от того, доступны ли у вас функции C ++ 11, реализация будет отличаться, но в обоих случаях без массивов.

Примечание. в следующих реализациях предполагается, что числа, хранящиеся в table, идут последовательно от 0 до dim ^ 2-1. Если это не случай, вам придется свернуть свою собственную подходящую функцию для table и использовать указанные выше реализации get_x_comp и get_y_comp.

C++11:

template <unsigned dim> //use unsigned to avoid negative numbers!
struct internal {
  static constexpr unsigned table(unsigned i, unsigned j) { return i*dim+j; }
  static constexpr unsigned x_comp(unsigned index) { return index/dim; }
  static constexpr unsigned y_comp(unsigned index) { return index%dim; }
};

Вы можете вызывать эти функции как обычные функции где угодно, особенно когда вам нужны константы времени компиляции. Пример: int a[internal<5>::table(2,4)];

C++03:

template <unsigned dim> //use unsigned to avoid negative numbers!
struct internal {
  template<unsigned i, unsigned j>
  struct table{ static const unsigned value = i*dim+j; };
  template<unsigned index>
  struct x_comp{ static const unsigned value = index/dim; };
  template<unsigned index>
  struct y_comp{ static const unsigned value = index%dim; };
};

Использование этих метафункций немного более неуклюже, чем в C ++ 11, но работает как обычно с метафункциями шаблонов. Тот же пример, что и выше: int a[internal<5>::table<2,4>::value];

Примечание. На этот раз вы можете поместить (мета) функции в заголовок, поскольку они больше не являются неотъемлемыми статическими переменными-членами. Также вам не нужно ограничивать шаблон небольшими размерами, так как все будет хорошо рассчитано для размеров меньше sqrt(numeric_limits<unsigned>::max()).

Извините, если я не отвечаю на вопрос напрямую (или вообще), но я действительно не понимаю, о чем вы спрашиваете. Я думаю, вы говорите, что хотите инициализировать во время компиляции способ представления массива размером N x M в виде одномерного массива?

Я включил код, позволяющий выделять неквадратные размеры. Я построил это на "простом" C ++, поэтому, если вы только начинаете знакомиться с шаблонами, это не так уж и сложно.

Можно ли сделать что-то подобное?

template <typename T, typename std::size_t N, typename std::size_t M = 1>
class Array {
    T* data;
public:
    Array<T, N, M>() : data(new T[N * M]) {
        T temp = 0;
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < M; j++) {
                data[i * M + j] = temp++;
            }
        }
    }
    /* methods and stuff
}

Где M - номер столбца, поэтому вы должны использовать это так:

int main(void) {

    Array<float, 10, 10> myArray;

    return 0;
}

Не забудьте вызвать delete в деструкторе.

Изменить: я не понимал правила заполнения x_comp и y_comp, когда писал это, теперь, когда я вижу, что часть вопроса, этот ответ на самом деле не актуален, потому что я ошибочно предполагал, что table содержит только последовательные целые числа. Ответ в любом случае остается здесь, потому что ответ Арне (гораздо лучший) относится к нему.

Я бы заменил массивы на std::array и использовал бы утилиту C ++ 14 integer_sequence:

template <int dim>
struct internal {
    static std::array<std::array<unsigned, dim>, dim> table;
    static std::array<unsigned, dim*dim> x_comp;
    static std::array<unsigned, dim*dim> y_comp;
};

template<unsigned Origin, unsigned... I>
constexpr std::array<unsigned, sizeof...(I)>
make_1d_array_impl(std::integer_sequence<unsigned, I...>)
{
    return { { I + Origin ... } };
}

template<int N>
constexpr std::array<unsigned, N*N>
make_1d_array()
{
    return make_1d_array_impl<0>(std::make_integer_sequence<unsigned, N*N>{});
}


template<unsigned... I>
constexpr std::array<std::array<unsigned, sizeof...(I)>, sizeof...(I)>
make_2d_array_impl(std::integer_sequence<unsigned, I...> seq)
{
    return { { make_1d_array_impl<I*sizeof...(I)>(seq)  ... } };
}

template<int N>
constexpr std::array<std::array<unsigned, N>, N>
make_2d_array()
{
    return make_2d_array_impl(std::make_integer_sequence<unsigned, N>{});
}

template<int dim>
std::array<std::array<unsigned, dim>, dim> internal<dim>::table = make_2d_array<dim>();

Это правильно заполняет массив table. Мне придется подумать об этом еще немного, чтобы заполнить x_comp и y_comp, как вы хотите, но это выполнимо.

Вы можете найти реализацию integer_sequence в C ++ 11 на https://gitlab.com/redistd/integer_seq/blob/master/integer_seq.h