如何停止此指针内存泄漏？

Question

我在 c++ 方面表现不错，但在指针和内存方面我一直很糟糕。我遇到了这种情况，不知道有没有解决办法。

typedef unsigned long long ullong;

class MathClass { //This is just an example class
public:
    MathClass() {num = new ullong[1]();}

    MathClass operator+(MathClass b) { //This is not my actual function, just one that has the same problem
        MathClass c;
        c.num[0] = num[0] + b.num[0];
        delete [] num;
        num = NULL;
        return c;
    }
public:
    ullong* num;
};

这适用于这种情况。

MathClass a;
MathClass b;
for (int i = 0; i < 1000; i++) {
    a = a + b;
}

因为我设置 a 等于 a + b，所以当 + 函数运行时，它会将 a 设置为等于 c 并删除旧的 a num。

对于这种情况，它会导致错误，因为我正在删除 b 的 num。

MathClass a;
MathClass b;
MathClass c;
for (int i = 0; i < 1000; i++) {
    a = b + c;
}

如果我不删除 num 这会起作用，但这会导致内存泄漏。当我不删除 num 时，内存很容易超过 100MB。我敢肯定这个问题的答案很简单，但我想不通。

Answer 1

您需要三（五）条规则。

当你分配内存时，或者如果你需要实现赋值、析构函数或复制构造函数，那么你需要全部三个（五个 - 移动构造函数和移动赋值）。

当您使用 new（考虑 shared_ptr、unique_ptr）分配内存时，您需要控制复制分配和删除的工作方式。

class MathClass { //This is just an example class
public:
    MathClass() {num = new ullong[1]();}
    ~MathClass() { delete [] num;} // cleans up memory.
    MathClass( const MathClass & rhs ) { num = new ullong[1](); num[0] = rhs.num[0]; }
    MathClass& operator=( const MathClass & rhs )
    {
       if( &rhs != this ) {
          num[0] = rhs.num[0];
       }
       return *this;
    }

    MathClass operator+(MathClass b) { //This is not my actual function, just one that has the same problem
    MathClass c;
    c.num[0] = num[0] + b.num[0];
    // the wrong place delete [] num;
    num = NULL;
    return c;
    }
public:
    ullong* num;
};

operator+ 中的 delete [] 位于错误的位置，因为它试图找到正确的位置来释放内存。但是，最简单的方法是应用 rule of 3 并确保内存在构造时构建，在删除时删除，并且赋值（和移动）运算符正常工作

Answer 2

问题实际上并不完全在于指针，而是运算符重载和类实现（正如 cmets 中提到的那样）。 如果您在第一个示例中更改参数顺序（即 a = a + b -> a = b + a ），您将看到与第二个示例相同的错误。所以这里有一篇关于实现operator overloading 的好文章 代码可能是这样的

#include <iostream>
#include <algorithm>

typedef unsigned long long ullong;

class MathClass {

public:
    MathClass() { num = new ullong[ 1 ](); }
    MathClass( const MathClass &a ) { 
        *this = a;
    }
    ~MathClass() {  
        delete[] num;
        num = NULL;
    }

    MathClass &operator=( const MathClass &a ) {
        if ( this != &a ) {
            num = NULL;
            num = new ullong[ 1 ];
        }
        std::copy( a.num, a.num + 1, num );

        return *this;
    }

    friend MathClass operator+( const MathClass &a, const MathClass b ) {
        MathClass c;
        c.num[ 0 ] = a.num[ 0 ] + b.num[ 0 ];

        return c;

    }
ullong *num;
};

int main( int argc, char **argv ) {
   MathClass a;
   MathClass b;
   MathClass c;
   for ( int i = 0; i < 1000; ++i ) {
      std::cout << "a.num[ 0 ] is " << a.num[ 0 ] << std::endl;
      std::cout << "b.num[ 0 ] is " << b.num[ 0 ] << std::endl;
      a = b + a;
      a = c + b;
   }

   return 0;
}

在 main "std::cout" 中仅用于输出可见性。复制构造函数的实现肯定比我的要好得多，但这里的关键点是，当您使用复杂类型时，您几乎总是必须重新实现复制和分配运算符，因为它们经常（如果不是总是）被调用。 还有一些其他时刻可以很好地提及您的代码。至少自从 C++11 NULL 更改为 nullptr 之后，typedef 也不那么常见了。使用引用而不是指针，这是一种很好的做法，尤其是在复杂参数的情况下，通过引用而不是通过值传递它们，因为在通过值传递的情况下，将调用复制构造函数，并且您将不得不实例化相同的参数，这可能会导致内存过度使用。