c++ - 自定义数组类 : Constructor for Initialization of List

Question

我正在使用 C++ 编写一个自定义数组类(作为一个自学练习)，但我不确定如何创建一个允许我执行以下操作的构造函数:

#include "array.h"
#include <iostream>
int main()
{
    array<int> test = {1, 2, 3, 4};
    std::cout << test(1) << std::endl;
    return 0;
}

编译器 (VS Express 2013) 给我的错误是“没有构造函数数组::数组 [with T = int] 的实例”与参数列表匹配。参数类型是 (int, int, int, int)。”

我不确定采用枚举一组元素的构造函数调用了什么。我知道我已经适本地重载了 operator()(const int&) .我也知道这(出于我不清楚的原因)有效:

#include "array.h"
#include <iostream>
int main()
{
    array<char> test = "abcd";
    std::cout << test(1) << std:: endl; // prints 'a', as expected. 
    std::cout << test(4) << std::endl; // prints 'd', as expected.
    return 0;
}

这是通过 array(const T[]) 实现的构造函数:array<int> test = {1, 2, 3, ..., n} 的解决方案情况相似吗？

提前感谢您的指导。

编辑:包括下面的代码，以防有帮助。

template<typename T>
class array
{
public:
    typedef T* iterator;
    typedef const T* const_iterator;
private:
    iterator head;
    unsigned long elems;
public:
    array()
        : head(nullptr)
        , elems(0) {}
    array(const unsigned long &size)
        : head(size > 0 ? new T[size] : nullptr)
        , elems(size) {}
    array(const T[]);
    array(const array&);
    ~array() { delete[] head; }

    iterator begin() const { return head; }
    iterator end() const { return head != nullptr ? &head[elems] : nullptr; }
    unsigned long size() const { return elems; }

    array& operator=(const array&);
    T& operator()(const unsigned long&);
};

template<typename T>
array<T>::array(const T rhs[])
{
    unsigned long size = sizeof(rhs) / sizeof(T);
    head = new T[size];
    iterator pointer = begin();
    for (const_iterator i = &rhs[0]; i != &rhs[0] + size; i++)
        *pointer++ = *i;
}

template<typename T>
array<T>::array(const array<T> &rhs)
{
    head = new T[rhs.size()];
    iterator pointer = begin();
    for (const_iterator i = rhs.begin(); i != rhs.end(); i++)
        *pointer++ = *i;
}

template<typename T>
array<T>& array<T>::operator=(const array<T> &rhs)
{
    if (this != &rhs)
    {
        delete[] head;
        head = new T[rhs.size()];
        iterator pointer = begin();
        for (const_iterator i = rhs.begin(); i != rhs.end(); i++)
            *pointer++ = *i;
    }
    return *this;
}

template<typename T>
T& array<T>::operator()(const unsigned long &index)
{
    if (index < 1 || index > size())
    {
        // Add some error-handling here.
    }
    return head[index - 1];
}

Answer 1

#include <initializer_list>

// ...

template <typename T>
class array
{   
    // ... 
    array(std::initializer_list<T> il);    

// ...    
template <typename T>
array<T>::array(std::initializer_list<T> il)
{
    unsigned long size = il.size();
    head = new T[size];
    iterator pointer = begin();
    for (const T& i : il)
        *pointer++ = i;
}

// ...
array<int> test = {1, 2, 3, 4};

DEMO

---

建议的改进:

1. array(const T rhs[]);相当于array(const T* rhs); ，也就是一个指针，表示sizeof(rhs) / sizeof(T) expression 不会给你项目的数量。如果你想要一个特殊的构造函数 const char* ，然后考虑整个 array<char>如果 T，则特化或至少从重载决议中禁用此构造函数不是 char

2. head = new T[size];默认初始化所有元素(为类型的每个实例调用默认构造函数 T )。然后调用赋值操作:*pointer++ = *i; .这可以通过使用 placement-new 来改进，例如 ::new ((void*)ptr) T(*i);其中 ptr是指向原始的、未初始化的内存缓冲区的指针，例如 new char[sizeof(T)*size]或从 get_temporary_buffer 返回.

---

如果您想知道为什么以下内容有效 array<char> test = { "abcd" };对于您当前的实现，这里有一个解释:

1. array<T>类有一个构造函数采用 const T[] , 这对于 T=char被实例化为 array<char>::array(const char*) .

2. List-initialization 可用于调用对象的构造函数。

3. 你的 const T[]构造函数不是显式的，这意味着您可以使用如下复制初始化语法:

   array<char> test = { "test" };
   

4. 表达式sizeof(rhs) / sizeof(T) ，虽然如上所述无效，但对于 T=char评估为 sizeof(char*) / sizeof(char) ，这是(最有可能)4 / 1 = 4 .

5. 你的 "test"用于初始化的正好有 4 个字母，你的运气。