C ++: заполнить массив в соответствии с параметром шаблона - PullRequest
Новая
       6

C ++: заполнить массив в соответствии с параметром шаблона

12 голосов
/ 01 июля 2010

По сути, ситуация выглядит следующим образом:

У меня есть шаблон класса (использующий один параметр шаблона 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};

(Как) этого можно достичь?

Ответы [ 9 ]

5 голосов
/ 01 июля 2010

Вы не можете сделать это с массивами в стиле C, потому что они не имеют семантики значений.

Однако, если вы используете что-то вроде std::tr1::array, вы можете легко сделать то, что вы хотите, инициализируя результат функции или используя итератор, который генерирует эти значения.

2 голосов
/ 01 июля 2010

Используйте идиому "статический конструктор".

// РЕДАКТИРОВАТЬ 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];
    }
}
1 голос
/ 02 июля 2010

Я думаю, что это работает только в 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;
};
1 голос
/ 01 июля 2010

Не можете ли вы обернуть массив в статическую функцию, например, 

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) будет ложным, и шаг инициализации будет пропущен.

1 голос
/ 01 июля 2010

Это кажется сложным. Самый близкий подход, о котором я могу думать, был бы следующим: 

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;
1 голос
/ 01 июля 2010

Вы можете написать класс-оболочку, но я уверен, что есть более чистые решения: 

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;
};
0 голосов
/ 01 июля 2010

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

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;
}

Теперь разные компиляторы поддерживают разные уровни рекурсии шаблонов (и эта методика обходится компилятору дорого), поэтому будьте осторожны ... "Here Be Dragons";-)

О, еще одна вещь, вам не нужно переопределять массив в специализированной версии 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;
    }
};
0 голосов
/ 01 июля 2010

Вот пример использования 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;в настоящее время его размер фиксирован.

0 голосов
/ 01 июля 2010

встраивает цикл for в статический конструктор , который работает до нужной длины, по сути, он такой же, как при использовании инициализатора: 

for(int i = 0; i < length; i++)
    array[i] = i + 1;
...