Question

我正在寻找有关如何在重载运算符中使用this关键字的一些建议。我试过阅读它，但它并没有完全有意义，也许如果有人可以更深入地解释它？

我还提供了我的问题所在的代码，它意味着添加两个矩阵。我必须坚持const Matrix&论点。对于要添加的4行代码，我得到的当前错误为no match for ‘operator[]’ (operand types are ‘const Matrix’ and ‘int’)。

int array1[2][2] = {{5, 7}, {3, 2}}; //makes the 2 dimensional arrays used to represent the matrix 
int array2[2][2] = {{2, 3}, {1, 4}};
Matrix m2(array1);
const Matrix m3(array2);

cout << m2 << " + " << m3 << " = " << m2 + m3 << endl; //here is where the operator + comes into play. (The << operator was overloaded to work with this)
cout << m3 << " + " << m2 << " = " << m3 + m2 << endl << endl;

以上所有内容都在主程序中找到。下面我添加了属于.cpp的方法和类定义的一些（所需部分）。

Matrix Matrix::operator+(const Matrix& rightOp) const
{
Matrix addedMatrix;

addedMatrix.matrix[0][0] = *this->matrix + rightOp[0][0]; //current issue stands at these for lines
addedMatrix.matrix[0][1] = *this->matrix + rightOp[0][1]; //*this is used to represent the left operand of the expression, which points to the Matrix object that called the method
addedMatrix.matrix[1][0] = *this->matrix + rightOp[1][0];
addedMatrix.matrix[1][1] = *this->matrix + rightOp[1][1];

return addedMatrix;
}


Matrix::Matrix(const int newMatrix[][2]) //constructor where m2 and m3 are passed to
{
for(int row = 0; row < 2; row++)
    for(int col = 0; col < 2; col++)
        matrix[row][col] = newMatrix[row][col];  
}

ostream& operator<<(ostream& output, const Matrix& newMatrix) //overloaded << operator
{
output << "[[" << newMatrix.matrix[0][0] << ", " << newMatrix.matrix[0][1]         << "], "
           << "[" << newMatrix.matrix[1][0] << ", " << newMatrix.matrix[1][1] << "]]";

return output;
}

class Matrix //Class Defintion for Matrix
{
public:
    Matrix();
    Matrix(const int[][2]);
    Matrix operator+(const Matrix&) const;
    friend ostream& operator<<(ostream&, const Matrix&);
private:
    int matrix[2][2];
};

Answer 1

错误非常简单，与this无关。

'operator []'不匹配（操作数类型为'const Matrix'和'int'）

您尚未为矩阵类定义operator[]，并且在编写时尝试调用

rightOp[0][0]

我认为你的意图是

addedMatrix.matrix[0][0] = this->matrix[0][0] + rightOp.matrix[0][0];

等等。这与写作相同

addedMatrix.matrix[0][0] = matrix[0][0] + rightOp.matrix[0][0];

Answer 2

要获得更多帮助，您需要显示矩阵类的定义，但对于初学者：

编译器认为你要做的是访问二维矩阵数组中的元素，而我认为你想要的是访问该矩阵中的单个数字。
要以这种方式使用索引运算符（[]），您需要在矩阵类中重载它们，在这种情况下，您不能像那样重载它们，因为索引运算符只接受一个整数作为它的参数。任何涉及索引运算符多次使用的解决方案都比较重要，比如重载（）运算符，以便你可以执行rightOp（2,2）。
你的* this-＆gt;矩阵应该尝试访问单个值，而不是整个矩阵。'

编辑：查看代码之后，您忘记的是您需要访问Matrix.matrix [0] [0]，而不是Matrix [0] [0]。请记住，您实际上是从矩阵类

中的数组中获取数字

Answer 3

看看here并查看解决方案是否有帮助。

此处粘贴了完整的解决方案。

Either: this->operator()(i,j) or (*this)(i,j)

Answer 4

operator+将两个参数作为输入，并返回一个新对象，而不是一个修改过的对象。因此将它作为类成员实现是没有意义的。它通常作为独立的全局函数实现。另一方面，operator+=作为一种类方法更有意义，而operator+ 通常以operator+的形式实现。例如：

class Matrix { private: int matrix[2][2]; public: Matrix(); // initialize matrix to default values Matrix(const Matrix &); // copy existing matrix values ... Matrix& operator+=(const Matrix& rightOp); friend Matrix operator+(const Matrix& leftOp, const Matrix& rightOp); }; Matrix operator+(const Matrix& leftOp, const Matrix& rightOp);

Matrix operator+(const Matrix& leftOp, const Matrix& rightOp) { Matrix tmp(leftOp); tmp += rightOp; return tmp; } Matrix& Matrix::operator+=(const Matrix& rightOp) { for(int row = 0; row < 2; ++row) { for(int col = 0; col < 2; ++col) { matrix[row][col] += rightOp.matrix[row][col]; } } return *this; }

话虽这么说，你也可以实现operator+作为一种类方法：

class Matrix { private: int matrix[2][2]; public: Matrix(); // initialize matrix to default values Matrix(const Matrix &); // copy existing matrix values ... Matrix operator+(const Matrix& rightOp) const; };

Matrix Matrix::operator+(const Matrix& rightOp) const { Matrix result(*this); for(int row = 0; row < 2; ++row) { for(int col = 0; col < 2; ++col) { result.matrix[row][col] += rightOp.matrix[row][col]; } } return result; }

或者：

Matrix Matrix::operator+(const Matrix& rightOp) const { Matrix result; for(int row = 0; row < 2; ++row) { for(int col = 0; col < 2; ++col) { result.matrix[row][col] = this->matrix[row][col] + rightOp.matrix[row][col]; } } return result; }

使用This关键字和运算符重载

4 个答案: