C ++: Fill Array в соответствии с параметром шаблона
https://stackoverflow.com/questions/3157454
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianВопрос
По сути, ситуация выглядит следующим образом:
У меня есть шаблон класса (используя один параметр шаблона length Тип int) и хочу представить статический массив. Этот массив должен быть длиной length и содержать элементы 1 к length.
Код выглядит следующим образом:
template<int length>
class myClass{
static int array[length];
};
Тогда я хотел написать линию для инатализации массива
// of course, the line below does not work as intended.
template<int length> int myClass<length>::array[length]={1,2, ..., length};
(Как) может это быть достигнуто?
Решение
Используйте «Статический конструктор» IDIOM.
// Редактировать 2.
#include <iostream>
template<int length>
class myClass {
public:
typedef int ArrayType[length];
static struct StaticData {
ArrayType array;
StaticData()
{
for (int i = 0; i < length; i++) array[i] = i;
}
}
static_data;
static ArrayType &array;
};
template<int length>
typename myClass<length>::StaticData myClass<length>::static_data;
template<int length>
typename myClass<length>::ArrayType &myClass<length>::array = myClass<length>::static_data.array;
int main(int argc, char** argv) {
const int LEN = 5;
for (int i = 0; i < LEN; i++) {
std::cout << myClass<LEN>::array[i];
}
}
Другие советы
Вы не можете сделать это с помощью массивов в стиле C, потому что у них нет значения SEMANTICS.
Если вы используете что-то вроде std::tr1::array Однако тогда вы можете легко сделать то, что вы хотите, инициализируя в результате функции, или с помощью итератора, который генерирует эти значения.
Вы можете написать класс обертки, но я уверен, что есть чистые решения:
template <size_t length>
class array_init_1_to_n
{
int array[length];
public:
array_init_1_to_n()
{
for (int i = 0; i < length; ++i)
{
array[i] = i + 1;
}
}
operator int*()
{
return array;
}
operator const int*() const
{
return array;
}
};
template<size_t length>
class myClass{
static array_init_1_to_n<length> array;
};
Кажется жестким. Ближайший подход, который я могу думать, будет следующим:
template<int length>
class myClass
{
public:
myClass()
{
static InitializeArray<length> initializeArray(&array);
}
template<int length>
class InitializeArray
{
public:
InitializeArray(int* array)
{
for(int i = 0; i < length ; ++i)
array[i] = i;
}
};
static int array[length];
static myClass instance;
};
template<int length> int myClass<length>::array[length];
template<int length> myClass myClass::instance;
Разве вы не можете обернуть массив в статической функции, так, например,
template<int length>
class myClass {
static int* myArray() {
static bool initd = false;
static int array[length];
if(!initd) {
for(int i=0; i<length; ++i) {
array[i] = i+1;
}
initd = true;
}
return array;
};
};
а затем получить доступ к этому, как,
myClass<4>::myArray()[2] = 42;
Он будет инициализирован при первом использовании и по следующим доступам initd статичен, if(!initd) будет ложным, а этап инициализации будет пропущен.
Я думаю, что это работает только в C ++ 0x. В C ++ 03 Что бы вы ни делали - вы получите динамически инициализированный массив, и, таким образом, потенциально иметь проблемы с помощью инициализации. Следующий код C ++ 0x не будет иметь таких проблем.
template<int...>
struct myArray;
template<int N, int ...Ns>
struct myArray<N, Ns...> : myArray<N-1, N, Ns...> { };
template<int ...Ns>
struct myArray<0, Ns...> {
static int array[sizeof...(Ns)];
};
template<int ...Ns>
int myArray<0, Ns...>::array[sizeof...(Ns)] = { Ns... } ;
template<int length>
class myClass : myArray<length> {
using myArray<length>::array;
};
встроить на петлю в Статический конструктор который бежит до длины, его в основном так же, как и использование инициализатора:
for(int i = 0; i < length; i++)
array[i] = i + 1;
Вот пример с использованием Boost.mpl:
#include <cstddef>
#include <iostream>
#include <boost/mpl/range_c.hpp>
#include <boost/mpl/string.hpp>
template<std::size_t length>
struct myClass {
static const std::size_t Length = length;
typedef typename boost::mpl::c_str< boost::mpl::range_c<std::size_t, 1, length + 1> > Array;
};
int main() {
// check whether the array really contains the indented values
typedef myClass<10> test;
for (std::size_t i = 0; i < test::Length; ++i) {
std::cout << test::Array::value[i] << std::endl;
}
}
Обратите внимание, что массив больше, чем length; В настоящее время его размер фиксирован.
Вы можете использовать явную экспозицию шаблона дополнительного статического элемента, конструктор которого заботится о заполнении записей:
template<int length>
class myClass{
public:
static int array[length];
typedef enum{LENGTH=length} size_;
struct filler
{
filler(void)
{
for(int i=0;i<LENGTH;++i)
array[i]=i+1;
}
};
static filler fill_;
};
// of course, the line[s] below now do work as intended.
template<int length>
int myClass<length>::array[length];
//static member definition
template<int length>
typename myClass<length>::filler myClass<length>::fill_;
//explicit template instantiation
template myClass<5>::filler myClass<5>::fill_;
int main(void)
{
for(int i=0;i<myClass<5>::LENGTH;++i)
cout<<myClass<5>::array[i]<<endl;
return 0;
}
Или, поскольку подобное (вероятно, лучше) решение уже было показано выше Benoit, вот шаблон рекурсивной версии, просто для удовольствия:
//recursive version:
template<int length>
class myClass{
public:
static int array[length];
typedef enum{LENGTH=length} size_;
static void do_fill(int* the_array)
{
the_array[LENGTH-1]=LENGTH;
myClass<length-1>::do_fill(the_array);
}
struct filler
{
filler(void)
{
/*for(int i=0;i<LENGTH;++i)
array[i]=i+1;*/
do_fill(array);
}
};
static filler fill_;
};
//explicit specialization to end the recursion
template<>
class myClass<1>{
public:
static int array[1];
typedef enum{LENGTH=1} size_;
static void do_fill(int* the_array)
{
the_array[LENGTH-1]=LENGTH;
}
};
//definition of the explicitly specialized version of the array
//to make the linker happy:
int myClass<1>::array[1];
// of course, the line below does not work as intended.
template<int length>
int myClass<length>::array[length];
//static member definition
template<int length>
typename myClass<length>::filler myClass<length>::fill_;
//explicit template instantiation
template myClass<5>::filler myClass<5>::fill_;
int main(void)
{
for(int i=0;i<myClass<5>::LENGTH;++i)
cout<<myClass<5>::array[i]<<endl;
return 0;
}
Теперь разные компиляторы поддерживают разные уровни рекурсии шаблона (и эта техника - это компилятор дорогой) Так, осторожен ... «Вот драконы» ;-)
О, еще одна вещь, вам не нужно переопределить массив в специализированной версии MyClass, чтобы вы могли избавиться от инстанционного массива [1]:
//explicit specialization to end the recursion
template<>
class myClass<1>{
public:
typedef enum{LENGTH=1} size_;
static void do_fill(int* the_array)
{
the_array[LENGTH-1]=LENGTH;
}
};
