加载中…
个人资料
南冠彤
南冠彤
  • 博客等级:
  • 博客积分:0
  • 博客访问:415,028
  • 关注人气:59
  • 获赠金笔:0支
  • 赠出金笔:0支
  • 荣誉徽章:
相关博文
推荐博文
谁看过这篇博文
加载中…
正文 字体大小:

(转)内存泄露检测相关

(2012-08-15 10:47:07)
标签:

杂谈

分类: CPP/C

http://blog.csdn.net/yysdsyl/article/details/4033986#comments

内存泄漏是编程中常常见到的一个问题,我所遇过的原因有两个:

1.分配完内存后忘记回收

2.代码有问题,造成想回收却无法回收,例如:

int* p=new int;
p
=new int  //p指针修改,原来申请内存的地址没有记录下来,于是无法释放

 下面介绍如何检查内存泄漏:

1.包含头文件和定义

#define _CRTDBG_MAP_ALLOC   //并非绝对需要该语句,但如果有该语句,打印出来的是文件名和行数等更加直观的信息
#include 
<stdlib.h>
#include 
<crtdbg.h>

(1)#include语句必须采用上文所示顺序。如果更改了顺序,所使用的函数可能无法正确工作

(2)如果有cpp文件无法看到这三行,以下函数就无效了,于是应该把这三行放到一个头文件里,确保每个cpp文件会调用到它

2.方法一:使用_CrtDumpMemoryLeaks()

int main(int argc char* argv[])
{
    {
new int;}
    _CrtDumpMemoryLeaks();
    
return 0;
}

output:

Detected memory leaks!
Dumping objects ->
{49} normal block at 0x00384DA8, 4 bytes long.
 Data: <    > CD CD CD CD 
Object dump complete.

其内容包括:内存分配型号(在大括号内)、块类型(普通、客户端或 CRT)、 十六进制形式的内存位置、以字节为单位的块大小、以字节为单位的块大小、前 16 字节的内容(十六进制)

注意:

(1)大括号的位置,如果不加{new int;},这块内存是等到main函数结束才泄漏的,而_CrtDumpMemoryLeaks()是在main函数里调用的,于是判断内存泄漏

class A
{
public:
    
int* Data;
    A()
    {
        Data
=new int;
    }
    
~A()
    {
        delete Data;
    }
};

int main(int argc char* argv[])
{
    Test;
    _CrtDumpMemoryLeaks();
    
return 0;
}

output:

Detected memory leaks!
Dumping objects ->
{49} normal block at 0x00384DA8, 4 bytes long.
 Data: <    > CD CD CD CD 
Object dump complete.

(2)对于一些全局函数,如果初始化时申请了内存,到程序结束时候才释放,此函数会一直把新申请的内存当作泄漏来对待

Test;
int main(int argc char* argv[])
{
    _CrtDumpMemoryLeaks();
    
return 0;
}

output:

Dumping objects ->
{49} normal block at 0x00384DA8, 4 bytes long.
 Data: <    > CD CD CD CD 
Object dump complete.

2.方法二:在程序入口写几个语句,程序退出时,如果发现有内存泄漏,会自动在DEBUG OUTPUT窗口和DebugView中输出内存泄漏信息

int tmpFlag = _CrtSetDbgFlag( _CRTDBG_REPORT_FLAG );
 tmpFlag 
|= _CRTDBG_LEAK_CHECK_DF;
 _CrtSetDbgFlag( tmpFlag );

3.方法三:使用_CrtMemCheckpoint(),可以查出某程序段的内存泄漏情况

int main(int argc char* argv[])
{
    CrtMemState s1, s2, s3;
    _CrtMemCheckpoint( 
&s1 );
    
new int//程序段
    _CrtMemCheckpoint( &s2 );
    
if _CrtMemDifference( &s3, &s1, &s2) _CrtMemDumpStatistics( &s3 );
    
return 0;
}

output:

 bytes in 0 Free Blocks.
4 bytes in 1 Normal Blocks.
0 bytes in 0 CRT Blocks.
0 bytes in 0 Ignore Blocks.
0 bytes in 0 Client Blocks.
Largest number used: 0 bytes.
Total allocations: 4 bytes.


在编程中经常涉及到内存管理,于是便希望有个内存检测器来帮助我们debug。我们想检测内存泄漏,就必须记录程序中的内存分配和释放情况,同时我们也希望能记录内存分配代码所在行号和位置,也就是我们需要重载以下四个全局函数:

void* operator new(size_t Size, char* FileName, int LineNum);
void* operator new[](size_t Size, char* FileName, int LineNum);
void operator delete(void* Object);
void operator delete[](void* Object);

下面将描述如何实现一个简单的内存检测器

1.获得内存分配代码所在行号和位置

我们需要将缺省的全局new operator替换为带有文件名和行号的版本,代码如下:

#define new new(__FILE__, __LINE__ )

2.建立记录内存分配和释放情况的数据结构NewList

NewList中记录了内存分配代码所在行号、位置、内存分配后获得指针与大小。由于我们想记录整个程序中内存分配和释放情况,于是应实例化一个NewList全局对象NewRecord。

注意:全局对象应放在cpp中,如果放在.h中,.h文件又被多个文件include,于是会出现重定义

3.重载new和delete那四个全局函数

new:(1)分配内存,如果失败了抛出异常 (2)记录相关数据 (3)返回分配所得指针

注意在重载operator new[]时Size为0的情况,这时我们当Size=1;

delete :(1)找到相关数据并删除 (2)释放内存

void* operator new(size_t Size, char* FileName, int LineNum)
{
    
if (Size==(size_t)0Size=1;
    
void* Result=::operator new(Size);
    
if (!Result) throw bad_alloc();
    
else
    
{
        NewListNode Temp(Result, Size, FileName, LineNum);
        NewRecord.Add(Temp);
        
return Result;
    }

}


void* operator new[](size_t Size, char* FileName, int LineNum)
{
    
if (Size==(size_t)0Size=1;
    
void* Result=::operator new[](Size);
    
if (!Result) throw bad_alloc();
    
else
    
{
        NewListNode Temp(Result, Size, FileName, LineNum);
        NewRecord.Add(Temp);
        
return Result;
    }

}


void operator delete(void* Object)
{
    
if (!Object) return;
    NewRecord.Remove(Object);
    free(Object);
}


void operator delete[](void* Object)
{
    
if (!Object) return;
    NewRecord.Remove(Object); 
    free(Object);
}

4.如何打印出内存泄漏的有关信息

对于打印信息我们会有各种各样不同的要求,譬如输出到控制台,输出到文件,同时输出到控制台跟文件等。每一种情况都实现一个函数显然不可行,为了应付这种情况,我们可以考虑如下数据结构:

class Print{};
class PrintToConsole public Print{}; 

5.如何使用

(1)让所有代码都#include "DebugNew.h",如果有的代码包含而有的代码不包含,内存分配与释放信息也就记录不准确了。

(2)此代码无法处理多线程的情况

6.使用效果

#include "DebugNew.h"
#include 
<stdlib.h>
#include 
<iostream>
#include 
<conio.h>

using namespace std; 
    
int main(int argc char* argv[])
{
    
new int;
    Check();
    _getch();
    
return 0;
}


#include "DebugNew.h"
#include 
<stdlib.h>
#include 
<iostream>
#include 
<conio.h>

using namespace std; 
    
int main(int argc char* argv[])
{
    
int* p=new int;
    delete p;
    Check();
    _getch();
    
return 0;
}

DebugNew.h

 1#ifndef DEBUGNEW_H
 2#define DEBUGNEW_H
 3
 4#include <iostream>
 5#include <stdlib.h>
 6#include "Link.h"
 7#include "Print.h"
 8
 9using namespace std;
10
11class NewListNode
12{
13public:
14    void* Object; //内存分配后获得的指针
15    size_t Size; //内存分配的大小
16    char* FileName; //内存分配代码所在文件位置
17    int LineNum; //内存分配代码所在行号
18
19    NewListNode();
20    NewListNode(void* Buffer, size_t s, char* File, int Line);
21    NewListNode(const NewListNode& Temp);
22}
;
23
24class NewList
25{
26public:
27    Link<NewListNode> Data;
28
29    bool IsEmpty();
30    void Add(const NewListNode& Temp);
31    void Remove(void* Object);
32    void Check();
33}
;
34
35extern void* operator new(size_t Size, char* FileName, int LineNum);
36extern void* operator new[](size_t Size, char* FileName, int LineNum);
37extern void operator delete(void* Object);
38extern void operator delete[](void* Object);
39
40extern void Check();
41extern NewList NewRecord;
42
43#define new new(__FILE__, __LINE__ )
44#endif

 

DebugNew.cpp

  1#include "DebugNew.h"
  2#undef new
  3
  4NewListNode::NewListNode()
  5{
  6    Object=0;
  7    FileName=0;
  8}

  9
 10NewListNode::NewListNode(void* Buffer, size_t s, char* File, int Line)
 11{
 12    Object=Buffer;
 13    Size=s;
 14    FileName=File;
 15    LineNum=Line;
 16}

 17
 18NewListNode::NewListNode(const NewListNode& Temp)
 19{
 20    FileName=Temp.FileName;
 21    LineNum=Temp.LineNum;
 22    Object=Temp.Object;
 23    Size=Temp.Size;
 24}

 25
 26bool NewList::IsEmpty()
 27{
 28    if (Data.GetHead()) return false;
 29    else return true;
 30}

 31
 32void NewList::Add(const NewListNode& Temp)
 33{
 34    Data.AddLast()->Data=Temp;
 35}

 36
 37void NewList::Remove(void* Object)
 38{
 39    Node<NewListNode>* Temp=Data.GetHead();
 40    while (Temp)
 41    {
 42        if (Temp->Data.Object==Object)
 43        {
 44            Data.Delete(Temp);
 45            return;
 46        }

 47        Temp=Temp->Next;
 48    }

 49}

 50
 51void NewList::Check()
 52{
 53    PrintToConsole Printer;
 54    if (!IsEmpty())
 55    {
 56        Printer.Writeln("存在内存泄漏");
 57        Printer.Writeln("Line/tSize/tPath");
 58        Printer.WriteLine();
 59        Node<NewListNode>* Temp=Data.GetHead();
 60        while (Temp)
 61        {
 62            char Line[20];
 63            itoa(Temp->Data.LineNum, Line, 10);
 64            Printer.Write(Line);
 65            Printer.Write("/t");
 66            char s[200];
 67            itoa(Temp->Data.Size, s, 10);
 68            Printer.Write(s);
 69            Printer.Write("/t");
 70            Printer.Write(Temp->Data.FileName);
 71            Printer.Write("/t");
 72            Temp=Temp->Next;
 73        }

 74    }

 75    else Printer.Writeln("不存在内存泄漏");
 76}

 77
 78NewList NewRecord;
 79
 80void* operator new(size_t Size, char* FileName, int LineNum)
 81{
 82    if (Size==(size_t)0Size=1;
 83    void* Result=::operator new(Size);
 84    if (!Result) throw bad_alloc();
 85    else
 86    {
 87        NewListNode Temp(Result, Size, FileName, LineNum);
 88        NewRecord.Add(Temp);
 89        return Result;
 90    }

 91}

 92
 93void* operator new[](size_t Size, char* FileName, int LineNum)
 94{
 95    if (Size==(size_t)0Size=1;
 96    void* Result=::operator new[](Size);
 97    if (!Result) throw bad_alloc();
 98    else
 99    {
100        NewListNode Temp(Result, Size, FileName, LineNum);
101        NewRecord.Add(Temp);
102        return Result;
103    }

104}

105
106void operator delete(void* Object)
107{
108    if (!Object) return;
109    NewRecord.Remove(Object);
110    free(Object);
111}

112
113void operator delete[](void* Object)
114{
115    if (!Object) return;
116    NewRecord.Remove(Object); 
117    free(Object);
118}

119
120void Check()
121{
122    NewRecord.Check();
123}

 

Print.h

 1#ifndef PRINT_H
 2#define PRINT_H
 3
 4#include <stdlib.h>
 5#include <iostream>
 6
 7using namespace std;
 8
 9class Print
10{
11public:
12    virtual ~Print();    
13}
;
14
15class PrintToConsole public Print
16{
17public:
18    virtual ~PrintToConsole();
19    virtual void Write(char* String);
20    virtual void Writeln(char* String);
21    virtual void WriteLine();
22}

23
24#endif

 

Print.cpp

 1#include "Print.h"
 2
 3Print:: ~Print()
 4{
 5}

 6
 7PrintToConsole::~PrintToConsole()
 8{
 9}

10
11void PrintToConsole::Write(char* String)
12{
13    if (String) cout<<String;
14}

15
16void PrintToConsole::Writeln(char* String)
17{
18    if (String) cout<<String<<endl;
19    else cout<<endl;
20}

21    
22void PrintToConsole::WriteLine()
23{
24    cout<<"-------------------------------------------------------------------------------"<<endl;
25}

 

 

 

 

 

 

 

 

 

 

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{157normal block at 0x003AF1704 bytes long.
  4.  Data: 00 00 00 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.     intnew int();
  6.     _CrtDumpMemoryLeaks();
  7.     return 0;
  8. }

  运行后,在Output(输出)窗口,显示了如下的信息:

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

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

  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. int _tmain(int argc, _TCHAR* argv[])
  13. {
  14.     intnew int();
  15.     _CrtDumpMemoryLeaks();
  16.     return 0;
  17. }

  该程序定义了几个宏,通过宏将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, bytes long.
  4.  Data:    00 00 00 00 
  5. Object dump complete.

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

  1. int _tmain(int argc, _TCHAR* argv[])
  2. {
  3.     intnew int();
  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 new int();     }
  16.     ~Test()       delete _p;          }
  17.     int_p;
  18. };
  19. int _tmain(int argc, _TCHAR* argv[])
  20. {
  21.     intnew int();
  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 new int();     }
  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.     intnew int();
  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 _CrtDumpMemoryLeaks();
  16.     assert( == 0);
  17. }
  18. int _tmain(int argc, _TCHAR* argv[])
  19. {
  20.     atexit(Exit);
  21.     intnew int();
  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文件中,该文件包含一些通用的,基本所有文件都会用到的代码东东。

  好了,到现在,检测内存泄露总算完成了,而且他还能定位到到底是代码中哪个文件,哪行出现了内存泄露。下一篇文章将会讲些实际遇到的一些问题,例如只知道有内存泄露,但是不知道到底内存泄露的具体位置,如何利用内存断点等技术来定位内存泄露的位置啊,最后会从代码的角度讲下,怎么样才能避免内存泄露吧。

0

阅读 评论 收藏 转载 喜欢 打印举报/Report
  • 评论加载中,请稍候...
发评论

    发评论

    以上网友发言只代表其个人观点,不代表新浪网的观点或立场。

      

    新浪BLOG意见反馈留言板 电话:4000520066 提示音后按1键(按当地市话标准计费) 欢迎批评指正

    新浪简介 | About Sina | 广告服务 | 联系我们 | 招聘信息 | 网站律师 | SINA English | 会员注册 | 产品答疑

    新浪公司 版权所有