Question

我是C ++的初学程序员。最近，我开始使用C ++进行图像处理。我正在尝试定义和使用以下函数：

Matrix MVE(Matrix R, double tolerance)
{
    int n = R.Y();
    Matrix P(n,4);
    for (int i = 0; i < n; ++i)
    {
            P[i][0] = R[i][0];
            P[i][1] = R[i][1];
            P[i][2] = R[i][2];
            P[i][3] = 1.0;
    }
    Matrix *Q = P.T();
            double err = 1.0;
    MatVectorCol u(n);                      
    u.Set(1.0 / n);
    MatVectorCol Mv(n);                 

    while (err > tolerance)                         
    {
            Matrix uM(n, n);
            uM.SetDiagonal(u);
            Matrix *X = *Q * uM;
            Matrix *X1 = *X * P; 
            Matrix invX(4, 4);
            invX = *X1->Inverse();
     delete X;  // Error here!
            delete X1;
    }

    return invX;
}

但是当程序执行“删除X”行时，我收到此错误：

Windows在plappd.exe中触发了断点。

这可能是由于堆的损坏，这表示plappd.exe或其加载的任何DLL中存在错误。

这也可能是由于用户在plappd.exe有焦点时按下F12。

Matrix类的构造函数和操作定义如下：

Matrix::Matrix(int _y, int _x) 
{ 
    x = _x; 
    y = _y; 
    M = new double [x * y]; 
    buff = new double [x]; 
    memset0_64(M, sizeof(double) * (x * y));
}

Matrix *Matrix::Transpose()
{
    Matrix *b = new Matrix(x, y);
    for (int i = 0; i < x; ++i)
    {
            double *b_line_i = (*b)[i];
            for (int j = 0; j < y; ++j)
                    b_line_i[j] = (*this)[j][i];
    }
    return b;
}

Matrix *Matrix::operator * (const Matrix &m)
{
    if (x == m.y)
    {
            Matrix *b = new Matrix(y, m.x);
            for (int i = 0; i < y; ++i)
            {
                    double *b_line_i = (*b)[i];
                    double *line_i = (*this)[i];
                    for (int j = 0; j < m.x; ++j)
                            for (int k = 0; k < x; ++k)
                                    b_line_i[j] += line_i[k] * m(k, j);
            }
            return b;
    }
    else
            return 0;
}

代码确实有问题，但我无法弄清楚它在哪里以及如何解决它。

提前致谢。

Answer 1

您的代码的错误在于您过度使用/滥用运算符新的动态内存分配。除非必须，否则不要动态分配内存 - 这很容易出错，如果你是“初学者”，你绝对应该避免这样做。（除非你使用另一种语言动态分配内存并知道你正在做什么）。

不使用new分配双打，而是使用std::vector<double>或类似的容器。这样您就不必编写析构函数。

如果你的类动态分配内存，它必须有析构函数。 C ++没有垃圾收集，所以没有人会清理你的烂摊子并为你释放资源。

如果你的类有析构函数，它应该服从rule of three。您应该定义复制构造函数和赋值运算符。如果不这样做，将导致内存泄漏，未定义的行为和崩溃。

不要从运算符内返回原始指针。不要从运算符返回动态分配的对象（如果必须返回动态分配的对象，则创建单独的函数）。如果必须返回动态分配的对象，请使用智能指针，因此它们将自动销毁（std::shared_ptr或boost::shared_ptr应该有效）。

传统上，operator*应该按值返回对象。它应该是这样的：

Matrix Matrix::operator* (const Matrix &arg1, const Matrix &arg2){...}|

C ++中的堆损坏

1 个答案: