实现内存泄漏检测器
让我们来实现内存泄漏检测器。
由于我们已经重载了 new 操作符，很容易想到手动管理内存分配和自然释放内存。如果我们的 delete 没有释放所有分配的内存，就会发生内存泄漏。现在的问题是：我们应该使用什么结构来手动管理内存？
双向链表是一个不错的选择。在实际代码中，我们不知道何时需要分配内存，因此单向线性链表不够好，而动态结构（例如链表）会更加方便。此外，单向线性链表在删除内存泄漏检测器中的对象时也不方便。
因此，双向链表是目前的最佳选择：
#include <iostream>
#include <cstring>
// 定义 __NEW_OVERLOAD_IMPLEMENTATION__ 宏，
// 防止重载 `new` 操作符
#define __NEW_OVERLOAD_IMPLEMENTATION__
#include "LeakDetector.hpp"
typedef struct _MemoryList {
struct _MemoryList *next, *prev;
size_t size; // 分配内存的大小
bool isArray; // 是否为数组
char *file; // 泄漏文件的位置
unsigned int line; // 泄漏行号
} _MemoryList;
static unsigned long _memory_allocated = 0; // 保存未释放的内存大小
static _MemoryList _root = {
&_root, &_root, // 第一个元素的指针都指向自身
0, false, // 分配内存大小为 0，不是数组
NULL, 0 // 无文件信息，行号为 0
};
unsigned int _leak_detector::callCount = 0; 现在，让我们手动管理分配的内存：
// 从 _MemoryList 的头部开始分配内存
void* AllocateMemory(size_t _size, bool _array, char *_file, unsigned _line) {
// 计算新的大小
size_t newSize = sizeof(_MemoryList) + _size;
// 由于 new 已经被重载，我们只能使用 malloc 进行分配。
_MemoryList *newElem = (_MemoryList*)malloc(newSize);
newElem->next = _root.next;
newElem->prev = &_root;
newElem->size = _size;
newElem->isArray = _array;
newElem->file = NULL;
// 如果存在文件信息，则保存
if (_file) {
newElem->file = (char *)malloc(strlen(_file)+1);
strcpy(newElem->file, _file);
}
// 保存行号
newElem->line = _line;
// 更新链表
_root.next->prev = newElem;
_root.next = newElem;
// 保存到未释放的内存大小
_memory_allocated += _size;
// 返回分配的内存
return (char*)newElem + sizeof(_MemoryList);
} 以及重载 delete 操作符：
void DeleteMemory(void* _ptr, bool _array) {
// 回到 MemoryList 的起始位置
_MemoryList *currentElem = (_MemoryList *)((char *)_ptr - sizeof(_MemoryList));
if (currentElem->isArray != _array) return;
// 更新链表
currentElem->prev->next = currentElem->next;
currentElem->next->prev = currentElem->prev;
_memory_allocated -= currentElem->size;
// 释放文件信息的内存
if (currentElem->file) free(currentElem->file);
free(currentElem);
} 考虑到我们有两种不同的方式使用 new 和 delete：
void* operator new(size_t _size) {
return AllocateMemory(_size, false, NULL, 0);
}
void* operator new[](size_t _size) {
return AllocateMemory(_size, true, NULL, 0);
}
void* operator new(size_t _size, char *_file, unsigned int _line) {
return AllocateMemory(_size, false, _file, _line);
}
void* operator new[](size_t _size, char *_file, unsigned int _line) {
return AllocateMemory(_size, true, _file, _line);
}
// 重载 operator delete
void operator delete(void *_ptr) noexcept {
DeleteMemory(_ptr, false);
}
void operator delete[](void *_ptr) noexcept {
DeleteMemory(_ptr, true);
} 最后，我们需要实现 _leak_detector::LeakDetector，它将在 static _leak_detector _exit_counter 的析构函数中被调用。然后所有分配的对象将被释放。如果 static _MemoryList _root 不为空，则会出现内存泄漏，我们只需要遍历 _root 来找到内存泄漏的位置：
unsigned int _leak_detector::LeakDetector(void) noexcept {
unsigned int count = 0;
// 遍历整个链表，如果存在内存泄漏，
// 则 _LeakRoot.next 不会指向自身
_MemoryList *ptr = _root.next;
while (ptr && ptr != &_root)
{
// 输出所有泄漏信息
if(ptr->isArray)
std::cout << "Leaking[] ";
else
std::cout << "Leaking ";
std::cout << ptr << ", size of " << ptr->size;
if (ptr->file)
std::cout << " (located in " << ptr->file << ", line " << ptr->line << ")";
else
std::cout << " (no file info)";
std::cout << std::endl;
++count;
ptr = ptr->next;
}
if (count)
std::cout << "Existing " << count << " memory leaking behavior, "<< _memory_allocated << " byte in total." << std::endl;
return count;
} 让我们编译所有内容：
g++ main.cpp LeakDetector.cpp -std=c++11 -Wno-write-strings 在 main.cpp 中，取消注释 include "LeakDetector.hpp"。以下是预期输出：
