c++内存泄露之重载new运算符

我不是女神ヾ 2022-08-07 01:33 164阅读 0赞

C++程序的复杂性很大一部分在于他的内存管理，没有C\#那样的垃圾回收机制，内存管理对初学者来说很困难。经常会出现内存泄露的情况。那么我们写程序如何避免内存泄露呢？首先我们需要知道程序有没有内存泄露，然后定位到底是哪行代码出现内存泄露了，这样才能将其修复。  
本文描述了如何检测内存泄露。最主要的是纯C，C++的程序如何检测内存泄露。  
现在有很多专业的检测工具，比如比较有名的BoundsCheck, 但是这类工具也有他的缺点，我认为首先BoundsCheck是商业软件，呵呵。然后呢需要安装，使用起来不太方便。因为我们检测的时候不一定经常会启动他来检测。这样经常会积累很多问题，那时要解决就麻烦了。最好就是从开始编码，一步一步的都能随时提醒我们内存泄露。我们编程序会经常调试，假如能在每次调试程序的时候都能自动检测内存泄露就好了。

**一. 在 MFC 中检测内存泄漏  
假如是用MFC的程序的话，很简单。默认的就有内存泄露检测的功能。  
我们用VS2005生成了一个MFC的对话框的程序,发现他可以自动的检测内存泄露.不用我们做任何特殊的操作. 仔细观察,发现在每个CPP文件中,都有下面的代码:**

1.  **\#ifdef \_DEBUG**
2.  **\#define new DEBUG\_NEW**
3.  **\#endif**

**DEBUG\_NEW 这个宏定义在afx.h文件中，就是它帮助我们定位内存泄漏。  
  
在含有以上代码的cpp文件中分配内存后假如没有删除，那么停止程序的时候，VisualStudio的Output窗口就会显示如下的信息了：**

1.  **Detected memory leaks!**
2.  **Dumping objects ->**
3.  **d:/code/mfctest/mfctest.cpp(80) : \{ 157\} normalblock at 0x003AF170, 4 bytes long.**
4.  **Data: < > 00 0000 00**
5.  **Object dump complete.**

**在Output窗口双击粗体字那一行，那么IDE就会打开该文件，定位到该行，很容易看出是哪出现了内存泄露。**

**二．检测纯C++的程序内存泄露**

**我试了下用VisualStudio建立的Win32 Console Application和Win32 Project项目，结果都不能检测出内存泄露。  
下面一步一步来把程序的内存泄露检测的机制建立起来。  
首先，我们需要知道C运行库的Debug版本提供了许多检测功能，使得我们更容易的Debug程序。在MSDN中有专门的章节讲这个，叫做Debug Routines，建议大家先看看里面的内容吧。  
我们会用到里面很重要的几个函数。其中最重要的是 \_CrtDumpMemoryLeaks();自己看MSDN里的帮助吧。使用这个函数，需要包含头文件crtdbg.h  
该函数只在Debug版本才有用，当在调试器下运行程序时，\_CrtDumpMemoryLeaks 将在“Output(输出)”窗口中显示内存泄漏信息.写段代码试验一下吧，如下：  
检测内存泄露版本一：**

1.  **\#include "stdafx.h"**
2.  **\#include <crtdbg.h>**
3.  **int \_tmain(int argc, \_TCHAR\* argv\[\])**
4.  **\{** 
5.  **int\* p = newint();**
6.   **\_CrtDumpMemoryLeaks();**
7.  **return 0;**
8.  **\}**

**运行后，在Output（输出）窗口，显示了如下的信息：**

1.  **Detected memory leaks!**
2.  **Dumping objects ->**
3.  **\{112\} normal block at 0x003AA770, 4 bytes long.**
4.  **Data: < > 00 00 00 00**
5.  **Object dump complete.**

**但是这个只是告诉我们程序有内存泄露，到底在哪泄露了一眼看不出来啊。  
看我们的检测内存泄露版本二：**

**该程序定义了几个宏，通过宏将Debug版本下的new给替换了，新的new记录下了调用new时的文件名和代码行.运行后，可以看到如下的结果：**

1.  **Detected memory leaks!**
2.  **Dumping objects ->**
3.  **d:/code/consoletest/consoletest.cpp(21) : \{112\} client block at 0x003A38B0, subtype 0, 4 bytes long.**
4.  **Data: < > 00 00 00 00**
5.  **Object dump complete.**

**呵呵，已经和MFC程序的效果一样了，但是等一等。看下如下的代码吧：**

1.  **int \_tmain(int argc, \_TCHAR\* argv\[\])**
2.  **\{** 
3.  **int\* p = newint();**
4.   **\_CrtDumpMemoryLeaks();**
5.  **delete p;**
6.  **return 0;**
7.  **\}**

**运行后可以发现我们删除了指针，但是它仍然报内存泄露。所以可以想象，每调用一次new，程序内部都会将该调用记录下来，类似于有个数组记录，假如 delete了，那么就将其从数组中删除，而\_CrtDumpMemoryLeaks()就是把这个数组当前的状态打印出来。  
所以除了在必要的时候Dump出内存信息外，最重要的就是在程序退出的时候需要掉用一次\_CrtDumpMemoryLeaks();  
假如程序有不止一个出口，那么我们就需要在多个地方都调用该函数。  
更进一步，假如程序在类的析构函数里删除指针，怎么办？例如：**

1.  **\#include "stdafx.h"**
2.  **\#ifdef \_DEBUG**
3.  **\#define DEBUG\_CLIENTBLOCK new( \_CLIENT\_BLOCK, \_\_FILE\_\_, \_\_LINE\_\_)**
4.  **\#else**
5.  **\#define DEBUG\_CLIENTBLOCK**
6.  **\#endif**
7.  **\#define \_CRTDBG\_MAP\_ALLOC**
8.  **\#include <crtdbg.h>**
9.  **\#ifdef \_DEBUG**
10. **\#define new DEBUG\_CLIENTBLOCK**
11. **\#endif**
12. **class Test**
13. **\{** 
14. **public:**
15.  **Test() \{ \_p = newint(); \}**
16.  **~Test() \{ delete \_p; \}**
17. **int\* \_p;**
18. **\};**
19. **int \_tmain(int argc, \_TCHAR\* argv\[\])**
20. **\{** 
21. **int\* p = newint();**
22. **delete p;**
23.  **Test t;**
24.  **\_CrtDumpMemoryLeaks();**
25. **return 0;**
26. **\}**

**可以看到析构函数在程序退出的时候才调用，明明没有内存泄露，但是这样的写法还是报了。  
如何改进呢,看检测内存泄露版本三：**

1.  **\#include "stdafx.h"**
2.  **\#ifdef \_DEBUG**
3.  **\#define DEBUG\_CLIENTBLOCK new( \_CLIENT\_BLOCK, \_\_FILE\_\_, \_\_LINE\_\_)**
4.  **\#else**
5.  **\#define DEBUG\_CLIENTBLOCK**
6.  **\#endif**
7.  **\#define \_CRTDBG\_MAP\_ALLOC**
8.  **\#include <crtdbg.h>**
9.  **\#ifdef \_DEBUG**
10. **\#define new DEBUG\_CLIENTBLOCK**
11. **\#endif**
12. **class Test**
13. **\{** 
14. **public:**
15.  **Test() \{ \_p = newint(); \}**
16.  **~Test() \{ delete \_p; \}**
17. **int\* \_p;**
18. **\};**
19. **int \_tmain(int argc, \_TCHAR\* argv\[\])**
20. **\{** 
21.  **\_CrtSetDbgFlag ( \_CRTDBG\_ALLOC\_MEM\_DF | \_CRTDBG\_LEAK\_CHECK\_DF );**
22. **int\* p = newint();**
23. **delete p;**
24.  **Test t;**
25. **return 0;**
26. **\}**

