C++中基于Crt的内存泄漏检测

尽管这个概念已经让人说滥了 ，还是想简单记录一下， 以备以后查询。

#ifdef _DEBUG
#define  DEBUG_CLIENTBLOCK   new( _CLIENT_BLOCK, __FILE__, __LINE__)
#else
#define  DEBUG_CLIENTBLOCK
#endif
#define  _CRTDBG_MAP_ALLOC
#include 
#ifdef _DEBUG
#define  new DEBUG_CLIENTBLOCK
#endif


int  _tmain( int  argc, _TCHAR* argv[])
{
     char * p =  new  char ();
     char * pp =  new  char [10];
     char * ppp = ( char *)malloc(10);

    _CrtDumpMemoryLeaks();

     return  0;
}

主要原理是运用Crt 的内存调试功能, 通过宏替代默认的operator new, 让它被下面版本替代:

void  *__CRTDECL  operator  new (
        size_t cb,
         int  nBlockUse,
         const  char  * szFileName,
         int  nLine
        )
        _THROW1(_STD bad_alloc)
{
     /*  _nh_malloc_dbg already calls _heap_alloc_dbg in a loop and calls _callnewh
       if the allocation fails. If _callnewh returns (very likely because no
       new handlers have been installed by the user), _nh_malloc_dbg returns NULL.
      */
     void  *res = _nh_malloc_dbg( cb, 1, nBlockUse, szFileName, nLine );

    RTCCALLBACK(_RTC_Allocate_hook, (res, cb, 0));

     /*  if the allocation fails, we throw std::bad_alloc  */
     if  (res == 0)
    {
         static  const  std::bad_alloc nomem;
        _RAISE(nomem);
    }

     return  res;
}

这样Crt会把此次分配内存的文件名和行号以及大小等记录下来，最后当调用用 _CrtDumpMemoryLeaks();  时如果还没释放就会打印出来。
结果如下:

Detected memory leaks!
Dumping objects ->
f:\test\memleakchecker\memleakchecker\memleakchecker.cpp(23) : {108} normal block at 0x0003A1A8, 10 bytes  long .
 Data: <          > CD CD CD CD CD CD CD CD CD CD 
f:\test\memleakchecker\memleakchecker\memleakchecker.cpp(22) : {107} client block at 0x0003A160, subtype 0, 10 bytes  long .
 Data: <          > CD CD CD CD CD CD CD CD CD CD 
f:\test\memleakchecker\memleakchecker\memleakchecker.cpp(21) : {106} client block at 0x0003A120, subtype 0, 1 bytes  long .
 Data: < > 00 
Object dump complete.

下面是一些注意事项：
（1）  #define  _CRTDBG_MAP_ALLOC 的作用
如果不定义这个宏， C方式的malloc泄露不会被记录下来。

（2）数字 { 108 } {107}的作用
表示第几次分配， 你可以通过 _CrtSetBreakAlloc程序运行到预定次数时暂停  ，比如

int  _tmain( int  argc, _TCHAR* argv[])
{
    _CrtSetBreakAlloc(108);

     char * p =  new  char ();
     char * pp =  new  char [10];
     char * ppp = ( char *)malloc(10);

    _CrtDumpMemoryLeaks();

     return  0;
}

（3）如果程序有多个出口或是有涉及到全局变量， 可以通过 _CrtSetDbgFlag  设置标志让程序退出时自动打印泄露 ， 比如

int  _tmain( int  argc, _TCHAR* argv[])
{
    _CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );

     char * p =  new  char ();
     char * pp =  new  char [10];
     char * ppp = ( char *)malloc(10);

     return  0;
}

（4）我们知道宏替代是最粗暴的方式， 所以尽量把下面new的替代宏放到每个Cpp里而不是放到一个通用的头文件中， 实际上MFC也是这么做的

#ifdef _DEBUG
#define  new DEBUG_CLIENTBLOCK
#endif

（5）上面的operator new只能照顾到最普通的new, 实际上operator new是有任意多种重载方式， 只需要确保第一个参数是表示大小。 比如下面的placement new就会编译失败， 因为宏替代后格式不符合要求了， 所以如果你的CPP用了非标准的new, 就不要加入new的检测宏了。

#include < new >

#ifdef _DEBUG
#define  DEBUG_CLIENTBLOCK   new( _CLIENT_BLOCK, __FILE__, __LINE__)
#else
#define  DEBUG_CLIENTBLOCK
#endif
#define  _CRTDBG_MAP_ALLOC
#include 
#ifdef _DEBUG
#define  new DEBUG_CLIENTBLOCK
#endif


int  _tmain( int  argc, _TCHAR* argv[])
{
    _CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );

     char * p =  new  char ();
     char * pp =  new  char [10];
     char * ppp = ( char *)malloc(10);

     char  d;
     char *  p1  =  new ( & d)  char ( ' a ' );

     return  0;
}

（6）因为STL里map内的tree用到了placement new,  所以如果你这样用会编译失败：

#ifdef _DEBUG
#define  DEBUG_CLIENTBLOCK   new( _CLIENT_BLOCK, __FILE__, __LINE__)
#else
#define  DEBUG_CLIENTBLOCK
#endif
#define  _CRTDBG_MAP_ALLOC
#include 
#ifdef _DEBUG
#define  new DEBUG_CLIENTBLOCK
#endif

#include 

你应该把  #include  < map >放到 宏定义的前面。

（7） 如果你在宏  #define  new DEBUG_CLIENTBLOCK 之后再声明或定义 operator new函数， 都会因为宏替代而编译失败。
而STL的xdebug文件恰恰申明了operator new函数， 所以请确保new的替代宏放在所有include头文件的最后， 尤其要放在STL头文件的后面。

//MyClass.cpp

#include "myclass.h"
#include 
#include 

#ifdef _DEBUG
#define  new DEBUG_CLIENTBLOCK
#endif

MyClass::MyClass()
{
    char* p = new char('a');
}

(8)如果你觉得上面的这种new替代宏分散在各个CPP里太麻烦， 想把所有的东西放到一个通用头文件里，请参考下面定义的方式:

// MemLeakChecker.h 
#include 
#include 
// other STL file

#ifdef _DEBUG
#define  DEBUG_CLIENTBLOCK   new( _CLIENT_BLOCK, __FILE__, __LINE__)
#else
#define  DEBUG_CLIENTBLOCK
#endif
#define  _CRTDBG_MAP_ALLOC
#include 
#ifdef _DEBUG
#define  new DEBUG_CLIENTBLOCK
#endif

 
（9）简单判断某个独立函数有没有内存泄露可以用下面的方法:

class  DbgMemLeak
{
    _CrtMemState m_checkpoint;

public :
     explicit  DbgMemLeak() 
    {   
        _CrtMemCheckpoint(&m_checkpoint); 
    };

    ~DbgMemLeak()
    {
        _CrtMemState checkpoint;
        _CrtMemCheckpoint(&checkpoint);
        _CrtMemState diff;
        _CrtMemDifference(&diff, &m_checkpoint, &checkpoint);
        _CrtMemDumpStatistics(&diff);
        _CrtMemDumpAllObjectsSince(&diff);
    };
};


int  _tmain( int  argc, _TCHAR* argv[])
{
    DbgMemLeak check;
    {
         char * p =  new  char ();
         char * pp =  new  char [10];
         char * ppp = ( char *)malloc(10);
    }

     return  0;
}

 

 (10) 其实知道了原理, 自己写一套C++内存泄露检测也不难, 主要是重载operator new和operator delete, 可以把每次内存分配情况都记录在一个Map里， delete时删除记录， 最后程序退出时把map里没有delete的打印出来。 当然我们知道Crt在实现new时一般实际上调的是malloc, 而malloc可能又是调HeapAlloc，而HeapAlloc可能又是调用RtlAllocateHeap， 所以理论上我们可以在这些函数的任意一层拦截和记录。但是如果你要实现自己的跨平台内存泄露检测，还是重载operator new吧。

 

转载于:https://www.cnblogs.com/weiym/archive/2013/02/25/2932810.html