new的三种形式

new operator

new操作符，用于动态分配内存并进行初始化，不能被重载，new operator首先会申请内存，然后调用构造函数进行初始化，这与C中的malloc是有区别的。malloc只负责申请内存，不会进行初始化操作。

operator new

标准库的函数，只分配内存而不进行初始化，可以重载。operator new与malloc的作用是一样的，只是负责内存的申请。

placement new

在指定的内存上构造对象。由于内存是指定的，所以该new不要delete，而是调用其析构函数析构即可。用的较少，即便使用，也会封装在特定类中使用。

关系

new operator会调用operator new进行内存的申请，而后自行调用构造函数进行初始化。

delete的二种形式

delete operator

delete operator与new operator对应，为关键字，不能被重载，会首先调用对象的析构函数进行析构，然后进行内存的释放。

operator delete

标准库的函数，只释放内存不会析构，可以重载。与free作用一样。delete operator会首先调用析构函数，然后调用operator delete进行内存释放。

内存泄漏

内存泄漏（Memory Leak）是指程序中己动态分配的堆内存由于某种原因程序未释放或无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。简单说也即new出的对象没有被delete掉，这对C++从业者非常常见，而重载new和delete对于检测这种问题非常有帮助。
思想：在new时，将指针地址和申请内存发生的文件及行号保存在map中，在delete中利用指针地址进行擦除，最后map中保留的信息即为没有被释放的信息。

#include <iostream>
#include <map>
#include <string>
#include <sstream>
using std::cout;
using std::endl;
using std::map;
using std::string;
using std::stringstream;


class MemoryLeakDetect{
public:
    static MemoryLeakDetect& instance(){
        static MemoryLeakDetect detect;
        return detect;
    }
    void insert(void* ptr, const char* file, int line){
        std::ostringstream ss;
        ss<<file<<line;
        record[reinterpret_cast<int>(ptr)] = ss.str();
    }
    void erase(void* ptr){
        record.erase(reinterpret_cast<int>(ptr));
    }
    void print(){
        for(auto pair : record){
            cout<<pair.second<<" memory leakage"<<endl;
        }
    }

private:
    MemoryLeakDetect(){
    }
    map<int, string> record;
};
void* operator new(std::size_t size, const char* file, int line) {
    cout<<"new"<<size<<endl;
    void* ptr = malloc(size);
    MemoryLeakDetect::instance().insert(ptr, file, line);
    return ptr;
}
void* operator new[](std::size_t size, const char* file, int line){
    cout<<"new[]"<<size<<endl;
    void* ptr = malloc(size);
    MemoryLeakDetect::instance().insert(ptr, file, line);
    return ptr;
}
void operator delete(void* ptr){
    free(ptr);
    MemoryLeakDetect::instance().erase(ptr);
    ptr = nullptr;
}
void operator delete[](void* ptr) {
    free(ptr);
    MemoryLeakDetect::instance().erase(ptr);
    ptr = nullptr;
}

#define new new(__FILE__, __LINE__)

class A{
public:
    A(){
        cout<<"construct"<<endl;
    }
    ~A(){
        cout<<"destruct"<<endl;
    }
};
int main(){
    int* p1 = new int;
    int* p2 = new int[4];
    A* a1 = new A;
    A* a2 = new A[1];
    delete p1;
    delete[] p2;
    delete a1;
    delete[] a2;
    //MemoryLeakDetect::instance().print();
}

CMakeLists.txt：

cmake_minimum_required (VERSION 2.8)
add_definitions(-std=c++11)
add_definitions(-fpermissive)
add_executable(demo main.cc)

WalkeR_ZG