Question

我需要一些帮助来实现我的类中的动态数组的复制构造函数和operator =。 此时不允许使用矢量

这是我的代码：类：

    class Matrix{
    private:
        int rows;
        int columns;
        double* matrix;
    public:
        Matrix();
        explicit Matrix(int N);
        Matrix(int M, int N);
        void setValue(int M, int N, double value);
        double getValue(int M, int N);
        bool isValid() const;
        int getRows();
        int getColumns();
        ~Matrix();
        friend ostream& operator<<(ostream &out, Matrix&matrix1);       
};

我的代码：

Matrix::Matrix(){
    matrix = NULL;
}

Matrix::Matrix(int N){
    matrix = new double[N * N];
    rows = N;
    columns = N;

    for(int i = 0; i < N; i++){
        for(int j = 0; j < N; j++){
            if(i==j)
                matrix[i * N + j] = 1;
            else
                matrix[i * N + j] = 0;
        }
    }
}

Matrix::Matrix(int M, int N){
    matrix = new double[M * N];
    rows = M;
    columns = N;

    for(int i = 0; i < M; i++){
        for(int j = 0; j < N; j++)
            matrix[i * N + j] =  0;
    }
}

Matrix::~Matrix(){
    delete [] matrix;
}

void Matrix::setValue(int M, int N, double value){
    matrix[M * columns + N] = value;
}

double Matrix::getValue(int M, int N){
    return matrix[M * columns + N];
}

bool Matrix::isValid() const{
    if(matrix==NULL)
        return false;
    else
        return true;
}

int Matrix::getRows(){
    return rows;
}

int Matrix::getColumns(){
    return columns;
}

ostream& operator<<(ostream &out, Matrix&matrix1){
    if(matrix1.isValid())
        for(int i = 0; i < matrix1.getRows(); i++){
            for(int j = 0; j < matrix1.getColumns(); j++)
                out << matrix1.getValue(i,j) << "\t";
            out << endl;
        }
    else
        out << "Matrisen er ikke gyldig."; //the matrix is not valid
    return out;
}

这样的事情会起作用吗？

Matrix &operator=(const Matrix &m) {*(this->matrix) = *(m.matrix);}
Matrix(const Matrix &rhs) : matrix(0) {
        this->matrix = new double();
        *(this->matrix) = *(rhs.matrix);
    }

我还要重载运算符+ =和+。我试图将其实现为：

const Matrix operator+=(Matrix matrix1, Matrix matrix2){
        if(!matrix1.isValid() || !matrix2.isValid()){
            cout << "En av matrisene er ugyldig"; //one of the matrices are invalid
            return Matrix::Matrix(); //returning a NULL matrix
        }
        else{
            if(matrix1.getColumns()==matrix2.getColumns() && matrix1.getRows()==matrix2.getRows()){
                Matrix temp(matrix1.getRows(), matrix1.getColumns());
                for(int i = 0; i < matrix1.getRows(); i++){
                    for(int j = 0; j < matrix1.getColumns(); j++)
                        temp.setValue(i,j,(matrix1.getValue(i,j) + matrix2.getValue(i,j)));
                }
                return temp;
            }
            else{
                cout << "Matrisene har ikke samme dimensjon"; //the matrices does not have the same dimensions
                return Matrix::Matrix();
            }
        }
    }
    const Matrix operator+(Matrix matrix1, Matrix matrix2){
        return matrix1 += matrix2;
    }

这样的事情会起作用吗？将操作符作为类的一部分，类的朋友还是在类之外重载是否更好？

任何帮助都是适当的。

Answer 1

为什么要删除其他问题？我希望这只是一个错误:(见最后的编辑）

是的，您的代码中存在许多问题，甚至在您的设计中也存在问题。

只是为了给你一个想法：

您的Matrix没有复制构造函数（或移动），也没有“=”。他们是：

Matrix(const Matrix &m);

和（移动构造函数）：

Matrix(Matrix &&m);

和

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

如果您没有定义这些特殊功能，编译器将为您定义它。但他们只会显然有效。程序编译但工作错误（浅层与深层复制问题，按值或按引用传递）。我认为你在构造函数中使用new来构建matrix私有数组。在析构函数中delete[]matrix。每次传递Matrix值时，都会使用编译器生成的复制构造函数进行复制，只需复制Matrix成员的值，从而复制指针{{1}的值但不是数组。在通话结束时，本地副本将被破坏，您的原始矩阵将被删除！这只是众多问题中的一个。足够让你坐下来，更多地阅读垃圾，然后再试一次。一个“简单”的修复可能会取代

matrix

通过

 double *matrix;

现在编译器生成的函数会更好用。

是的，如果您想将std::vector<double> matrix;与[]一起使用，则需要对其进行定义。 Matrix是一个二元运算符，它接受一个参数（左边总是+=，一个指向对象的指针，并调用它）。在这里，您只需要一个带有2个参数的免费this或一个带有一个+()的成员。希望这对你有所帮助。再问一次。

编辑：这是+()吗？

operator=

不，这只会复制第一个双倍。您需要在entery数组上循环并复制每个元素。首先，您需要确保矩阵的大小是兼容的。（如果您使用Matrix &operator=(const Matrix &m) {*matrix = *(m.matrix);} vector将起作用。）。复制构造函数的修复可能是：

matrix=m.matrix

移动：

Matrix::Matrix(const Matrix &m):   rows    (m.rows), 
                                   columns (m.columns), 
                                   matrix  (new double[rows* columns]) 
{
    for(int i = 0; i < rows; i++)
        for(int j = 0; j < columns; j++)
            matrix[i * columns + j] =  m.matrix[i * columns + j];

}

当您不关心原始值时，此移动可以显着提高应对Matrix的效率，例如，具有临时对象的情况。在这种情况下，您不需要迭代复制每个数组元素：您只需窃取整个数组。好的一点是，在大多数情况下，编译器会为您自动选择正确的变体（复制或移动）。

Answer 2

Matrix &operator=(const Matrix &m) {*(this->matrix) = *(m.matrix);}

这只会将lhs'矩阵的第一个元素指定为与rhs'矩阵的第一个元素相同。最重要的是，这需要使用相同数量的行和列初始化两个矩阵。您可以使用memcpy或循环来分配所有元素。

Matrix(const Matrix &rhs) : matrix(0) {
    this->matrix = new double();
    *(this->matrix) = *(rhs.matrix);
}

这将失败，因为您没有为新构造的实例的矩阵成员分配足够的内存（除非另一个矩阵是1x1矩阵）。假设矩阵以行主顺序存储，它应该如下所示：

Matrix(const Matrix &rhs) : matrix(0), rows(rhs.rows), columns(rhs.columns) {
    this->matrix = new double[rows * columns];
    for (size_t r = 0; r < rows; r++) {
       for (size_t c = 0; c < columsn; c++) {
          this->matrix[r * columns + c] = rhs.matrix[r * columns + c];
       }
    }
}

编辑：只是为了确保，这是我将如何进行赋值运算符：

Matrix &operator=(const Matrix &m) {
    if (rows * columns != m.rows * m.columns) {
        delete [] this->matrix;
        this->matrix = new double[m.rows * m.columns];
    }
    rows = m.rows;
    columns = m.columns;
    for (size_t r = 0; r < rows; r++) {
       for (size_t c = 0; c < columsn; c++) {
          this->matrix[r * columns + c] = m.matrix[r * columns + c];
       }
    }
    return *this;
}

复制构造函数和operator =以获取类中的动态数组

2 个答案: