如何在 C++ 中创建内存泄漏？

Question

我只是想知道如何使用 C++ 创建系统内存泄漏。我已经对此进行了一些谷歌搜索，但没有发现太多，我知道在 C# 中这样做并不可行，因为它是托管代码，但想知道是否有一种简单的方法可以用 C++ 做到这一点？我只是觉得看看系统由于代码编写不正确而遭受了多少损失会很有趣。谢谢。

Answer 1

当您调用new 而不稍后调用相应的delete 时，会发生内存泄漏。如本示例代码所示：

int main() {
    // OK
    int * p = new int;
    delete p; 

    // Memory leak
    int * q = new int;
    // no delete
}

Answer 2

1. 创建指向对象的指针并在堆上分配它
2. 不要删除它。
3. 重复前面的步骤
4. ????
5. 利润

Answer 3

int main() {
    while(true) new int;
}

Answer 4

内存泄漏有很多种：

• 分配的内存由于没有指向它而无法释放。
  这类泄漏很容易在 C 和 C++ 中创建。它们也很容易预防、检测和治愈。因为它们很容易检测，所以有很多免费和商业工具可以帮助找到此类泄漏。

• 应在很久以前释放的仍可访问的已分配内存。
  这类泄漏更难检测、预防或治愈。有些东西仍然指向它，它最终会被释放——例如，就在exit() 之前。从技术上讲，这并不是一个泄漏，但实际上它是一个泄漏。许多所谓的无泄漏应用程序都有这样的泄漏。你所要做的就是运行一个系统配置文件来查看一些愚蠢的应用程序消耗更多的内存。即使在托管语言中，这些类型的泄漏也很容易创建。

• 分配的内存一开始就不应该分配。
  示例：用户可以轻松地要求 Matlab 创建这些类型的泄漏。 Matlab 在创建此类泄漏方面也相当积极。当 Matlab 从malloc 获取失败时，它会进入一个循环，等待一段时间，然后重试malloc。与此同时，操作系统疯狂地尝试通过将程序块从真实内存转移到虚拟内存来处理内存丢失。最终，一切都在虚拟内存中——一切都陷入了停滞。

Answer 5

只需编写一个分配“大量数据”的应用程序，然后阻塞直到它被杀死。只需运行这个程序并让它继续运行。

Answer 6

在 C# 中，只需使用 P/Invoke 分配大量内存、资源句柄并保留它们。

您可以在简单的 C# 工具中很好地使用非托管代码

Answer 7

class ClassWithLeakedMemory{
private:
    char* str;
public:
    ClassWithLeakedMemory(){
        str = new char[100];
    }

    ~ClassWithLeakedMemory(){
        cout<<"We are not freeing the dynamically allocated string memory"<<endl;
    }

};


class ClassWithNoLeakedMemory{
private:
    char* str;
public:
    ClassWithNoLeakedMemory(){
        str = new char[100];
    }

    ~ClassWithNoLeakedMemory(){
        cout<<"We are freeing the dynamically allocated string memory"<<endl;
        delete[] str;
        str = null;

    }

};

int main() {
    //we are creating an automatic object of the ClassWithleakedMemory
    //when we will come out of the main, this object will be
    //out of scope. hence it will be deleted. so destructor will
    //be called. but in the destructor, we have not specifically
    //deleted the dynamically allocated string.

    //so the stack based pointer object str will be deleted but the   memory  
    //it was pointing to won't be deleted. so we will be left with an
    //unreferenced memory. that is memory leak.
    ClassWithLeakedMemory objectWithLeakedmemory;
    ClassWithNoLeakedMemory objectWithNoLeakedmemory;
    return 0;
}

基于堆栈的指针对象引用两个类中动态分配的内存的方式如下图所示：

Answer 8

当不再引用使用new 创建的对象时，必须对其应用delete 运算符。否则，它占用的内存将丢失，直到程序终止。这称为内存泄漏。这是一个插图：

#include <vector>
using namespace std;

void memory_leak(int nbr)
{
   vector<int> *ptrVector = new vector<int>(nbr);
   // some other stuff ...
   return;
}

如果我们返回而不在对象上调用delete（即delete ptrToVector），则会发生内存泄漏。为避免这种情况，不要在内存堆上分配本地对象，而是使用堆栈分配的变量，因为这些变量会在函数退出时自动清理。要在运行时堆栈上分配向量，请避免使用new（在堆上创建它）和指针。

Answer 9

就这么简单：⠀⠀⠀

new int;

Answer 10

#include <stdio.h>

void main(){

for(int i = 0; i < 1000; i++)

double* ptr = (double*)malloc(1000000*sizeof(double))

//free(ptr);

ptr = NULL;

}

注意：散列的代码行在进程分配它并且没有将其返回给操作系统时导致内存泄漏