用 C++ 设计多维数组

Question

我想为多维数组设计一个 C++ 类。我所说的多维是指 1d、2d、3d 等。该类支持逐个元素加法和标量乘法运算符。假设 A 和 B 是该类的实例（具有相同的大小和维度）。我想在这样的表达式中使用对象：

C = A * 2 + B

我想知道的是如何管理内存。在上面的表达式中，A * 2会创建一个该类的临时对象，稍后将其添加到B中。无论如何，添加完成后该临时对象就是垃圾。我写了下面的类，它运行得很好，但我很确定它会泄漏内存。现在我的问题是，

1. 如何解决内存问题？设计课程的最佳方式是什么？

2. 是否可以在堆栈而不是堆上分配所需的内存？

   类 XArray
   {
       int num_dim；
       int * 变暗；
       int *index_helper;
       int 表大小；
       双*表；
   
   
   民众：
       XArray(const int n, const int *d):num_dim(n), dims(d)
       {
           整数大小=1；
           for (int i = 0; i < n; i++) {
               大小 *= d[i];
           }
           表大小=大小；
           表=新双[大小]；
           index_helper = 新的 int[n];
       };
   
       ~XArray()
       {
           删除[]表；
           删除[]索引助手；
       };
   
       int 暗淡（int d）
       {
           返回暗淡[d]；
       }
   
       双&运算符()(int i)
       {
           索引助手[0] = i;
           返回 get_helper(1,index_helper);
       }
   
       双&运算符()(int i, int j)
       {
           索引助手[0] = i;
           index_helper[1] = j;
           返回 get_helper(2,index_helper);
       }
   
       双&运算符（）（int i，int j，int k）
       {
           索引助手[0] = i;
           index_helper[1] = j;
           index_helper[2] = k;
           返回 get_helper(3,index_helper);
       }
   
       XArray 运算符*(double m)
       {
           XArray *xa = new XArray(num_dim, dims);
           for (int i = 0; i < table_size; i++) {
               xa->table[i] = this->table[i] * m;
           }
   
           返回*xa；
       }
   
       XArray 运算符+(const XArray &that)
       {
           if (num_dim != that.num_dim) {
               char *msg = 新的 char[100];
               sprintf(msg, "XArray::dimensions 在 + 操作中不匹配，预期 %d，找到 %d", num_dim, that.num_dim);
               抛出消息；
           }
   
           for (int i = 0; i < num_dim; i++) {
               if (this->dims[i] != that.dims[i]) {
                   char *msg = 新的 char[100];
                   sprintf(msg, "XArray::dimension %d 未加工, %d != %d", i, dims[i], that.dims[i]);
                   抛出消息；
               }
           }       
   
           XArray *xa = new XArray(num_dim, dims);
           for (int i = 0; i < table_size; i++) {
               xa->table[i] = this->table[i] + that.table[i];
           }
   
           返回*xa；
       }
   
   私人的：
       双& get_helper(int n, int *索引)
       {
           如果（n！= num_dim）{
               char *msg = 新的 char[100];
               sprintf(msg, "XArray::尺寸不匹配，预期 %d，找到 %d", num_dim, n);
               抛出消息；
           }
   
           整数乘数=1；
           整数索引 = 0；
   
           for (int i = 0; i < n; i++) {
               if (indices[i] < 0 ||indexs[i] >= dims[i]) {
                   char *msg = 新的 char[100];
                   sprintf(msg, "XArray::index %d 超出范围，%d 不在 (0, %d) 中", i, Index[i], dims[i]);
                   抛出消息；
               }
   
               索引 += 索引[i] * 乘数；
               乘数 *= dims[i];
           }
   
       返回表[索引]；
   }
   

   };

Answer 1

我怀念复制构造函数和赋值运算符。您将需要它们来复制内部缓冲区，而不仅仅是复制指针，否则您最终将释放相同的内存两次。

如果您要支持 c++0x，您可能还需要实现移动语义以获得最佳性能。

