【转】c++内存泄露检测，长文慎入！

原文网址：http://blog.csdn.net/zengraoli/article/details/8905334

关于内存泄露的，今天无意想到，网上找了一下

 

本篇blog附带的所有工具和代码下载地址如下：

http://download.csdn.net/detail/zengraoli/5348827

文中的memcheck晚点的时候在把它打包成dll

一、使用Dbgview.exe

不多数都是用的Dbgview.exe，话说还不错，我一直想找的仅仅是一个检测内存泄露的class，没想到csdn上面问，找到了这么一个工具，参看csdn论坛链接http://bbs.csdn.net/topics/390452307

来个测试工程：

#include <iostream>
#include "string"
#include "vector"
using namespace std;

int main()
{
    {
        char *str;
        str = new char[100 + 1];

        strcpy(str, "zengraoli");

        cout << str << endl;
    }

    _CrtDumpMemoryLeaks();   // 内存泄露检测

    return 0;
}

Ctrl+F5后，在Dbgview.exe中出现了下面的信息：

Detected memory leaks

这个是提示

上面的测试不方便的地方：

但在这上面显然有不太好的地方，比如我需要知道哪一行导致的内存泄露，所以参考csdn blog的一篇文章：http://blog.csdn.net/iuhsihsow/article/details/8492363

再次修改：

#include "stdafx.h"
#include <iostream>
#include "string"
#include "vector"
using namespace std;

#ifdef  _DEBUG
#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>
#define newEx   new(_NORMAL_BLOCK, __FILE__, __LINE__)
#endif

inline void EnableMemLeakCheck()
{
    _CrtSetDbgFlag(_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) | _CRTDBG_LEAK_CHECK_DF);
}

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

    char *str = newEx char[9 + 1];

    cout << str << endl;

    return 0;
}

Ctrl+F5后，在Dbgview.exe中出现了下面的信息：

可以看到正是25行的地方导致内存泄露的

二、不使用Dbgview.exe，直接使用class

参考文章：http://www.cnblogs.com/FCoding/archive/2012/07/04/2576877.html

Code没来得及细看，能用就是了^_^，方便就行，枉自猜测一下原理----------重载了new和delete，对他俩进行一个计数，并记下行数，两个不为偶数，则就是代表已经出现内存泄露了

MemCheck.h：

#ifndef MEMCHECK_H
#define MEMCHECK_H
#include <cstddef>  // for size_t

// Hijack the new operator (both scalar and array versions)
void* operator new(std::size_t, const char*, long);
void* operator new[](std::size_t, const char*, long);
#define new new (__FILE__, __LINE__)

extern bool traceFlag;
#define TRACE_ON() traceFlag = true
#define TRACE_OFF() traceFlag = false

extern bool activeFlag;
#define MEM_ON() activeFlag = true
#define MEM_OFF() activeFlag = false

#endif

MemCheck.cpp：

#include <cstdio>
#include <cstdlib>
#include <cassert>
using namespace std;
#undef new

// Global flags set by macros in MemCheck.h
bool traceFlag  = true;
bool activeFlag = false;

namespace
{
    // Memory map entry type
    struct Info
    {
        void* ptr;
        const char* file;
        long  line;
    };

    // Memory map data
    const  size_t MAXPTRS = 10000u;
    Info   memMap[MAXPTRS];
    size_t nptrs = 0;

    // Searches the map for an address
    int findPtr(void* p)
    {
        for (int i = 0; i < nptrs; ++i)
        {
            if (memMap[i].ptr == p)
            {
                return i;
            }
        }
        return -1;
    }

    void delPtr(void* p)
    {
        int pos = findPtr(p);
        assert(p >= 0);
        // Remove pointer from map
        for (size_t i = pos; i < nptrs-1; ++i)
        {
            memMap[i] = memMap[i+1];
        }
        --nptrs;
    }

    // Dummy type for static destructor
    struct Sentinel
    {
        ~Sentinel()
        {
            if (nptrs > 0)
            {
                printf("Leaked memory at:
");
                for (size_t i = 0; i < nptrs; ++i)
                {
                    printf("	%p (file: %s, line %ld)
",
                            memMap[i].ptr, memMap[i].file, memMap[i].line);
                }
            }
            else
            {
                printf("No user memory leaks!
");
            }
        }
    };

    // Static dummy object
    Sentinel s;

} // End anonymous namespace

// Overload scalar new
void* operator new(size_t siz, const char* file,
                   long line)
{
    void* p = malloc(siz);
    if (activeFlag)
    {
        if (nptrs == MAXPTRS)
        {
            printf("memory map too small (increase MAXPTRS)
");
            exit(1);
        }
        memMap[nptrs].ptr = p;
        memMap[nptrs].file = file;
        memMap[nptrs].line = line;
        ++nptrs;
    }
    if (traceFlag)
    {
        printf("Allocated %u bytes at address %p ", siz, p);
        printf("(file: %s, line: %ld)
", file, line);
    }
    return p;
}

// Overload array new
void* operator new[](size_t siz, const char* file,
                     long line)
{
    return operator new(siz, file, line);
}

// Override scalar delete
void operator delete(void* p)
{
    if (findPtr(p) >= 0)
    {
        free(p);
        assert(nptrs > 0);
        delPtr(p);
        if (traceFlag)
        {
            printf("Deleted memory at address %p
", p);
        }
    }
    else if (!p && activeFlag)
    {
        printf("Attempt to delete unknown pointer: %p
", p);
    }
}

// Override array delete
void operator delete[](void* p)
{
    operator delete(p);
}

那哥们的测试工程，挺不错的，有3种情况：

#include "stdafx.h"
#include <iostream>
#include <vector>
#include <cstring>

#include "MemCheck.h"   // Must appear last!
using namespace std;

void Test()
{
    int *i = new int(0);
}

class MyClass
{
private:
    int *p;
public:
    MyClass()
    {
        if(p != NULL)
        {
            p = new int(0);
        }
    }
    ~MyClass()
    {
        if(p != NULL)
        {
            delete p;
            p = NULL;
        }
    }
};

void Test2()
{
    int *i = NULL;  // better for read
    i = new int(0);
    int *&y = i;    // pointer's reference
    delete i;

    MyClass *pMyClass = new MyClass();

    std::vector<MyClass*> myClasses;
    myClasses.push_back(new MyClass());
    myClasses.push_back(new MyClass());

    std::vector<void*> myVector;
    myVector.push_back(new MyClass());
    myVector.push_back(new MyClass());
    delete (MyClass *)(myVector.at(0));
    delete myVector.at(1); // memory leak
}

class Foo
{
    char* s;
public:
    Foo(const char*s )
    {
        this->s = new char[strlen(s) + 1];
        strcpy(this->s, s);
    }
    ~Foo()
    {
        delete [] s;
    }
};

void Test3()
{
    cout << "hello
";
    int* p = new int;
    delete p;
    int* q = new int[3];
    delete [] q;
    /**//*delete r;*/
    vector<int> v;
    v.push_back(1);
    Foo s("goodbye");
}

int main()
{
    TRACE_OFF();
    MEM_ON();
    Test();
    Test2();
    Test3();
    MEM_OFF();
}

在我编译的时候，会出现一下提示：

运行的时候出现：

对这个cpp的使用说明：

1、使用时在工程中加入在MemCheck.h，而且这个.h文件应该放在所以头文件的后边，因为里面有这么一句代码：#undef new

2、用MEM_ON()和MEM_OFF()来打开和关闭检测

3、TRACE_ON()和TRACE_OFF()用来打开或关闭检测结果的输出(上面的测试代码中使用没做检测结果的输出)

4、可以检测代码中使用了流、标准容器，以及某个类的构造函数分配了空间