Question

我试图在我创建的矩阵类上使用运算符重载和+和=运算符。无论是构造函数还是析构函数导致问题，或者它都没有问题（尽管我将每个问题都变为灰色，并且两者都显得有效）有人可以帮我理解导致这种奇怪行为的原因。当我尝试创建3个矩阵a b和c然后尝试a = b + c;它失败了。

header file
#ifndef MATRIX_H;
#define MATRIX_H;
using namespace std;


enter code here

class matrix
{
friend ostream& operator<< (ostream&, matrix &);
public:
    matrix();
    matrix(int,int); //constructor
    matrix(const matrix&);//copy constructor
    ~matrix();
    int getRow();
    int getCol();
    void setRow(int);
    void setCol(int);
    class arr1D{                //proxy class to allow the use of [][]       operator
        public:
        arr1D(int* a):temp(a){}
        int &operator[](int a){
            return temp[a];
        }
        int *temp;
    };
    arr1D operator[](int a){
    return arr1D(arr2[a]);
    }
    matrix& operator=(const matrix& );

    matrix& operator+(const matrix& );

protected:
private:
    int row , col;
    int **arr2;

   };

   #endif // MATRIX_H

enter code here
cpp file
#include <iostream>
#include "matrix.h"

using namespace std;

matrix::matrix()
{
setCol(0);
setRow(0);
**arr2=0;
}


matrix::matrix(int x, int y) //matrix constructor creates x*y matrix and                 initializes to 0's
{
setCol(y);
setRow(x);
arr2 = new int * [getRow()];
if (arr2) {
    for (int i = 0; i < getRow(); i++) {
        arr2[i] = new int [getCol()];

    };
};
for (int i=0; i<getRow();i++){
    for (int j=0;j<getCol();j++){
        arr2[i][j]=0;
    };
};
}

matrix::matrix(const matrix &m){ //defines the copying constructor
 row=m.row;
 col=m.col;
arr2 = new int*[row];
for (int i=0; i<row; i++){
    arr2[i] = new int[col];
    }
for (int i=0; i<row; i++){
    for (int j=0; j<col; j++){
        arr2[i][j] = m.arr2[i][j];
    }
 }

}

 matrix::~matrix(){ //defines the destructor
 for (int i=0; i<row; i++){
    delete[] arr2[i];
    }
delete[] arr2;
}


int matrix::getRow(){ //getter for row
return row;
}

int matrix::getCol(){ // getter for col
return col;
}

void matrix::setRow(int x){ //setter for row
row=x;
}

void matrix::setCol(int x){ //setter for col
col=x;
 }


ostream& operator<< (ostream& output, matrix& a){
     int i,j;
     for (i=0; i < a.getRow() ; i++){
        for (j=0; j< a.getCol() ; j++){

            output << " " <<a.arr2[i][j];

        };
         output << "\n";
     };
return output;
}

matrix& matrix::operator=(const matrix& right)
{
if (this == &right) {     // Same object?
  return *this;
}
row = right.row;
col = right.col;
for (int i=0; i<row; i++)
{
  for (int j=0; j<col; j++){
    arr2[i][j]=right.arr2[i][j];
  }
}
return *this ;
}

matrix& matrix::operator+(const matrix& right)
{
int row=right.row;
int col=right.col;
matrix result(row,col);
for (int i = 0; i < row; i++){
    for (int j = 0; j < col; j++){
            //cout<<"arr2[i][j]="<<arr2[i][j]<<endl;
            //cout<<"right.arr2[i][j]="<<right.arr2[i][j]<<endl;
        result.arr2[i][j]=(arr2[i][j] + right.arr2[i][j]);
            //cout<<"result.arr2[i][j]="<<result.arr2[i][j]<<endl;
    };
 };
 return result;
 }

Answer 1

首先，正如另一个答案所指出的那样，您将在operator +中返回对临时的引用。这是未定义的行为。

但是，不是以这种方式编写operator +，而是应该编写operator +=代替，然后依次operator +编写operator +=。由于程序员除了+=之外还期望matrix也适用于+，因此忽略+=是没有意义的。

对于operator +=，在这种情况下，您将返回对当前对象的引用。

所以我们需要做的就是将operator +中的代码移到operator +=：

#include <exception>
//...
matrix& matrix::operator+=(const matrix& right)
{
    if(row != right.row || col != right.col)
       throw std::logic_error("Matrix not the same size");

    for (int i = 0; i < right.row; i++)
    {
        for (int j = 0; j < right.col; j++)
             arr2[i][j] += right.arr2[i][j]);
    }
    return *this;
 }

请注意，我们返回对当前矩阵的引用，因为+=修改了当前矩阵。另请注意，我们对发送到+=的非法矩阵抛出异常。这个IMO比返回错误的合法matrix更有意义。如果矩阵的大小不同，则代码不应尝试返回矩阵。

现在operator +可以用+=：

来编写

   matrix matrix::operator+(const matrix& right)
   {
      return matrix(*this) += right;
   }

信不信由你，就是这样。我们所做的只是创建一个临时矩阵，并使用传入的参数调用+=。我们将此结果作为一个全新的矩阵返回，就像我们期望的那样。

另一个问题是赋值运算符。鉴于您已编写了复制构造函数和析构函数，并且复制构造函数无需使用赋值运算符即可工作，则copy / swap idiom可用于实现赋值运算符。

   #include <algorithm>
   //...
   matrix& matrix::operator=(const matrix& right)
   {
      matrix temp(right);
      std::swap(temp.arr2, arr2);
      std::swap(temp.row, row);
      std::swap(temp.col. col);
      return *this;
   }

我们在这里所做的只是创建传入对象的临时矩阵，并用当前对象的内容交换其内容。当临时在返回时死亡时，临时销毁掉掉的旧内容。

这种方法的优点是不仅实现起来非常简单（只是对std::swap的一堆调用），它也是异常安全的。如果创建临时矩阵时出现问题，则会抛出std::bad_alloc异常，而不会弄乱或更改this的任何成员。给出了另一个答案的问题，即在分配新内存之前首先释放内存，使用上述技术解决了这个问题。

构造函数\析构函数或对OOP的理解

1 个答案: