从零开始学C++之重载 operator new 和 operator delete 实现一个简单内存泄漏跟踪器

本文主要是介绍从零开始学C++之重载 operator new 和 operator delete 实现一个简单内存泄漏跟踪器，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

先来说下实现思路：可以实现一个Trace类，调用 operator new 的时候就将指向分配内存的指针、当前文件、当前行等信息添加进Trace 成员map容器内，在调用operator delete 的时候删除这些信息。定义一个全局Trace 对象，当程序结束，对象析构时判断成员map 是否还有信息，如果有则打印出来，表示已经发生内存泄漏，从输出可以看出是哪一个文件哪一行分配了内存但没有释放掉。

DebugNew.h：

C++ Code  

1
2
3
4
5
6
7
8
9

#ifndef _DEBUG_NEW_H_
#define _DEBUG_NEW_H_

#ifndef NDEBUG
#include "Tracer.h"
#define new new(__FILE__, __LINE__)
#endif // NDEBUG

#endif // _DEBUG_NEW_H_

Trace.h：

C++ Code  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

#ifndef _TRACER_H_
#define _TRACER_H_

#include <map>

#ifndef NDEBUG

void * operator new(size_t size, const char *file, long line);
void operator delete( void *p);

void * operator new[](size_t size, const char *file, long line);
void operator delete[]( void *p);

class Tracer
{
private:
     class Entry
    {
     public:
        Entry( const char *file = 0, long line = 0)
            : file_(file), line_(line) {}
         const char *File() const
        {
             return file_;
        }
         long Line() const
        {
             return line_;
        }
     private:
         const char *file_;
         long line_;
    };
public:
    Tracer();
    ~Tracer();
     static bool Ready;

     void Add( void *p, const char *file, long line);
     void Remove( void *p);
     void Dump();

private:
    std::map< void *, Entry> mapEntry_;
};

#endif // NDEBUG

#endif // _TRACER_H_

Trace.cpp：

C++ Code  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

#include <iostream>
#include "Tracer.h"

#ifndef NDEBUG

bool Tracer::Ready = false;

Tracer::Tracer()
{
    Ready = true;
}

Tracer::~Tracer()
{
    Ready = false;
    Dump();
}

void Tracer::Add( void *p, const char *file, long line)
{
    mapEntry_[p] = Entry(file, line);
}

void Tracer::Remove( void *p)
{
    std::map< void *, Entry>::iterator it;
    it = mapEntry_.find(p);
     if (it != mapEntry_.end())
    {
        mapEntry_.erase(it);
    }
}

void Tracer::Dump()
{
     if (mapEntry_.size() > 0)
    {
        std::cout << "*** Memory leak(s):" << std::endl;
        std::map< void *, Entry>::iterator it;

         for (it = mapEntry_.begin(); it != mapEntry_.end(); ++it)
        {
             const char *file = it->second.File();
             long line = it->second.Line();
             int addr = reinterpret_cast< int>(it->first);
            std::cout << "0x" << std::hex << addr << ": "
                      << file << ", line " << std::dec << line << std::endl;

        }
        std::cout << std::endl;
    }
}

Tracer NewTrace;

void * operator new(size_t size, const char *file, long line)
{
     void *p = malloc(size);
     if (Tracer::Ready)
    {
        NewTrace.Add(p, file, line);
    }
     return p;
}

void operator delete( void *p)
{
     if (Tracer::Ready)
    {
        NewTrace.Remove(p);
    }
    free(p);
}

void * operator new[](size_t size, const char *file, long line)
{
     void *p = malloc(size);
     if (Tracer::Ready)
    {
        NewTrace.Add(p, file, line);
    }
     return p;
}

void operator delete[]( void *p)
{
     if (Tracer::Ready)
    {
        NewTrace.Remove(p);
    }
    free(p);
}
#endif // #ifndef NDEBUG

main.cpp：

C++ Code  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include <iostream>
using namespace std;

#include "DebugNew.h"

int main( void)
{
     int *p = new int;
     /*delete p;*/

     int *p2 = new int[ 5];
     /*delete[] p2;*/

     return 0;
}