**\_CrtSetDbgFlag ( \_CRTDBG\_ALLOC\_MEM\_DF | \_CRTDBG\_LEAK\_CHECK\_DF );  
该语句在程序退出时自动调用 \_CrtDumpMemoryLeaks。必须同时设置 \_CRTDBG\_ALLOC\_MEM\_DF 和 \_CRTDBG\_LEAK\_CHECK\_DF.  
这样，该版本已经达到了MFC一样的效果了，但是我觉得光这样还不够，因为我们只是在Output窗口中输出信息，对开发人员的提醒还不明显，经常会被遗漏，而且很多人就算发现了内存泄露，但是不好修复，不会严重影响到程序外在表现，都不会修复。怎么样能让开发人员主动的修复内存泄露的问题呢？记得曾经和人配合写程序，我的函数参数有要求，不能为空，但是别人老是传空值，没办法了，只好在函数开始验证函数参数，给他assert住，这样程序运行时老是不停的弹出assert，调试程序那个烦压，最后其他程序员烦了，就把这个问题给改好了，输入参数就正确了。所以我觉得咱要让程序员主动去做一件事，首先要让他觉得做这个事是能减轻自己负担，让自己工作轻松的。呵呵，那咱们也这样，当程序退出时，检测到内存泄露就让程序提示出来。  
看检测内存泄露版本四：**

1.  **\#include "stdafx.h"**
2.  **\#include <assert.h>**
3.  **\#ifdef \_DEBUG**
4.  **\#define DEBUG\_CLIENTBLOCK new( \_CLIENT\_BLOCK, \_\_FILE\_\_, \_\_LINE\_\_)**
5.  **\#else**
6.  **\#define DEBUG\_CLIENTBLOCK**
7.  **\#endif**
8.  **\#define \_CRTDBG\_MAP\_ALLOC**
9.  **\#include <crtdbg.h>**
10. **\#ifdef \_DEBUG**
11. **\#define new DEBUG\_CLIENTBLOCK**
12. **\#endif**
13. **void Exit()**
14. **\{** 
15. **int i = \_CrtDumpMemoryLeaks();**
16.  **assert( i == 0);**
17. **\}**
18. **int \_tmain(int argc, \_TCHAR\* argv\[\])**
19. **\{** 
20.  **atexit(Exit);**
21. **int\* p = newint();**
22. **return 0;**
23. **\}**

**该版本会在程序退出时检查内存泄露，假如存在就会弹出提示对话框.  
atexit(Exit);设置了在程序退出时执行Exit()函数。  
Exit()函数中,假如存在内存泄露，\_CrtDumpMemoryLeaks()会返回非0值，就会被assert住了。  
  
到这个版本已经达到可以使用的程度了。但是我们还可以做些改进，因为真要准确的检测到代码中所有的内存泄露，需要把代码中的\#define……拷贝到所有使用new的文件中。不可能每个文件都拷贝这么多代码，所以我们可以将他提取出来，放在一个文件中，比如我是放在 KDetectMemoryLeak.h中，该文件内容如下：**

1.  **\#pragma once**
2.  **\#ifdef \_DEBUG**
3.  **\#define DEBUG\_CLIENTBLOCK new( \_CLIENT\_BLOCK, \_\_FILE\_\_, \_\_LINE\_\_)**
4.  **\#else**
5.  **\#define DEBUG\_CLIENTBLOCK**
6.  **\#endif**
7.  **\#define \_CRTDBG\_MAP\_ALLOC**
8.  **\#include <stdlib.h>**
9.  **\#include <crtdbg.h>**
10. **\#ifdef \_DEBUG**
11. **\#define new DEBUG\_CLIENTBLOCK**
12. **\#endif**

**然后将KDetectMemoryLeak.h包含在项目的通用文件中，例如用VS建的项目就将其包含在stdafx.h中。或者我自己建的一个Common.h文件中，该文件包含一些通用的，基本所有文件都会用到的代码东东。  
  
好了，到现在，检测内存泄露总算完成了，而且他还能定位到到底是代码中哪个文件，哪行出现了内存泄露。下一篇文章将会讲些实际遇到的一些问题，例如只知道有内存泄露，但是不知道到底内存泄露的具体位置，如何利用内存断点等技术来定位内存泄露的位置啊，最后会从代码的角度讲下，怎么样才能避免内存泄露吧。**