涉及指针和手动实现矩阵类的问题

问题描述 投票：2回答：1

我目前正在做一个更大的项目，涉及到实现一个线性代数计算器。我决定不使用任何其他已经存在的可能帮助我实现它的库，因为我认为这太容易了。

我首先开始编写Matrix类的代码，现在它的样子是这样的。

class Matrix{
private:
    int rows; // no. rows
    int columns; // no. columns
    double** matVal; //values of the matrix
    char name; //only used when printing it out or by outside programs.
public:
    //constructors and destructor
    Matrix();
    Matrix(int r,int c,char _name);
    ~Matrix();

    //basic get functions for private access
    int getNrRows();
    int getNrCols();
    char getName();
    double getVal(int row,int col);

    //basic set functions for private variables
    void setVal(int row,int col,double value);
    void setName(char _name);

    //basic matrix operations
    Matrix operator=(Matrix M);
    Matrix operator+(Matrix M);
    Matrix operator-(Matrix M);
    Matrix operator*(Matrix M);

    //Printing out the matrix
    void Print();
};

一开始很顺利，但后来我遇到了一个致命的错误，使我无法继续前进。为了提供更多信息，这里是我的函数（+一些代码来试图找出问题所在）和我在main()中执行的内容。

#define cout std::cout

Matrix::Matrix(){
    rows = 0;
    columns = 0;
    matVal = nullptr;
}

Matrix::Matrix(int r,int c,char _name){
    rows = r;
    columns = c;
    name = _name;
    matVal = new double*[r];
    for(int i = 0; i < r; i++){
        matVal[i] = new double[c];
    }
    for(int i = 0; i < r; i++){
        for(int j = 0; j < c; j++){
            matVal[i][j] = 0;
        }
    }
}

Matrix::~Matrix(){
    for (int i = 0; i < rows; i++)
        delete[] matVal[i];
    delete[] matVal;
}

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

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

char Matrix::getName(){
    return name;
}

double Matrix::getVal(int row, int col){
    return matVal[row-1][col-1];
}

void Matrix::setVal(int row,int col,double value){
    matVal[row-1][col-1] = value;
}

void Matrix::setName(char _name){
    name = _name;
}

Matrix Matrix::operator=(Matrix M){
    for (int i = 0; i < rows; i++)
        delete[] matVal[i];
    delete[] matVal;

    rows = M.rows;
    columns = M.columns;

    matVal = new double*[rows];

    for(int i = 0; i < rows; i++){
        matVal[i] = new double[M.columns];
    }

    for(int i = 0; i < M.rows; i++){
        for(int j = 0; j < M.columns; j++){
            matVal[i][j] = M.matVal[i][j];
            cout<<matVal[i][j]<<' ';
        }
        cout<<'\n';
    }
    cout<<this<<std::endl;
    return *this;
}

Matrix Matrix::operator+(Matrix M){
    Matrix Rez;
    Rez.rows = rows;
    Rez.columns = columns;
    for(int i = 0; i < rows; i++){
        for(int j = 0; j < columns; j++){
            Rez.matVal[i][j] = matVal[i][j] + M.matVal[i][j];
        }
    }
    return Rez;
}

void Matrix::Print(){
    cout<<'\n';
    cout<<name<<": "<<"\n";
    for(int i = 0; i < rows; i++){
        for(int j = 0; j < columns; j++){
            cout<<matVal[i][j]<<' ';
        }
        cout<<'\n';
    }
    cout<<'\n';
    return;
}

Main:

Matrix M(4,3,'A');
M.setVal(1,1,2);
M.setVal(1,3,-1.1);
M.Print();
Matrix A(4,3,'B');
A.setVal(3,2,5);
A.Print();
Matrix C(4,3,'C');
C = A;
cout<<C.getVal(3,2)<<'\n';
cout<<C.getNrCols()<<" "<<C.getNrRows()<<endl;
C.Print();
cout<<"S"<<endl;

打印前2个矩阵工作正常，当我在operator=函数中给C的每个元素分配适当的值后，再次打印，工作正常，但当我在C上使用Print()函数时，它崩溃了。下面是上面代码的控制台输出。

A:
2 0 -1.1
0 0 0
0 0 0
0 0 0


B:
0 0 0
0 0 0
0 5 0
0 0 0

