Question

假设我有一个类Matrix，其构造函数如下：

Matrix::Matrix(int rows, int cols)
{
    nrows = a; //here nrows is the number of rows for each matrix 
    ncols = b; //here ncols is the number of cols for each matrix
    p = new double [rows*cols];
    for(int i=0;i<rows*cols;i++) 
        { 
            *p++ = 0.0;
        }
}

假设我还有一份副本＆＃39;构造函数如下：

Matrix::Matrix(const Matrix& mat)
{   p = new double[mat.nrows*mat.ncols];
    for(int i=0;i<mat.nrows*mat.ncols;i++)
        { 
             p[i] = mat.p[i];

        }
}

现在还假设我的主要功能中有以下几行：

int main()
    {
        Matrix A(2,2);
        Matrix B(2,2);
        A = Matrix(B); //call overloaded assignment operator, and copy ctor/
     }

这里＆＃39; =＆＃39;运算符重载以将B中的所有元素分配给A. 我的问题是，一旦调用了复制构造函数，Matrix A对象就是一个全新的对象。

有没有更好的方法来编写复制构造函数，这样如果Matrix A已经存在，那么调用A = Matrix（B）会导致错误？

Answer 1

我建议使用std::vector

，而不是使用动态分配的数组

class Matrix
{
public:
    Matrix(long rows, long cols);
private:
    long nrows;
    long ncols;
    std::vector<double> p;
}

然后你的构造函数可以

Matrix::Matrix(long rows, long cols)
: nrows(rows),
  ncols(cols),
  p(rows * cols)
{ }

与动态分配的数组使用std::vector的{{3}}一起，您现在可以获得编译器生成的复制构造函数，因此您不需要编写一个。

如果您不希望您的类可复制，delete复制构造函数和复制赋值运算符。

class Matrix
{
public:
    Matrix(long rows, long cols);
    Matrix(const Matrix& mat) = delete;
    Matrix& operator=(const Matrix& mat) = delete;
private:
    long nrows;
    long ncols;
    std::vector<double> p;
}

Answer 2

声明

A = Matrix(B);

首先使用copy-constructor创建临时对象。然后在赋值中使用此临时对象。

所以使用复制构造函数是正确的，但不是作为赋值的一部分。

Answer 3

远更好删除赋值运算符：

Matrix& operator=(const Matrix&) = delete;

然后使用A = Matrix(B)会发出编译时错误。然后，您将被迫使用构造函数，您的具体问题将不再适用。

Answer 4

没有。因为那时它不会是一个副本构造函数。构造函数构造。

如何正确指定复制构造函数

4 个答案: