Memory leak detector ( C++)
This is a simple solution for memory leak detector.
For any C++ software source under windows, please follow these steps:
1. You need to put MemoryTracker.h and MemoryAllocateTracker.h into include folder, and force all *.cpp file to include MemoryTracker.h first(when using MVS C++/Using precompiled headers, we usually include it within stdafx.h, and remove all MVS C++ generated DEBUG_NEW if exists);
2. Besides, modify the log file location(which is now c:\temp\) in MemoryAllocateTracker.cpp, and rebuild the version of MemoryAllocateTracker.dll;
3. Also make sure no other 'replace new' exists in your C++ source;
For any issues, please feel free to send email to health_163@163.com.
MemoryTracker.h
#pragma once #ifdef _DEBUG #pragma comment(lib, "MemoryAllocateTracker.lib") #include " MemoryAllocateTracker.h " #ifdef new #undef new #endif inline void * __cdecl operator new (size_t size, const char * file, int line) { return MemoryAllocateTracker::GetInstance().re_malloc_dbg(size, _NORMAL_BLOCK, file, line); } inline void * __cdecl operator new [](size_t size, const char * file, int line) { return operator new (size, file, line); } inline void __cdecl operator delete( void * ptr) { MemoryAllocateTracker::GetInstance().re_free_dbg(ptr, _NORMAL_BLOCK); } inline void __cdecl operator delete[]( void * ptr) { delete ptr; } #ifdef DEBUG_NEW #undef DEBUG_NEW #endif #define DEBUG_NEW new (__FILE__, __LINE__) #define new DEBUG_NEW #ifdef malloc #undef malloc #endif #define malloc(s) MemoryAllocateTracker::GetInstance().re_malloc_dbg(s, _NORMAL_BLOCK, __FILE__, __LINE__) #ifdef calloc #undef calloc #endif #define calloc(c, s) MemoryAllocateTracker::GetInstance().re_calloc_dbg(c, s, _NORMAL_BLOCK, __FILE__, __LINE__) #ifdef realloc #undef realloc #endif #define realloc(p, s) MemoryAllocateTracker::GetInstance().re_realloc_dbg(p, s, _NORMAL_BLOCK, __FILE__, __LINE__) // #define _recalloc(p, c, s) _recalloc_dbg(p, c, s, _NORMAL_BLOCK, __FILE__, __LINE__) // #define _expand(p, s) _expand_dbg(p, s, _NORMAL_BLOCK, __FILE__, __LINE__) #ifdef free #undef free #endif #define free(p) MemoryAllocateTracker::GetInstance().re_free_dbg(p, _NORMAL_BLOCK) // #define _msize(p) _msize_dbg(p, _NORMAL_BLOCK) // #define _aligned_msize(p, a, o) _aligned_msize_dbg(p, a, o) // #define _aligned_malloc(s, a) _aligned_malloc_dbg(s, a, __FILE__, __LINE__) // #define _aligned_realloc(p, s, a) _aligned_realloc_dbg(p, s, a, __FILE__, __LINE__) // #define _aligned_recalloc(p, c, s, a) _aligned_recalloc_dbg(p, c, s, a, __FILE__, __LINE__) // #define _aligned_offset_malloc(s, a, o) _aligned_offset_malloc_dbg(s, a, o, __FILE__, __LINE__) // #define _aligned_offset_realloc(p, s, a, o) _aligned_offset_realloc_dbg(p, s, a, o, __FILE__, __LINE__) // #define _aligned_offset_recalloc(p, c, s, a, o) _aligned_offset_recalloc_dbg(p, c, s, a, o, __FILE__, __LINE__) // #define _aligned_free(p) _aligned_free_dbg(p) // // #define _malloca(s) _malloca_dbg(s, _NORMAL_BLOCK, __FILE__, __LINE__) // #define _freea(p) _freea_dbg(p, _NORMAL_BLOCK) // // #define _strdup(s) _strdup_dbg(s, _NORMAL_BLOCK, __FILE__, __LINE__) // #define _wcsdup(s) _wcsdup_dbg(s, _NORMAL_BLOCK, __FILE__, __LINE__) // #define _mbsdup(s) _strdup_dbg(s, _NORMAL_BLOCK, __FILE__, __LINE__) // #define _tempnam(s1, s2) _tempnam_dbg(s1, s2, _NORMAL_BLOCK, __FILE__, __LINE__) // #define _wtempnam(s1, s2) _wtempnam_dbg(s1, s2, _NORMAL_BLOCK, __FILE__, __LINE__) // #define _fullpath(s1, s2, le) _fullpath_dbg(s1, s2, le, _NORMAL_BLOCK, __FILE__, __LINE__) // #define _wfullpath(s1, s2, le) _wfullpath_dbg(s1, s2, le, _NORMAL_BLOCK, __FILE__, __LINE__) // #define _getcwd(s, le) _getcwd_dbg(s, le, _NORMAL_BLOCK, __FILE__, __LINE__) // #define _wgetcwd(s, le) _wgetcwd_dbg(s, le, _NORMAL_BLOCK, __FILE__, __LINE__) // #define _getdcwd(d, s, le) _getdcwd_dbg(d, s, le, _NORMAL_BLOCK, __FILE__, __LINE__) // #define _wgetdcwd(d, s, le) _wgetdcwd_dbg(d, s, le, _NORMAL_BLOCK, __FILE__, __LINE__) // #define _getdcwd_nolock(d, s, le) _getdcwd_lk_dbg(d, s, le, _NORMAL_BLOCK, __FILE__, __LINE__) // #define _wgetdcwd_nolock(d, s, le) _wgetdcwd_lk_dbg(d, s, le, _NORMAL_BLOCK, __FILE__, __LINE__) // #define _dupenv_s(ps1, size, s2) _dupenv_s_dbg(ps1, size, s2, _NORMAL_BLOCK, __FILE__, __LINE__) // #define _wdupenv_s(ps1, size, s2) _wdupenv_s_dbg(ps1, size, s2, _NORMAL_BLOCK, __FILE__, __LINE__) #if !__STDC__ #ifdef strdup #undef strdup #endif #define strdup(s) MemoryAllocateTracker::GetInstance().re_strdup_dbg(s, _NORMAL_BLOCK, __FILE__, __LINE__) #ifdef wcsdup #undef wcsdup #endif #define wcsdup(s) MemoryAllocateTracker::GetInstance().re_wcsdup_dbg(s, _NORMAL_BLOCK, __FILE__, __LINE__) #ifdef tempnam #undef tempnam #endif #define tempnam(s1, s2) MemoryAllocateTracker::GetInstance().re_tempnam_dbg(s1, s2, _NORMAL_BLOCK, __FILE__, __LINE__) // #ifdef getcwd // #undef getcwd // #endif // #define getcwd(s, le) MemoryAllocateTracker::GetInstance().re_getcwd_dbg(s, le, _NORMAL_BLOCK, __FILE__, __LINE__) #endif #endif
MemoryAllocateTracker.h
#pragma once #ifdef MEMORY_ALLOC_TRACKER #define MEMORY_ALLOC_TRACKER_CLASS _declspec(dllexport) #define MEMORY_ALLOC_TRACKER_FUNC _declspec(dllexport) #else #define MEMORY_ALLOC_TRACKER_CLASS _declspec(dllimport) #define MEMORY_ALLOC_TRACKER_FUNC _declspec(dllimport) #endif class MEMORY_ALLOC_TRACKER_CLASS MemoryAllocateTracker { public : enum AllocState { AS_NOW, AS_MIN, AS_MAX }; public : static MemoryAllocateTracker & GetInstance(); int GetAllocatedSize(AllocState state) const ; void Alloc( void * addr, size_t size, const char * file, long line); void Dealloc( void * addr); void WriteLog( const char * file = " C:\\temp\\MemoryLeakTracker.txt " ); public : void re_free_dbg( void * addr, int blockType); void * re_malloc_dbg(size_t size, int blockType, const char * file, int line); void * re_calloc_dbg(size_t num, size_t size, int blockType, const char * file, int line); void * re_realloc_dbg( void * addr, size_t size, int blockType, const char * file, int line); char * re_strdup_dbg( const char * str, int blockType, const char * file, int line ); wchar_t * re_wcsdup_dbg( const wchar_t * str, int blockType, const char * file, int line ); char * re_tempnam_dbg( const char * dirname, const char * filePrefix, int blockType, const char * file, int line ); char * re_getcwd_dbg( char * buf, int size, int blockType, const char * file, int line ); private : MemoryAllocateTracker(); ~ MemoryAllocateTracker(); };
MemoryAllocateTracker.pp
#include < string > #include < iomanip > #include < fstream > #include < map > #include < set > #include " MemoryAllocateTracker.h " #ifndef _CRTBLD #define _CRTBLD #include < dbgint.h > #endif #pragma data_seg("SharedData") namespace { long g_TotalAllocCount = 0 ; HANDLE g_hProcHeap = 0 ; // TEMPLATE CLASS allocator template < class _Ty > class SpecAllocator { // generic allocator for objects of class _Ty public : typedef typename _Ty value_type; typedef value_type _FARQ * pointer; typedef value_type _FARQ & reference; typedef const value_type _FARQ * const_pointer; typedef const value_type _FARQ & const_reference; typedef _SIZT size_type; typedef _PDFT difference_type; template < class _Other > struct rebind { // convert an allocator<_Ty> to an allocator <_Other> typedef SpecAllocator < _Other > other; }; pointer address(reference _Val) const { // return address of mutable _Val return ( & _Val); } const_pointer address(const_reference _Val) const { // return address of nonmutable _Val return ( & _Val); } SpecAllocator() _THROW0() { // construct default allocator (do nothing) } SpecAllocator( const SpecAllocator < _Ty >& ) _THROW0() { // construct by copying (do nothing) } template < class _Other > SpecAllocator( const SpecAllocator < _Other >& ) _THROW0() { // construct from a related allocator (do nothing) } template < class _Other > SpecAllocator < _Ty >& operator = ( const SpecAllocator < _Other >& ) { // assign from a related allocator (do nothing) return ( * this ); } void deallocate(pointer _Ptr, size_type) { // deallocate object at _Ptr, ignore size // ::HeapFree(g_hProcHeap, 0, _Ptr); free(_Ptr); } pointer allocate(size_type _Count) { // allocate array of _Count elements g_TotalAllocCount += _Count; // check for integer overflow if (_Count <= 0 ) _Count = 0 ; else if (((_SIZT)( - 1 ) / _Count) < sizeof (_Ty)) _THROW_NCEE(std::bad_alloc, NULL); // return (pointer)::HeapAlloc(g_hProcHeap, 0, _Count); return (pointer)_malloc_dbg(_Count * sizeof (_Ty), 1 , __FILE__, __LINE__); } pointer allocate(size_type _Count, const void _FARQ * ) { // allocate array of _Count elements, ignore hint return (allocate(_Count)); } void construct(pointer _Ptr, const _Ty & _Val) { // construct object at _Ptr with value _Val _Construct(_Ptr, _Val); } void destroy(pointer _Ptr) { // destroy object at _Ptr _Destroy(_Ptr); } _SIZT max_size() const _THROW0() { // estimate maximum array size _SIZT _Count = (_SIZT)( - 1 ) / sizeof (_Ty); return ( 0 < _Count ? _Count : 1 ); } }; // typedef std::basic_string<char, std::char_traits<char>, SpecAllocator<char> > SpecString; typedef char * SpecString; // typedef std::string SpecString; typedef std:: set < int , std::less < int > , SpecAllocator < int > > SpecSet; struct TrackerNode { SpecString file; long lineNum; long allocSize; long count; long totalCount; long leakCount; TrackerNode( const char * f = 0 , long l = 0 , long s = 0 , long c = 1 ) : file(f != 0 ? f : " (No file path!) " ), lineNum(l),allocSize(s), count(c), totalCount( 1 ), leakCount( 0 ) { } TrackerNode( const TrackerNode & o) : file(o.file), lineNum(o.lineNum),allocSize(o.allocSize), count(o.count), totalCount( 1 ), leakCount( 0 ) { } ~ TrackerNode() { } static void * operator new (size_t size) { return _malloc_dbg(size, 1 , __FILE__, __LINE__); // return ::HeapAlloc(g_hProcHeap, 0, size); } static void operator delete( void * ptr) { // ::HeapFree(g_hProcHeap, 0, ptr); free(ptr); } }; // todo: It should be changed it to shared ptr later. typedef TrackerNode * TrackerNodePtr; typedef const TrackerNode * TrackerNodeConstPtr; inline bool operator < ( const TrackerNode & lt, const TrackerNode & rh) { if (lt.lineNum < rh.lineNum) { return true ; } else if (lt.lineNum == rh.lineNum && lt.file < rh.file) { return true ; } else if (lt.lineNum == rh.lineNum && lt.file == rh.file && lt.allocSize < rh.allocSize) { return true ; } return false ; } template < class _Ty = TrackerNode > struct LessForSort: public std::binary_function < _Ty, _Ty, bool > { bool operator () ( const _Ty & lt, const _Ty & rh) const { return lt.allocSize * lt.count > rh.allocSize * rh.count; } }; } template <> struct std::less < TrackerNodePtr > : public std::binary_function < TrackerNodePtr, TrackerNodePtr, bool > { bool operator () ( const TrackerNodePtr & lt, const TrackerNodePtr & rh) const { if (lt -> lineNum < rh -> lineNum) { return true ; } else if (lt -> lineNum == rh -> lineNum && lt -> file < rh -> file) { return true ; } else if (lt -> lineNum == rh -> lineNum && lt -> file == rh -> file && lt -> allocSize < rh -> allocSize) { return true ; } return false ; } }; namespace { struct AddrCountPair { long count; TrackerNodePtr addr; AddrCountPair( long c = 0 , TrackerNodePtr ptr = 0 ): count(c), addr(ptr) {} }; typedef std::map < int * ,AddrCountPair ,std::less < int *> ,SpecAllocator < std::pair < const int * , AddrCountPair > > > TrackerPtrMap; typedef TrackerPtrMap::iterator TrackerPtrMapItr; typedef std:: set < TrackerNodePtr ,std::less < TrackerNodePtr > ,SpecAllocator < TrackerNodePtr > > TrackerPtrSet; typedef TrackerPtrSet::iterator TrackerPtrSetItr; typedef std:: set < TrackerNode ,std::less < TrackerNode > ,SpecAllocator < TrackerNode > > TrackerSet; typedef TrackerSet::iterator TrackerSetItr; typedef std:: set < TrackerNode ,LessForSort <> ,SpecAllocator < TrackerNode > > TrackerSortedSet; typedef TrackerSortedSet::iterator TrackerSortedSetItr; long g_totalAlloc = 0 ; TrackerPtrMap g_allocMap; TrackerPtrSet g_allocSet; CMemoryState g_mfcMemStateBegin, g_mfcMemStateEnd; } namespace { class Mutex { friend class Lock; public : Mutex () { InitializeCriticalSection ( & _critSection); } ~ Mutex () { DeleteCriticalSection ( & _critSection); } private : void Acquire () { EnterCriticalSection ( & _critSection); } void Release () { LeaveCriticalSection ( & _critSection); } private : CRITICAL_SECTION _critSection; }; Mutex _mutex; class Lock { public : // Acquire the state of the semaphore Lock () { _mutex.Acquire(); } // Release the state of the semaphore ~ Lock () { _mutex.Release(); } }; } // see bellow...
MemoryAllocateTracker::MemoryAllocateTracker() { if (g_hProcHeap == 0 ) { // g_hProcHeap = ::HeapCreate(HEAP_CREATE_ENABLE_EXECUTE, 0, 0); } g_mfcMemStateBegin.Checkpoint(); } MemoryAllocateTracker:: ~ MemoryAllocateTracker() { Lock threadlock; WriteLog(); if (g_hProcHeap != 0 ) { // ::HeapDestroy(g_hProcHeap); g_hProcHeap = 0 ; } } int MemoryAllocateTracker::GetAllocatedSize(AllocState state) const { return 0 ; } void MemoryAllocateTracker::Alloc( void * addr, size_t size, const char * file, long line) { Lock threadlock; g_totalAlloc += size; TrackerNode node(file, line, size, 1 ) ; TrackerPtrSetItr it = g_allocSet.find( & node); if (it != g_allocSet.end()) { ( * it) -> count ++ ; ( * it) -> totalCount ++ ; g_allocMap[( int * )addr] = AddrCountPair(( * it) -> totalCount, ( * it)); } else { TrackerNodePtr nodeptr = new TrackerNode(node); g_allocSet.insert(nodeptr); g_allocMap[( int * )addr] = AddrCountPair(nodeptr -> totalCount, nodeptr); } } void MemoryAllocateTracker::Dealloc( void * addr) { Lock threadlock; TrackerPtrMapItr it = g_allocMap.find(( int * )addr); if (it != g_allocMap.end()) { g_totalAlloc -= it -> second.addr -> allocSize; -- (it -> second.addr -> count); g_allocMap.erase(it); g_TotalAllocCount -- ; } } MemoryAllocateTracker & MemoryAllocateTracker::GetInstance() { static MemoryAllocateTracker tracker; return tracker; } void MemoryAllocateTracker::WriteLog( const char * file) { double totalSizeAllocatedBySelf = double (g_TotalAllocCount) / 1024 ; if ( true ) { std::ofstream out ( " C:\\temp\\_MemoryLeakTracker.txt " ); if ( out .fail()) { return ; } out << std::setw( 24 ) << std::setprecision( 3 ) << " \t Total Size Allocated by MemoryAllocateTracker.dll:\t " << totalSizeAllocatedBySelf << " kb \n " << std::endl << " \t Total Size of Memory Leak(without MFC):\t " << double (g_totalAlloc) / 1024 << " kb \n " << std::endl << " \t Size(bytes) \t Count(times) \t Total(kb) \t First Leak Count \t Line number \t file location\n\n " ; for (TrackerPtrMapItr it = g_allocMap.begin(); it != g_allocMap.end(); ++ it) { AddrCountPair & pair = it -> second; if (pair.addr -> leakCount <= 0 || pair.count < pair.addr -> leakCount) { pair.addr -> leakCount = pair.count; } } for (TrackerPtrSetItr it = g_allocSet.begin(); it != g_allocSet.end();) { TrackerNodePtr ptr = * it; if (ptr -> count > 0 ) { out << " \t " << ptr -> allocSize << " \t\t " << ptr -> count << " \t\t " << double (ptr -> count * ptr -> allocSize) / 1024 << " \t\t " << ptr -> leakCount << " \t\t " << ptr -> lineNum << " \t\t " << ptr -> file << std::endl; } it = g_allocSet.erase(it); // Do not use free(ptr), else memory of (*ptr)->file is not released. delete ptr; } g_allocMap.clear(); out .flush(); out .close(); } g_mfcMemStateEnd.Checkpoint(); TrackerSet trackerSet ; _CrtMemBlockHeader * ptr = g_mfcMemStateEnd.m_memState.pBlockHeader; long mfcLeakSize = 0 ; while (ptr && ptr != g_mfcMemStateBegin.m_memState.pBlockHeader) { TrackerNode node(ptr -> szFileName, ptr -> nLine, ptr -> nDataSize, 1 ); mfcLeakSize += ptr -> nDataSize; TrackerSetItr it = trackerSet.find(node); if (it != trackerSet.end()) { it -> count ++ ; } else { trackerSet.insert(node); } ptr = ptr -> pBlockHeaderNext; } std::ofstream mfcOut(file); mfcOut << std::setw( 16 ) << std::setprecision( 3 ); mfcOut << " \t Total Size Allocated by MemoryAllocateTracker.dll:\t " << totalSizeAllocatedBySelf << " kb \n " << std::endl << " \n\t Total Size of Memory Leak:\t " << double (mfcLeakSize) / 1024 << " kb\n " << std::endl << " \t Size(bytes) \t Count(times) \t Total(kb) \t Line number \t file location " << std::endl; const bool needChecked = false ; if (needChecked && ptr) { _CrtMemBlockHeader * xptr = ptr; _CrtMemBlockHeader * rexptr = g_mfcMemStateBegin.m_memState.pBlockHeader; size_t count = 0 ; while (xptr || rexptr) { if (xptr != rexptr || ++ count > 1000 ) { mfcOut << " Got Stupid ! " << std::endl; break ; } xptr = xptr ? xptr -> pBlockHeaderNext : xptr; rexptr = rexptr ? rexptr -> pBlockHeaderNext : rexptr; } } TrackerSortedSet sortedSet(trackerSet.begin(), trackerSet.end()); for (TrackerSortedSetItr it = sortedSet.begin(); it != sortedSet.end(); ++ it) { mfcOut << " \t " << it -> allocSize << " \t\t " << it -> count << " \t\t " << double (it -> allocSize * it -> count) / 1024 << " \t\t " << it -> lineNum << " \t\t " << it -> file << std::endl; } mfcOut << " \n\n\t========================================== " << " File Order ==========================================\n\n " ; for (TrackerSetItr it = trackerSet.begin(); it != trackerSet.end(); ++ it) { mfcOut << " \t " << it -> allocSize << " \t\t " << it -> count << " \t\t " << double (it -> allocSize * it -> count) / 1024 << " \t\t " << it -> lineNum << " \t\t " << it -> file << std::endl; } mfcOut.flush(); mfcOut.close(); } void MemoryAllocateTracker::re_free_dbg( void * addr, int blockType) { _free_dbg(addr, blockType); Dealloc(addr); } void * MemoryAllocateTracker::re_malloc_dbg(size_t size, int blockType, const char * file, int line) { void * addr = _malloc_dbg(size, blockType, file, line); Alloc(addr, size, file, line); return addr; } void * MemoryAllocateTracker::re_calloc_dbg(size_t num, size_t size, int blockType, const char * file, int line) { void * addr = _calloc_dbg(num, size, blockType, file, line); Alloc(addr, num * size, file, line); return addr; } void * MemoryAllocateTracker::re_realloc_dbg( void * addr, size_t size, int blockType, const char * file, int line) { addr = _realloc_dbg(addr, size, blockType, file, line); Alloc(addr, size, file, line); return addr; } char * MemoryAllocateTracker::re_strdup_dbg( const char * str, int blockType, const char * file, int line ) { char * addr = _strdup_dbg(str, blockType, file, line); Alloc(addr, strlen(addr), file, line); return addr; } wchar_t * MemoryAllocateTracker::re_wcsdup_dbg( const wchar_t * str, int blockType, const char * file, int line ) { wchar_t * addr = _wcsdup_dbg(str, blockType, file, line); Alloc(addr, wcslen(addr), file, line); return addr; } char * MemoryAllocateTracker::re_tempnam_dbg( const char * dirname, const char * filePrefix, int blockType, const char * file, int line ) { char * addr = _tempnam_dbg(dirname, filePrefix, blockType, file, line); Alloc(addr, 123 , file, line); return addr; } char * MemoryAllocateTracker::re_getcwd_dbg( char * buf, int size, int blockType, const char * file, int line ) { char * addr = _getcwd_dbg(buf, size, blockType, file, line); Alloc(addr, 123 , file, line); return addr; }#pragma data_seg() #pragma comment(linker,"/section:SharedData,rws")
For MFC memory check, please refer to Detecting memory leaks: by using CRT diagnostic functions - Part1
and Inside CRT: Debug Heap Management
To figure out the function call stack, you need to use dbhelp API within the source above under windows NT.
Or else, Visual Leak Detector is also a good choice, also see http://vld.codeplex.com/.
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
