Memory leak detector(C++)

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/.