C++ 重载 new 和 delete

经过重载 new 和 delete, 从而控制内存分配的过程.
执行 new 的过程: 
编译器调用名为operator new(或operator new[])的标准库函数, 非配一块足够大, 原始, 未命名的内存空间.
编译器运行相应构造函数, 并未其传入初始值.
返回一个指向该对象的指针.
执行 delete 的过程: 
先执行相应的析构函数.
编译器调用名为operator delete(或operator delete[])的标准库函数释放内存空间.
编译器查找 new 和 delete 的顺序: 
若操做对象是类类型, 则编译器首先在类或基类的做用域中查找. 若类中含 operator new (或 operator delete) 成员, 则调用这些成员.
编译器在全局做用域中查找匹配的函数, 如有自定义版本, 则使用.
若没找到, 则使用标准库定义的版本.
可使用::(做用域运算符)忽略定义在类中的 new 或 delete 函数. eg: ::new只在全局做用域中查找.
new 和 new[]. 使用如下示例说明: 
new int 编译器解释为 new(sizeof(int)).
new int[10] 编译器解释为 new(sizeof(int) * 10).
new 和 operator new 函数的区别 (delete 和 operator delete 相似): 
new 除了调用 operator new 函数, 还要调用构造函数.
咱们日常说的重载 new, 其实只是重载 operator new 函数. 咱们没法阻止以后调用构造函数的行为(也不必阻止).
重载
咱们能够在类中, 或是在全局做用域中定义本身版本的 operator new 和 operator delete.
当在类中定义 operator new 和 operator delete 时, 他们是隐式静态 的(也就是说, 无需显式声明 static, 不过最好仍是声明吧, 保持统一性). 为何是静态的呢? 由于 operator new 用于对象构造前, operator delete 用于析构后. 并且既然是静态的, 也就没法操做类的非静态数据成员了.
operator new 和 operator delete
可定义其余类型的 operator new.
void *operator new(size_t, void*); 该形式只供标准库使用, 不容许被用户重载.
void *operator new(size_t size) {
    if (void *mem = malloc(size)) {
        return mem;
    } else {
        throw bad_alloc();
    }
}

void operator delete(void mem) noexcept {
    free(mem);
}
1
2
3
4
5
6
7
8
9
10
11
内存泄漏检测
资料
http://www.cnblogs.com/pangxiaodong/archive/2011/08/29/2158136.html
实现
MemInfoNode 用于记录申请的一块内存的信息. MemList 为一个单项链表, 存储每一个申请的内存块的数据.
#define new new(__FILE__, __LINE__) 的做用是, 能够在代码中直接方便的使用 new, 不改变原来代码中的语法. eg: new int将替换为new(__FILE__, __LINE__) int. 编译器最后将调用 operator new(sizeof(int), __FILE__, __LINE__)函数.
在 MemList 中要使用 malloc 和 free. 防止使用 new, delete 形成的递归死循环.
#include <iostream>
using namespace std;

class MemInfoNode {
private:
    void *pMem = NULL;    //memory address
    size_t memSize = 0;   
    const char *codeFile = NULL;
    unsigned int codeLine = 0;
    MemInfoNode *pNext = NULL;    //point to next node

    void Print(ostream &out = std::cout) {
        out << " FileName: " << codeFile
            << " LineNum: " << codeLine
            << " MemAddr: " << pMem
            << " MemSize: " << memSize
            << std::endl;
    }

    friend class MemList;
};

class MemList {
public:
    MemList() {}
    ~MemList() {
        MemInfoNode *nTmp = NULL;
        //释放泄露内存
        while (m_pHeadNode) {
            if (m_pHeadNode->pMem) { 
                free(m_pHeadNode->pMem); 
            }
            // move to next node
            nTmp = m_pHeadNode->pNext;
            free(m_pHeadNode);
            m_pHeadNode = nTmp->pNext;
        }
    }

    bool Prepend(void *pMem, size_t memSize, const char *fileName, unsigned int lineNo) {
        if (!pMem) {
            return false;
        }
        MemInfoNode *pNode = (MemInfoNode*)malloc(sizeof(MemInfoNode));
        pNode->pMem = pMem; pNode->memSize = memSize; pNode->codeFile = fileName; pNode->codeLine = lineNo;
        pNode->pNext = m_pHeadNode; m_pHeadNode = pNode;
        return true;
    }

    bool Remove(void *ptr) {
        if (!ptr) {
            return false;
        }

        MemInfoNode *n_pIt = m_pHeadNode;
        MemInfoNode *n_pPtr = NULL;
        while (n_pIt) {
            if (n_pIt->pMem == ptr) {    //findIt
                // 从 list 中 remove node
                if (!n_pPtr) {
                    m_pHeadNode = n_pIt->pNext;
                }
                else {
                    n_pPtr->pNext = n_pIt->pNext;
                }

                // free node
                free(n_pIt);
                return true;
            }
            n_pPtr = n_pIt;
            n_pIt = n_pIt->pNext;
        }
        return false;
    }

    friend ostream & operator << (ostream &out, MemList obj);

    void Result(ostream &out = std::cout) {
        if (!m_pHeadNode) {
            out << "[OK] This Application no memory leak!" << std::endl;
        }
        else {
            out << "[ERR] This Application have memory leak!" << std::endl;
            MemInfoNode *n_pIt = m_pHeadNode;
            while (n_pIt) {
                n_pIt->Print(out);
                n_pIt = n_pIt->pNext;
            }
        }
    }

private:
    MemInfoNode *m_pHeadNode = NULL;
};

ostream & operator << (ostream &out, MemList obj) {
    obj.Result(out);
    return out;
}

/*---------------  全局变量 ------------------*/
MemList mem_list; 

/*-------------- 重载 new new[] delete delete[] ---------------*/
void *operator new(size_t size, const char *fileName, unsigned int lineNo){
    void *pMem = malloc(size);
    if (pMem) {
        mem_list.Prepend(pMem, size, fileName, lineNo);
    }
    return pMem;
}
void *operator new[](size_t size, const char *fileName, unsigned int lineNo){
    return operator new(size, fileName, lineNo);    //Tips: 不能用 new, 而应该用 operator new
}

void operator delete(void *pMem) {
    if (pMem) {
        free(pMem);
        mem_list.Remove(pMem);
    }
}
void operator delete[](void *pMem) {
    operator delete(pMem);
}

/*------------------ 将 new 替换为重载的 new ----------------*/
#define new new(__FILE__, __LINE__)

void Test_bad_code() {
    int *p1 = new int;
    int *p2 = new int;
    int *p3 = new int[10];
    int *p4 = new int[20];

    delete p1;
    delete []p3;
}
void Test_good_code() {
    int *p1 = new int;
    int *p2 = new int;
    int *p3 = new int[10];
    int *p4 = new int[20];

    delete p1;
    delete p2;
    delete []p3;
    delete []p4;
}

int main()
{
    Test_good_code();
    Test_bad_code();

    //cout << mem_list;     mem_list.Result();