C++ 动态多维数组错误的重载赋值运算符

Question

我在使用动态数组重载 = 运算符时遇到了问题。这是我到目前为止所拥有的。我也知道我还没有写我的析构函数或构造函数，但我需要先关注这个运算符：

在我的头文件中：

#ifndef fasdf_dynn_h
#define fasdf_dynn_h

#include <iostream>
#include <fstream>
#include<string>
#include <cstdlib>
#include <vector>

using namespace std;
template <class T>

class MatrixdynVector{

public:
    template <class H>
    MatrixdynVector<H>& operator =(const MatrixdynVector<H>& c)
    {
        if (this == &c)//checks for self assignment
        {
            return *this;
        }
        else
        {
          delete [] matrix;
          matrix=new int[c.m*n];
          this->m=c.m;
          this->n=c.n;
          return *this;

        }
    }
private:
    int m,n;
    int** matrix;
};


#endif

Answer 1

我现在只关注主要问题；

第一，您正在为新数据数组分配 c.m * this->n 内存，我假设您要分配 c.m * c.n 内存。

最后，我强烈建议您仔细查看复制构造函数，因为删除函数可能会在 return 这种类型的矩阵时导致数据损坏。

具体来说，如果您曾经在堆栈上分配此 class，请不要创建一个明确的复制构造函数，并且不要确保您总是 return 一个副本，即对象的数据最后将被删除（我假设您将在析构函数中删除 [] 'matrix'），并且 returned 对象将 'matrix' 指向已删除的数据。我在制作自己的矩阵 class.

时遇到了这个问题

如果你绝对想要一个多维数组，你可以像这样创建它；

matrix = new int*[c.m];
for (int i = 0; i < c.m; i++)
  matrix[i] = new int[c.n]; // create a multi dimensional array

for (int i = 0; i < c.m; i++)
  for (int j = 0; j < c.n; j++)
    matrix[i][j] = c.matrix[i][j]; // add data to it

我差点忘了，对于析构函数，您还需要使用 for 循环删除矩阵；

for (int i = 0; i < c.m; i++)
  delete[] matrix[i]; // delete the second dimension of the matrix

delete[] matrix; // delete the first

这是一个拷贝构造函数的例子

MatrixdynVector<H>::MatrixdynVector(const MatrixdynVector<H>& oMat)
  : m(oMat.m), n(oMat.n), matrix(new int*[oMat.m]){
  for (int i = 0; i < m; i++){
    matrix[i] = new int[n];
    for (int j = 0; j < n; j++)
      matrix[i][j] = oMat.matrix[i][j];
  }
}

这个复制构造函数最重要的部分是参数是 const& 类型——如果不这样做，调用将变成递归的——并且正在创建一个副本。每当动态分配的内存属于一个对象时，必须非常小心地确保它有一个复制构造函数，每次调用它时都会分配新的内存，否则默认构造函数也会简单地将内存的所有权也交给副本，从而导致它与副本一起被删除。您还应注意，应尽可能使用引用来传递此类对象，因为使用副本重新分配内存非常昂贵。

C++ 动态多维数组错误的重载赋值运算符

C++ Overloading assignment operator for dynamic multi dimensional array error

c++

overloading

assignment-operator

rule-of-three