Download Debugging Tools for Windows. Use the gflags utility to turn on user-mode stack traces. Use UMDH to take multiple snapshots of your program's memory. Take a snapshot before memory gets allocated, and take a second snapshot after a point at which you believe that your program has leaked memory. You might want to add pauses or prompts in your program to give you a chance to run UMDH and take the snapshots. Run UMDH again, this time in its mode that does a diff between the two snapshots. It will then generate a report containing the call stacks of suspected memory leaks. Restore your previous gflags settings when you're done.

UMDH会给你比CRT调试堆更多的信息，因为它会监视整个进程的内存分配;它甚至可以告诉您第三方组件是否泄漏。

您可以在代码中使用一些技术来检测内存泄漏。最常见和最简单的检测方法是，定义一个宏(比如DEBUG_NEW)，并使用它与预定义的宏(如__FILE__和__LINE__)一起定位代码中的内存泄漏。这些预定义的宏告诉您内存泄漏的文件号和行号。

DEBUG_NEW只是一个宏，通常定义为:

#define DEBUG_NEW new(__FILE__, __LINE__)
#define new DEBUG_NEW

因此，无论在哪里使用new，它都可以跟踪文件和行号，这可以用来定位程序中的内存泄漏。

而__FILE__， __LINE__是预定义的宏，它们分别计算你使用它们的文件名和行号!

阅读下面的文章，它解释了使用DEBUG_NEW和其他有趣的宏的技术，非常漂亮:

一个跨平台的内存泄漏检测器

从Wikpedia,

Debug_new refers to a technique in C++ to overload and/or redefine operator new and operator delete in order to intercept the memory allocation and deallocation calls, and thus debug a program for memory usage. It often involves defining a macro named DEBUG_NEW, and makes new become something like new(_FILE_, _LINE_) to record the file/line information on allocation. Microsoft Visual C++ uses this technique in its Microsoft Foundation Classes. There are some ways to extend this method to avoid using macro redefinition while still able to display the file/line information on some platforms. There are many inherent limitations to this method. It applies only to C++, and cannot catch memory leaks by C functions like malloc. However, it can be very simple to use and also very fast, when compared to some more complete memory debugger solutions.

回答你问题的第二部分，

是否有任何标准或程序可以确保程序中没有内存泄漏。

是的，有。这是C和c++的主要区别之一。

在c++中，永远不要在用户代码中调用new或delete。RAII是一种非常常用的技术，它在很大程度上解决了资源管理问题。程序中的每一个资源(资源是任何需要获取，然后释放的东西:文件句柄，网络套接字，数据库连接，但也包括普通内存分配，在某些情况下，对API调用(BeginX()/EndX()， LockY()， UnlockY()))都应该包装在一个类中，其中:

构造函数获取资源(如果资源是内存分配，则调用new) 析构函数释放资源， 复制和赋值要么被阻止(通过将复制构造函数和赋值操作符设置为私有)，要么被实现为正确工作(例如通过克隆底层资源)

然后，该类在本地、堆栈上或作为类成员实例化，而不是通过调用new和存储指针来实例化。

You often don't need to define these classes yourself. The standard library containers behave in this way as well, so that any object stored into a std::vector gets freed when the vector is destroyed. So again, don't store a pointer into the container (which would require you to call new and delete), but rather the object itself (which gives you memory management for free). Likewise, smart pointer classes can be used to easily wrap objects that just have to be allocated with new, and control their lifetimes.

这意味着当对象超出作用域时，它将被自动销毁，并释放和清理它的资源。

如果在整个代码中始终这样做，就不会有任何内存泄漏。所有可能泄露的内容都绑定到析构函数，该析构函数保证在控件离开声明对象的作用域时被调用。

除了其他答案中提供的工具和方法之外，静态代码分析工具还可以用于检测内存泄漏(以及其他问题)。 Cppcheck是一个免费的健壮的工具。但是还有很多其他可用的工具。Wikipedia有一个静态代码分析工具列表。

在应用程序代码中不应该使用“new”或“delete”。相反，应该创建一个使用管理器/工作人员习惯用法的新类型，其中管理器类分配和释放内存，并将所有其他操作转发给工作人员对象。

不幸的是，这比它应该做的要多，因为c++没有“operator .”的重载。如果存在多态，则工作量更大。

但是这样做是值得的，因为这样您就不必担心内存泄漏，这意味着您甚至不需要寻找它们。

指令

你需要的东西

熟练使用c++ c++编译器 调试器和其他调查软件工具

1

理解操作符的基础知识。c++操作符new分配堆内存。delete操作符释放堆内存。对于每一个new，你应该使用delete来释放你分配的内存:

char* str = new char [30]; // Allocate 30 bytes to house a string.

delete [] str; // Clear those 30 bytes and make str point nowhere.

2

仅在删除时重新分配内存。在下面的代码中，str通过第二次分配获得了一个新地址。第一个地址将不可挽回地丢失，它所指向的30个字节也将丢失。现在他们不可能被释放，你有一个内存泄漏:

char* str = new char [30]; // Give str a memory address.

// delete [] str; // Remove the first comment marking in this line to correct.

str = new char [60]; /* Give str another memory address with
                                                    the first one gone forever.*/

delete [] str; // This deletes the 60 bytes, not just the first 30.

3

注意那些指针的赋值。每个动态变量(在堆上分配内存)都需要与一个指针相关联。当一个动态变量与其指针分离时，它就不可能被删除。同样，这会导致内存泄漏:

char* str1 = new char [30];

char* str2 = new char [40];

strcpy(str1, "Memory leak");

str2 = str1; // Bad! Now the 40 bytes are impossible to free.

delete [] str2; // This deletes the 30 bytes.

delete [] str1; // Possible access violation. What a disaster!

4

小心使用局部指针。在函数中声明的指针分配在堆栈上，但它所指向的动态变量分配在堆上。如果你不删除它，它将在程序退出函数后继续存在:

void Leak(int x){

char* p = new char [x];

// delete [] p; // Remove the first comment marking to correct.

}

5

注意“delete”后面的方括号。使用delete本身来释放单个对象。使用带方括号的delete[]来释放堆数组。不要做这样的事情:

char* one = new char;

delete [] one; // Wrong

char* many = new char [30];

delete many; // Wrong!

6

如果泄漏还允许-我通常寻求它与deleaker(检查这里:http://deleaker.com)。