像您所做的那样抛出动态分配的对象是一个非常糟糕的主意。

在您的运算符*中，您应该在堆上创建对象：

XArray operator*(double m)
{
    XArray xa(num_dim, dims);
    for (int i = 0; i < table_size; i++) {
        xa->table[i] = this->table[i] * m;
    }

    return xa;
}

但是，只要您不编写（移动）复制构造函数，这就会崩溃。因为 return 语句将创建一个引用与 xa 相同的内部数据的副本。 xa 将被销毁，它的析构函数将销毁其内部数据。因此，返回的临时对象在内部指向已损坏的数据。

编辑：

链接到有关移动语义或右值引用的信息

Answer 2

我建议执行以下操作以避免内存泄漏：

1. 将复制构造函数和operator = ()设为private并未实现以避免table 和 index_helper 被覆盖（并意外导致内存泄漏）。如果您希望使用它们，那么请确保，在重新分配给避免泄漏。
2. 对于错误消息，请使用 std::string
   而不是 char *msg = new
字符[100]；。它更加干净和
   可维护。
3. 不要使用 XArray *xa = new
   XArray(num_dim, 暗淡);;反而
   只需将其声明为 XArray xa; 即可。
   它将被堆叠并上紧
   自动（如果您有c++0x支持，那么您可以选择完美转发以消除不必要的副本）

现在关于您剩余的class设计，答案将非常主观，需要详细的代码分析。所以，我将由你来决定。

Answer 3

这个问题可能应该在代码审查中而不是在这里。但设计上的一些事情：

手动管理内存通常不是一个好主意，您应该更喜欢使用现有容器而不是动态分配的数组。构造函数获取传入指针的所有权这一事实并不常见，并且可能会导致用户代码出现问题。目前您不允许某些用途，例如：

int dims[3] = { 3, 4, 5 };
XArray array( 3, dims ); // or use sizeof(dims)/sizeof(dims[0]), or other trickery

对于用户代码来说，这比：

int ndims = 5;
int *dims = new int[ndims]
XArray array( ndims, dims );

这也意味着用户必须知道 dims 所有权已被获取并且他们无法删除 指针。

在内部，我会使用 std::vector 来维护动态内存，因为这将免费为您提供正确的语义。事实上，您需要实现复制构造函数和赋值运算符（或禁用它们），因为当前代码不会泄漏，但可能会尝试双重释放一些内存。请记住三者的规则：如果您提供复制构造函数、赋值运算符或析构函数中的任何一个，您可能应该提供所有三个。

您的 operator* 和 operator+ 泄漏内存（XArray 对象本身作为内部内存实际上是由缺席处理的复制构造函数，但不要认为这是不创建复制构造函数的原因，相反，您必须创建它）

允许抛出char*，但出于不同的原因，我建议您不要这样做。异常的类型应该提供有关发生了什么的信息，否则您的用户代码将必须解析异常的内容以确定出了什么问题。即使您决定使用单一类型，请注意，重载解析中使用的相同规则不适用于异常处理，特别是您可能会遇到未发生转换的问题。这也是设计中内存泄漏的另一个可能性，就像在抛出一个指向动态分配内存的指针时，如果用户没有释放内存，或者如果用户实际上没有释放内存，那么您将释放内存的责任委托给了用户。关心异常并只捕获所有内容（ catch (...) {} ），您将泄漏错误。

如果您的程序中可以这样做，那么最好不要抛出，而是断言（这是一个设计决策：错误的大小有多么糟糕，即使例外也可能发生，或者不应该发生的事情？）。

成员 index_helper 不属于该类，它是仅由不同 operator() 和 get_helper() 共享的实现细节> 方法，您应该将其从类中删除，并且可以在每个 operator() 中静态分配它。还有一点奇怪的是，您为 1、2 和 3 维提供单独的 operator()，而代码是通用的来处理任何 维度，而且您是实际上要求用户知道在公共接口之外，有两个操作是被禁止的，这也不是一个很好的设计。