关于运算符重载和内存泄漏的 C++ 引用

Question

我使用下面的代码

Matrix operator * (const Matrix & obj)
{
    Matrix m = Matrix();

    for (int i = 0; i < 4; i++)
        for (int j = 0; j < 4; j++)
        {
            m[i][j] = 0;

            for (int k = 0; k < 4; k++)
                m[i][j] += _data[i][k] * obj._data[k][j];
        }

    return m;
}

像这样

v1 = m_proj * m_view * m_object * v1;

但我猜这是非常未优化的，因为我假设我在运算符中创建的新 Matrix 正在疯狂地被复制。如果我这样做的话

Matrix & operator * (const Matrix & obj)
{
    Matrix m = Matrix();

    for (int i = 0; i < 4; i++)
        for (int j = 0; j < 4; j++)
        {
            m[i][j] = 0;

            for (int k = 0; k < 4; k++)
                m[i][j] += _data[i][k] * obj._data[k][j];
        }

    return m;
}

将运算符的返回类型更改为对 Matrix 的引用，整个代码将完全停止工作(它可以编译，只是矩阵没有按预期相乘)。

如果我把它改成

Matrix & operator * (const Matrix & obj)
{
    Matrix & m = * new Matrix();

    for (int i = 0; i < 4; i++)
        for (int j = 0; j < 4; j++)
        {
            m[i][j] = 0;

            for (int k = 0; k < 4; k++)
                m[i][j] += _data[i][k] * obj._data[k][j];
        }

    return m;
}

现在它可以工作了，但是我有一个严重的内存泄漏问题。

那么如何解决这个问题呢？有没有优雅的解决方案？

谢谢!

Answer 1

您的函数正在创建一个新对象，它应该按值返回该对象。

您不能返回对局部变量的引用，并且返回对动态分配内存的引用有多个问题:它解决不了任何问题(不会减少表达式创建的对象数量，并且由于动态分配)并增加了内存泄漏。

如果没有 Matrix 类的定义，则不清楚内存是在数组中处理还是动态分配。如果它是动态分配的并且你有一个 C++11 编译器，你可以实现移动构造和移动赋值以及所有这些复制 会消失。

在 C++03(以及 C++11)中，您可以实现 operator*= 并手动处理创建的对象(假设您可以高效地执行此操作):

//v1 = m_proj * m_view * m_object * v1;
Matrix tmp = m_proj;
tmp *= m_view;
tmp *= m_object;
tmp *= v1;
v1 = tmp;

这将创建一个临时文件并就地应用所有乘法，从而减少拷贝数。

无论如何，我不会花太多时间在这上面，因为复制 4x4 矩阵并不昂贵。