内存泄漏预防 C++（我是对还是错？）

Question

我已经在互联网上搜索了几个小时，并想出了这些步骤来防止内存泄漏（不使用智能指针和高级工具等）。如果以下发现有任何问题，请告诉我...提前致谢。

1. 每一个新的都应该有一个删除。
2. 如果 new 在类中，则将 delete 放入析构函数中会处理动态分配的内存。
3. 如果您在 main 中从类 foo 中创建一个新对象 obj，那么您将不得不显式删除 obj。
4. 如果您有多维动态数组，则必须删除这两个级别。 （我有点不确定这是否安全......我认为只有一次删除 ptr 可能会做到这一点，但经过仔细考虑后，我认为它是一个动态数组的动态数组，应该将每个动态数组分别视为一个动态数组）。

前 1 个。

char *ptr;
ptr = new char[size];
// Some Code here
delete ptr;

前 2.

//foo.h
class foo { 
private:
    char * ptr;
public
    foo();
    ~foo();
};
// foo.cpp
foo::foo()
{
    ptr = new char[100];
    for (int i = 0; i < 100; i++)
        ptr[i] = i;
}

foo::~foo()
{
    delete ptr;
}

前 3.

//main.cpp   foo class stays the same as ex 2.
int main()
{
    foo obj = new foo();
    // Some code here
    delete obj;
    return 0;
}

前 4.

//foo.h
class foo {
private:
    char ** ptr;
public
    foo();
    ~foo();
};

//foo.cpp
foo::foo()
{
    ptr = new char[100];
    for (int i = 0; i < 100; i++)
        ptr[i] = new char[100];
    for (int i = 0; i < 100; i++)
        for (int j = 0; j < 100; j++)
            ptr[i][j] = i;
}

foo::~foo()
{
    for (int i = 0; i < 100; i++)
        delete ptr[i];
    delete ptr;
}

Answer 1

以下是您在自行管理内存时需要注意的一些提示：-

首先也是最重要的是：-

1) 始终将 delete 与 new 和 delete[] 与 new[] 一起使用。混合使用会导致未定义的行为。

2) 永远不要组合 malloc/delete 或 new/free。

对于您的问题“如果您有多维动态数组，则必须删除两个级别。” 是的，你必须照顾他们。

您提到的事情是正确的，即每当您在堆中分配内存时，您都必须明确删除内存。尽管您错过了围绕 RAII 的一个重要方面。假设有一个函数负责分配/解除分配。

void fun ()
{
 1) int* ptr;
 2) ptr = new int;   //allocated memory.

 3) ...              //do something with ptr.

 4) delete ptr;     //done with ptr now delete it.
}

现在您可以删除使用 new 分配的内存了。但是，程序执行甚至可能无法到达您的删除。 （以防在 STEP#3 中引发异常）。这种情况会构成内存泄漏。

为了解决这些问题，我们有基于 RAII 概念的智能指针。只要超出范围，它们就会自动删除它们所引用的内存，这意味着您不需要处理内存管理。

Answer 2

1. 每一个新的都应该有一个删除。

是的。更准确地说：每个new 必须有一个匹配的delete，每个new[] 必须有一个匹配的delete[]

1. 如果 new 在类中，则将 delete 放入析构函数中会处理动态分配的内存。

不！您还应该注意通过复制构造函数或赋值对副本会发生什么，除非您明确禁止这些操作。详情请见What is The Rule of Three?。

1. 如果您在 main 中从类 foo 中创建一个新对象 obj，那么您将不得不显式删除 obj。

??见 1.？

4. 如果您有多维动态数组，则必须删除两个级别。 （我有点不确定这是否安全......我认为只有一次删除 ptr 可能会做到这一点，但经过仔细考虑后，我认为它是一个动态数组的动态数组，应该将每个动态数组分别视为一个动态数组）。

是的，如果您使用原始指针，无论有多少间接级别，您都必须始终注意正确的内存管理。

---

我最后的建议是，不要理会这些问题，而是使用<memory> 智能指针和standard c++ containers 提供的东西。

不要直接使用new/delete，除非您 100% 确定自己在做什么，并且 200% 确定自己确实需要这样做。

---

当您询问实际问题时：

（例如 2。）delete 与 new char[] 不匹配

ptr = new char[100];
           // ^^^^^

foo::~foo() {
    delete [] ptr;
        // ^^ put the square brackets there
}

同样适用于（例如 4.）