0 0 0
0 0 0
0 5 0
0 0 0
0x69fed0
5
3 4

C:

一开始我完全不知道它为什么会这样，但后来我把每个变量的指针打印出来代替（这次它把所有的变量都打印出来并返回0）。

A:
0x850e38 0x850e40 0x850e48
0x851318 0x851320 0x851328
0x851338 0x851340 0x851348
0x851358 0x851360 0x851368


B:
0x851390 0x851398 0x8513a0
0x8513b0 0x8513b8 0x8513c0
0x8513d0 0x8513d8 0x8513e0
0x855b08 0x855b10 0x855b18

0x855b40 0x855b48 0x855b50
0x855b60 0x855b68 0x855b70
0x855b80 0x855b88 0x855b90
0x855ba0 0x855ba8 0x855bb0
0x69fed0
5
3 4

C:
0 0x8 0x10
0 0x8 0x10
0 0x8 0x10
0 0x8 0x10

S

现在我认为是打印函数出了问题(否则为什么我能够在main中打印出5个变量?)。我还是不知道到底发生了什么，所以请大家帮忙。如果这是一个菜鸟的错误，我很抱歉，我还是很没有经验的。

我还忘了补充一点，类和类函数是在不同的文件中（header和cpp），虽然我不知道这对事情有什么影响。

c++ class pointers matrix dynamic-memory-allocation
1个回答
2
投票

签名 Matrix operator=(Matrix&); 在另一个答案中提出，它完全错误。正确的签名应该是

Matrix& operator=(const Matrix&);

或

void operator=(const Matrix&);

如果您不需要任务链(a = b = c).

最起码要实现：复制构造函数，复制赋值，和destructor。对于一个矩阵类，实现移动操作也是合理的。这就是所谓的 "移动操作"。零点五法则 (在我们这里是五个)。

如果一个类不需要用户定义的构造函数，不需要用户定义的赋值操作符，也不需要用户定义的析构函数，那就不要定义它们；如果一个类需要用户定义的析构函数，用户定义的复制（和移动）构造函数，或者用户定义的复制（和移动）赋值操作符，那么几乎可以肯定，它需要这三个（5个）。

我们假设矩阵内部用1D数组表示。这种方法避免了矩阵元素访问的不必要的间接性，简化了代码。

class Matrix {
public:
    Matrix(const Matrix&);
    Matrix(Matrix&&);

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

    ~Matrix();

private:
    double* data_        = nullptr;
    std::ptrdiff_t rows_ = 0;
    std::ptrdiff_t cols_ = 0;
};

复制操作应该是 深入即它们应该复制数据，而不仅仅是底层指针。让我们从复制构造函数开始。它应该分配存储空间，然后将数据从 other 到这个存储空间。

Matrix(const Matrix& other) 
: rows_(other.rows_), cols_(other.cols_) {
    const auto n = other.rows_ * other.cols_;
    data_ = new double[n];
    std::copy(other.data_, other.data_ + n, data_);
}

现在让我们实现 swap:

void swap(Matrix& other) {
    std::swap(rows_, other.rows_);
    std::swap(cols_, other.cols_);
    std::swap(data_, other.data_);
}

这个函数非常有用，因为它让我们几乎不需要任何代码就可以实现移动构造函数、复制赋值和移动赋值。

Matrix(Matrix&& other) {
    swap(other);
}

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

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

有了这样的规范实现，你就可以确信，一旦你正确地实现了复制构造函数和自赋值处理，这些函数就会被正确地实现（包括自赋值处理）。swap. 欣赏的优雅。抄来抄去.

现在我们来谈谈 operator+. 看看这个实现。

Matrix operator+(Matrix other) const {
    assert(rows_ == other.rows_);
    assert(cols_ == other.cols_);

    const auto n = rows_ * cols_;
    for (std::ptrdiff_t i = 0; i < n; ++i)
        other.data_[i] += data_[i];
    return other;
}

在这里，我们通过取值来获取参数，并得到一个（深度）副本。然后我们添加 this->data_ 到副本，并返回该副本。没有必要再引入一个本地的 Matrix 变量。

完整的演示

0
投票

你可以把 operator= 函数改成这种形式。

Matrix operator=(Matrix &M);

在定义中你应该把它的返回改为：

return M;

我检查过了，在operator+(和*)中，也考虑到了这一点。

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.