C++ 范围解析问题

Question

昨天我的班级有一个实验室考试，我们必须制作一个矩阵类并重载operation+()。在我去进行单元测试之前，我认为我的做法是正确的……我知道这是很多文字；然而，我在实验室的剩余时间里试图弄清楚出了什么问题，并且无法弄清楚为什么在赋值运算符调用之前临时对象矩阵超出了范围。

代码如下：

矩阵标题

#include <iostream>
#include <iomanip>
using namespace std;
class Matrix
{
Public:
// Constructor and Destructor Suite
Matrix(int x, int y); // Lab TA stated that Matricies would never go above two dimensions
~Matrix(); 

// Access and Mutation
void set(int row, int column, int value); // This function sets the value of a given matrix coordinate at row, column to value
int get(int row, int column) const; // This function returns the value of a matrix at row, column

Matrix& operator=(const Matrix& Q)
{
    cout << "Called Assignment" << endl;
    int r, c;
    r = Q.rows; c = Q.columns;
    for (int i = 0; i < r; i++)
    {
        for (int k = 0; k < c; k++)
        {
            cout << "Address of Calling Objet pointer Int: " << this->pMatrixOfInt[i][k] << setw(5) << *this->pMatrixOfInt[i][k] << endl;
            cout << "Address of Reference Object: " << Q.pMatrixOfInt[i][k] << setw(5) << *Q.pMatrixOfInt[i][k] << endl;
            *(this->pMatrixOfInt[i][k]) = *(Q.pMatrixOfInt[i][k]);
        }
    }
    return *this;
}
const Matrix operator+(const Matrix& Q);
friend ostream& operator<<(ostream& output, const Matrix& Q);
friend istream& operator>>(istream& input, Matrix& Q);
private:
int rows, columns;
int* pMatrixOfInt[50][50]; // Specification document said that these values would never go above 50
};

Matrix.cpp

/*
Matrix Class Definition
14 March 2014
*/
#include <iomanip>
#include <iostream>
#include "Matrix.h"
// Constructor
Matrix::Matrix(int x, int y)
{
    cout << "Constructor Called" << endl;
    this->rows=x;
    this->columns=y;
    for (int i=rows-1; i>=0; i--)           // If X and Y are both 50 then the starting value
    {                                       // for i and k should be 49 because of how arrays
        for (int k=columns-1; k>=0; k--)    // are indexed. Hence the rows-1
        {
            pMatrixOfInt[i][k] = new int;
        }
    }
}
// Destructor
Matrix::~Matrix()
{
    cout << "Destructor Called" << endl;
    for (int i=rows-1; i>=0; i--)           // If X and Y are both 50 then the starting value
    {                                       // for i and k should be 49 because of how arrays
        for (int k=columns-1; k>=0; k--)    // are indexed. Hence the rows-1
        {
            delete pMatrixOfInt[i][k];
        }
    }
}
// Access and Mutation
void Matrix::set(int row, int column, int value)
{
    *pMatrixOfInt[row][column] = value;
}
int Matrix::get(int row, int column) const
{
    return *pMatrixOfInt[row][column];
}
// Overloaded Addition Operator (Possible Scope Problem)
const Matrix Matrix::operator+(const Matrix& Q)
{
    cout << "Addition Operator Called" << endl;
    int rows, columns;
    rows = Q.rows;
    columns = Q.columns;
    Matrix newMatrix(rows, columns);
    cout << "newMatrix Rows: " << newMatrix.rows << " -- newMatrix columns: " << newMatrix.columns << endl; // Make a new matrix. Constructor will initialize the pointer Matrix
    int newValue;
    for (int i=0; i<rows; i++)
    {
        for (int k=0; k<columns; k++)
        {
            newValue = this->get(i,k);
            newValue += Q.get(i,k);
            newMatrix.set(i,k, newValue);
            cout << setw(5) << newMatrix.get(i, k);
        }
        cout << "\n";
    }
    return newMatrix;
}
// Friend definitions for i/ostreams.
ostream&::operator<<(ostream& output, const Matrix& Q)
{
    for (int r = 0; r<Q.rows; r++)
    {
        for (int c = 0; c<Q.columns; c++) // hahaha
        {
            output << setw(4) << Q.get(r,c);
        }
        output << "\n";
    }
    return output;
}
istream&::operator>>(istream& input, Matrix& Q)
{
    int value;
    for (int r = 0; r<Q.rows; r++)
    {
        for (int c = 0; c<Q.columns; c++)
        {
            input >> value;
            Q.set(r,c,value);
        }
    }
    return input;
}

当我尝试做这样的事情时：

newMatrix = oldMatrixA + oldMatrixB;
cout << newMatrix;

我收到以下一系列输出，然后是 BLOCK_HEADER_ERROR：

Addition Operator Called
0   1   2   3
1   3   5   7
Destructor Called
Assignment Called
Lots of output here regarding address of calling object and value along with the reference object and value of that too
!!!BLOCK_HEADER_ERROR!!!

谁能告诉我为什么加法运算符返回的临时对象在赋值运算符之前超出范围，即使它们在同一行并且 newMatrix 是一个返回对象，因此不应该被销毁，直到调用它的作用域要求销毁它？

提前感谢您的帮助，我昨晚没睡好，因为 TA 让我上交了我知道有 bug 的工作，我一直无法找出问题所在。

我知道这是很多代码，这是我在 StackOverflow 上发布过的最长的问题；不过，我喜欢睡个好觉，在我知道出了什么问题之前，我不认为我会好好休息。

Answer 1

为什么使用指针来存储值？改用普通整数就可以了。

首先想想“太早”的破坏：

在您的代码中，您实际上有两个临时变量（如果没有进行返回值优化）： 第一个是newValue，第二个是由operator+ 返回的临时右值。

在将newValue 复制到临时右值后，newValue 被破坏（您看到的消息）。

第二个问题是：您没有指定自定义复制构造函数（想想rule of three）。因此，右值临时副本具有指向您在破坏 newValue 时释放的整数的所有指针。

如果您不能使用纯整数，那么您必须编写自己的复制构造函数来真正复制（为新矩阵分配新整数）。

如果你可以使用纯整数，那么使用它们，一切都很好（不需要自定义析构函数/复制构造函数/复制赋值运算符）

复制构造函数示例：

Matrix::Matrix(const Matrix &other) {
    this->rows=other.rows;
    this->columns=other.columns;
    for (int row = 0; row < rows; ++row) {
        for (int column = 0; column < columns; ++column) {
            // allocate a new integer with the value 
            // copied from the other matrix
            pMatrixOfInt[row][column] = new int(*other.pMatrixOfInt[row][column]);
        }
    }
}