c++ - 这是否被认为是内存泄漏？

Question

假设您有一个像这样的简单类:

class foo{
private:
    int* mData;
    int  mSize;
public:
    foo(int size){
        mSize = size;
        mData = new int [mSize];
    }
    ~foo() {
        mSize = 0;
        delete [] mData;
    }
};

然后在 main 里面你做:

int main () {
    static int HUGE = 100000000;
    foo a(HUGE);
    // do something useful with a
    // .
    // .
    // .
    // Now I'm done with a; I do not need it anymore ...
    foo b(HUGE);
    // do something useful with b
    // Ok we are done with b
    return 0;
}

正如你所看到的，a在b之后不再需要，但是由于它是在栈上创建的，所以析构函数直到结束时才会被调用该程序。现在，我知道这与使用 new 分配并忘记调用 delete 不同，但这仍然是在浪费内存。您认为这是“内存泄漏”还是糟糕的编程？

另外，你会如何避免这种情况？一种方法是在不再需要对象时手动调用析构函数，但是，除了看起来丑陋和不熟悉!，你会遇到 double free 的麻烦，除非你将析构函数更改为类似:

foo::~foo(){
    if (mData != NULL){
        delete [] mData;
        mData = NULL;
        mSize = 0;
    }
}

另一种方法是通过foo *pa = new foo (HUGE) 在堆上创建a 然后调用delete pa 一旦不再需要对象。这可行，但存在引入另一种可能的内存泄漏的危险(如果忘记调用 delete pa)。

有没有更好的方法来摆脱不需要的对象？

Answer 1

当对象超出作用域时调用析构函数。 C++ 允许函数体内的任意作用域。以这种方式编写您的主要功能:

int main () {
    static int HUGE = 100000000;

    {
        foo a(HUGE);
        // do something useful with a
        // Now I'm done with a; I do not need it anymore ...
    }

    {
        foo b(HUGE);
        // do something useful with b
        // Ok we are done with b
    }
    // etc.
    return 0;
}

我看到你的例子被简化了，但在一个真正的程序中，不要忘记

• 为 foo 或
实现适当的复制构造函数和 operator=
• 为私有(private)复制构造函数和 operator= 添加声明，使其无法被调用。