c++ - 如何在具有动态大小数组的模板类中重载 operator=

Question

我刚开始使用 C++ 创建自己的模板类，在网上搜索了几个小时的答案并研究了函数及其参数之后，我放弃了。我在使用以下类的“=”运算符时遇到了运行时问题:

在 matrix.h 中:

template <class datatype> class Matrix{
  datatype** element;
  unsigned int m,n;

  public:

  Matrix(unsigned int M, unsigned int N,datatype x){
    m=M;    // # of rows
    n=N;    // # of cols
    element=new datatype*[m];
    for(int i=0;i<m;i++) element[i]=new datatype[n];
    for(int i=0;i<m;i++)
      for(int j=0;j<n;j++)
        element[i][j]=x;
  }

  void print(){
    for(int i=0;i<m;i++){
      for(int j=0;j<n;j++) cout<<element[i][j]<<" ";
      cout<<"\n";
    }
  }

  Matrix operator=(Matrix A){
    for(int i=0;i<m;i++) delete[] element[i];
    delete[] element;
    m=A.m;
    n=A.n;
    element=new datatype*[m];
    for(int i=0;i<m;i++) element[i]=new datatype[n];
    for(int i=0;i<m;i++)
      for(int j=0;j<n;j++)
        element[i][j]=A.element[i][j];
    return *this;
  }
};

当我去测试这个时，编译和链接运行顺利，没有错误，我得到了一个完全有效的打印。但是当试图将一个矩阵分配给另一个矩阵的值时，程序崩溃并显示消息“matrix_test 已停止工作”。这是我的测试代码，在 matrix_test.cpp 中:

Matrix<int> M(5u,3u,0);
Matrix<int> P(2u,7u,3);

int main(){
    M.print();
    cout<<"\n";
    P.print();
    cout<<"\n";
    P=M;
    P.print();        
}

在此先感谢您的帮助!

Answer 1

首先，您的复制分配的实现存在一个相当根本的缺陷:当您删除[] 表示然后分配一个新拷贝时，分配可能会抛出这种情况，在这种情况下您的原始矩阵是 delete[]d 且无法恢复。因此，分配不是异常安全的。

复制赋值运算符的最佳实现是利用复制构造和 swap() 成员。当然，这两个成员都没有出现在您的类(class)中，但让我们稍后再谈:

Matrix& Matrix::operator= (Matrix other) {
    other.swap(*this);
    return *this;
}

按值传递参数时，实际上是在复制它。要复制对象，您需要一个复制构造函数。一般来说，如果你需要一个复制赋值，你通常还需要一个复制构造函数和一个析构函数(在某些情况下，你只需要一个复制赋值来使复制赋值具有很强的异常安全性，但这是一个不同的讨论)。

复制构造函数的目的是复制另一个对象，例如，当对象按值传递时:

Matrix::Matrix(Matrix const& other)
    : element(new datatype*[other.m])
    , m(other.m)
    , n(other.n)
{
    int count(0);
    try {
        for (; count != m; ++count) {
            this->element[count] = new datatype[m];
            std::copy(other.element[count], other.element[count] + m,
                      this->element[count]);
        }
    }
    catch (...) {
        while (count--) {
            delete[] this->element[count];
        }
        delete[] this->element;
        throw;
    }
}

我不确定从异常中恢复是否真的正确:我无法处理处理所有这些指针的复杂性!在我的代码中，我会确保所有资源立即构造一个专用于自动释放它们的对象，但这需要更改对象的类型。给定类型的定义，还需要一个析构函数:

Matrix::~Matrix() {
    for (int count(this->m); count--; ) {
        delete[] this->element[count];
    }
    delete[] this->element;
}

最后，对于较大的对象，swap() 成员通常很方便。 swap() 的目的只是交换两个对象的内容。实现它的方法是做一个memberwise std::swap():

void Matrix::swap(Matrix& other) {
    using std::swap;
    swap(this->element, other.element);
    swap(this->n, other.n);
    swap(this->m, other.m);
}

鉴于该类的所有成员都是内置类型(尽管它们可能不应该是)，所以并不真正需要 using Action 。但是，如果对于用户定义的类型，除 std::swap() 之外的其他命名空间中存在 swap() 的专门重载，上述方法可确保它们被找到参数依赖查找。