c++ 的new/delete

1. c++ 在全局定义了 operator new(size_t size), operator new(size_t size,void* buf)和operator delete(void* buf);

① void* operator new(size_t size);//内部调用malloc(size)

② void* operator new(size_t size, void* buf);//什么也不做，直接 return buf;

③ void operator delete(void* buf);//内部调用free(buf);

2. ClassA* ptr = new ClassA()对应于编译器操作步骤：

void * mem=operator new(sizeof(ClassA));

ClassA* ptr=(ClassA*)mem;

ptr->ClassA::ClassA();

3. new(_mem) ClassA() 对应于编译器操作步骤：(假设_mem已指向一段申请好的内存)

void* mem = operator new(sizeof(ClassA),_mem);

ClassA* ptr=(ClassA*)mem;

ptr->ClassA::ClassA();

// ps.. 由于operator new(sizeof(ClassA),_mem)什么也不做，所以三步就只等价于后两步。

4. delete classAPtr 对应于编译器如下步骤：

ClassA* ptr=(ClassA*)classAPtr;

ptr->~ClassA();

operator delete(classAPtr);

5. 在ClassA 内部重载operator new(size_t size) 和 operator new(size_t size,void* buf)会让2，3中对operator new的调用，变成对重载的operator new调用。

#include <iostream>
#include <new>

class ClassA {
public:
    ClassA() {}
    ClassA(int v) { a = v; }
    static void* operator new(size_t size) {
        std::cout << "internal allocate used." << std::endl;
        return malloc(size);
    }
    static void* operator new(size_t size, void* buf) {
        std::cout << "internal allocate used for placement new." << std::endl;
        if (buf != nullptr)
            return buf;
        else
            return operator new(size);
    }
    static void operator delete(void* buf) {
        std::cout << "internal deallocate used." << std::endl;
        free(buf);
    }

    static void* operator new[](size_t nsize) {
        void* mem = operator new(sizeof(size_t) + nsize);
        size_t* temp = (size_t*)mem;
        *temp = nsize/sizeof(ClassA);
        ClassA* ptr = (ClassA*)(temp + 1);
        for (size_t i = 0; i < *temp; i++) {
            //(ptr + i)->ClassA::ClassA();
            new(ptr + i)ClassA();
            std::cout << "constructor: " << i << std::endl;
        }
        return ptr;
    }

    static void operator delete[](void* buf) {
        size_t* temp = (size_t*)buf-1;
        ClassA* ptr = (ClassA*)(buf);
        for (size_t i = (*temp); i >0 ; i--) {
               (ptr + i -1)->~ClassA();
               std::cout << "destructor: " << i-1 << std::endl;
        }
        operator delete(temp);
    }
public:
    int a;
};

int main()
{
    ClassA* ptr = (ClassA*)::operator new(sizeof(ClassA));// 使用全局operator new(size_t size);
    ::new(ptr) ClassA(6);// 内部使用全局operator new(size_t size，void* buf);
    std::cout << ptr->a << "\n";
    ::delete ptr; //使用全局operator delete(void* buf);

    ClassA* cptr = (ClassA*)operator new(sizeof(ClassA));//使用ClassA内部重载的operator new(size_t size)
    new(cptr)ClassA(10);//使用ClassA内部重载的operator new(size_t size,void* buf)
    std::cout << cptr->a << "\n";
    delete cptr;//使用ClassA内部重载的operator delete(void* buf);

    ClassA* arr = new ClassA[5];
    delete[] arr;
    return 0;
}

6. 重载 void* operator new[](size_t nsize), void* operator new[](size_t n, void* buf)和void operator delete[](void* buf),会相应的影响对象数组的创建和释放：

ClassA* arrClassA = new ClassA[5];

------>等价于

void * mem=operator new(sizeof(size_t)+nsize);

size_t* temp = (size_t*)mem;

*temp = nsize/sizeof(ClassA);

ClassA* ptr=(ClassA*)(temp+1);

for(size_t i=0;i<5;i++) (ptr+i)->ClassA::ClassA();

arrClassA=(ClassA*)ptr;

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

delete[] arrClassA;

------>等价于

size_t* temp = (size_t*)arrClassA-1;

ClassA* ptr=(ClassA*)arrClassA;

for(size_t i=*temp;i>0;i--) (ptr+i-1)->~ClassA();

operator delete(temp);

7. 不要重载全局operator new(size_t size)，operator new(size_t size，void* buf)，以及operator delete(void* buf), 否则那些没有重载这些函数的类在实例化和回收的时候将受到影响。

8. 有了上面的重载，我们可以接管ClassA内存的申请和释放权限，自定义设计该类的allocator，并进行内存管理，实现内存池。