Question

在标准c ++中我们可以写：

int myArray[5] = {12, 54, 95, 1, 56};

我想用模板写同样的东西：

Array<int, 5> myArray = {12, 54, 95, 1, 56};

假设

template <class Type, unsigned long N>
class Array
{
public:

    //! Default constructor
    Array();

    //! Destructor
    virtual ~Array();

    //! Used to get the item count
    //! @return the item count
    unsigned long getCount() const;

    //! Used to access to a reference on a specified item
    //! @param the item of the item to access
    //! @return a reference on a specified item
    Type & operator[](const unsigned long p_knIndex);

    //! Used to access to a const reference on a specified item
    //! @param the item of the item to access
    //! @return a const reference on a specified item
    const Type & operator[](const unsigned long p_knIndex) const;

private:

    //! The array collection
    Type m_Array[N];
};

我认为这是不可能的，但可能有一个棘手的方法来做到这一点！

Answer 1

我的解决方案是编写一个类模板，它累积传递给构造函数的所有值。以下是您现在可以启动Array的方法：

Array<int, 10> array = (adder<int>(1),2,3,4,5,6,7,8,9,10);

adder的实施如下所示，并完整演示：

template<typename T>
struct adder
{
   std::vector<T> items;
   adder(const T &item) { items.push_back(item); }
   adder& operator,(const T & item) { items.push_back(item); return *this; }
};

template <class Type, size_t N>
class Array
{
public:

    Array(const adder<Type> & init) 
    {
         for ( size_t i = 0 ; i < N ; i++ )
         {
               if ( i < init.items.size() )
                   m_Array[i] = init.items[i];
         }
    }
    size_t Size() const { return N; }
    Type & operator[](size_t i) { return m_Array[i]; }
    const Type & operator[](size_t i) const { return m_Array[i]; }

private:

    Type m_Array[N];
};

int main() {

        Array<int, 10> array = (adder<int>(1),2,3,4,5,6,7,8,9,10);
        for (size_t i = 0 ; i < array.Size() ; i++ )
           std::cout << array[i] << std::endl;
        return 0;
}

输出：

请自行查看ideone的在线演示：http://www.ideone.com/KEbTR

Answer 2

使用initializer lists在C ++ 0x中可以实现这一点。目前，没有办法做到这一点。

如果没有这个，你最接近的就是使用Boost.Assign。

Answer 3

实际上非常微不足道;只需删除构造函数和使数据成员公开。模板问题是红色的赫林;同样的规则适用于任何类：如果它是一个聚合，你可以使用聚合初始化;如果不是，你做不到。

- 詹姆斯坎泽

Answer 4

另一种不需要adder类模板的解决方案。现在你可以这样做：

int main() {

        Array<int, 10> array;
        array = 1,2,3,4,5,6,7,8,9,10;
        for (size_t i = 0 ; i < array.Size() ; i++ )
           std::cout << array[i] << std::endl;
        return 0;
}

输出：

以下是完整的解决方案：http://www.ideone.com/I0L1C

Answer 5

你是对的。目前的标准C ++无法做到这一点。但是，使用下一个标准（c ++ 0x）初始化程序列表就可以做到这一点！

使用值列表进行模板数组初始化

5 个答案: