在类中声明一个数组，并用构造函数设置它的大小

Question

我已经有一段时间没有使用 c++ 了，但我刚刚开始使用它进行项目。这可能是不可能的，但我试图用一个数组创建一个模板类，该数组将其大小设置为我试图用构造函数设置的常量的值。

这是构造函数的代码：

Tarray(int s): start_size(s){
    }

这是设置数组大小的代码：

const int start_size;
T this_array[start_size];

这是整个文件：

#ifndef TARRAY_H_
#define TARRAY_H_


template<typename T>
class Tarray {
private:
    const int start_size;
    T this_array[start_size];
    int array_size;
public:
    Tarray(int s): start_size(s){
    }
    ~Tarray(){
        delete[] this_array;
    }
    T & operator[](int i){
        return this_array[i];
    }
};



#endif /* TARRAY_H_ */

这些是我得到的错误：

..\/template_array/Tarray.h:16:24: error: 'Tarray<T>::start_size' cannot appear in a constant-expression
..\/template_array/Tarray.h:16:34: error: 'new' cannot appear in a constant-expression
..\/template_array/Tarray.h:16:34: error: ISO C++ forbids initialization of member 'this_array' [-fpermissive]
..\/template_array/Tarray.h:16:34: error: making 'this_array' static [-fpermissive]
..\/template_array/Tarray.h: In instantiation of 'Tarray<Person>':
..\Human.cpp:17:24:   instantiated from here
..\/template_array/Tarray.h:16:34: error: invalid in-class initialization of static data member of non-integral type 'Person*'
Build error occurred, build is stopped
Time consumed: 343  ms. 

当我尝试调整代码时，错误消息一直在发生变化，但这些是来自此特定构建的错误。

感谢您的帮助

Answer 1

您收到编译器错误的原因是这一行：

T this_array[start_size];

这一行将使您的Tarray 实际上包含start_size 的T 实例。它不会保存对这些实例的指针或引用——它们将是包含 Tarray 的其他实例变量的同一内存块的一部分。 这将使类的大小取决于 start_size，而 start_size 在编译时是未知的。任何 C++ 类的大小必须在编译时就知道，这是不可能的。

有两种方法可以解决这个问题：

1. 使用array new 在堆上分配T 实例数组。这就是std::vector 所做的。编写这样一个类并在它被复制/移动/扩展/等时让它表现正确是困难和乏味的，所以我建议只使用std::vector。
2. 固定T实例的数量，作为模板参数传递

即：

template<typename T, std::size_t N>
class TArray
{
    ...
    T this_array[N];
    ...
}

这就是 std::array（仅限 C++11）和 boost::array 所做的。同样，我建议使用其中之一，而不是自己编写。除非这是家庭作业，当然……

最后，值得注意的是这是一个错误：

~Tarray(){
    delete[] this_array;
}

this_array 没有分配给new，所以你不应该delete 它。如果数组是这里的类的一部分（而不是单独堆分配并由类拥有），那么默认情况下它将与类的其余部分一起被销毁。调用delete 不仅没有必要，而且几乎肯定会导致崩溃。

Answer 2

std::vector 正是这项工作的工具：

template<typename T>
class Tarray {
private:
    std::vector<T> this_array;
public:
    Tarray(int s): this_array(s){
    }
    ~Tarray(){
    }
    T & operator[](int i){
        return this_array[i];
    }
};

Answer 3

以下代码做了类似的事情，但不使用构造函数：

#ifndef TARRAY_H_ 
#define TARRAY_H_ 


template<int SizeT> 
class Tarray { 
private: 
    T this_array[SizeT]; 
public: 
    Tarray() {} 
    ~Tarray() {} 
    T & operator[](int i){ 
        return this_array[i]; 
    } 
}; 

#endif /* TARRAY_H_ */ 

你可以这样使用它：

TArray<10> myArray;

Answer 4

您必须在运行时创建数组。

template<typename T>
class Tarray {
private:
    const int start_size;
    T* this_array;
    int array_size;

    Tarray( const Tarrat& inObj ); // no copy

public:
    Tarray(int s): start_size(s), this_array( new T[s] ) {
    }
    ~Tarray(){
        delete[] this_array;
    }
    T & operator[](int i){
        return this_array[i];
    }
};

注意，要使其工作，T 必须有一个默认构造函数（即，一个不带参数的构造函数）。

Answer 5

改用 std::vector，让自己的生活变得简单。 :)

（如果你想要一个固定大小的数组，那么 std::array 可能是一种可能性，我认为这是在 C++11 中，如果没有，那么 boost 可能有一个实现）。

如果你坚持使用普通的数组语法，就像你使用 ye-olde C 一样，那么你将需要使用模板参数，这样你的模板类就有两个参数 - 一个用于 'T'它现在已经有了，另一个用于数组大小。

你自己管理那个数组会让你的生活变得特别困难——如果你觉得你必须定义一个析构函数，那么除了构造函数之外，你真的应该定义复制构造函数。 （如果我没记错的话，这就是所谓的三巨头规则），而是依赖 RAII，避免自己显式调用 operator delete 或 delete[]。