C++ 里面的new，operator new ，placeme

最近在思考c++里面空间分配的机制，里面涉及到几个概念。什么是new，什么是malloc？什么是operator new？什么是placement new ？
对于初学者，可能不需要考虑这个问题，因为 只需要会写 int * p = new int[10] ; 就可以了。

但是，这个明白这个，对理解c++还是很有帮助哒~

对于如下的代码，如果看明白了，就基本上理解什么是new，什么是operator new ，什么是 placement new 了。

class Test
{
public:
    Test(int n) : n_(n)
    {
        cout << "构造函数 ： Test(int n) : n_(n)" << endl;
    }
    Test(const Test& other)
    {
        cout << "Test(const Test& other)" << endl;
    }
    ~Test()
    {
        cout << "~Test()" << endl;
    }
    void *operator new(size_t size)//普通情况调用，标注为0
    {
        cout << "mark 0 : void* operator new(size_t size)" << endl;
        void* p = malloc(size);
        return p;
    }
    void operator delete(void* p)
    {
        cout << "void operator delete(void* p)" << endl;
        free(p);
    }
    void operator delete(void* p, size_t size)//如果上面那个和这个delete都有，那么调用上面的。
    {
        cout << "void operator delete(void* p, size_t size)" << endl;
        free(p);
    }

    void* operator new(size_t size, void* p)//另一种情况调用，标注为2
    {
        cout << "mark 2 : run" << endl;
        return p;
    }

    int n_;
};

void* operator new[](size_t size) {
    cout << "operator new[] , 全局非test类调用这个" << endl;
    void * p = malloc(size);
    return p;
}

void * operator new(size_t size) {
    cout << "operator new , 全局非test类调用这个" << endl;
    void * p = malloc(size);
    return p;
}

void operator delete[](void * p) {
    cout << "operator delete[] , 全局非test类调用这个 " << endl;
    free(p);
}

void operator delete(void * p) {
    cout << "operator delete , 全局非test类调用这个 " << endl;
    free(p);
}

int main(void)
{
    //第一个知识点
    Test* p1 = new Test(100);    // new operator = operator new + 构造函数的调用 调用标注0
    delete p1;                  //delete = 析构函数的调用+operator delete

    //第二个知识点
    char* str = new char[100]; //调用标注3
    delete[] str;

    char * str2 = new char;
    delete str2;


    //第三个知识点
    char chunk[10];
    Test* p2 = new (chunk) Test(200);    //operator new(size_t, void *_Where)+构造函数的调用
                                         // placement new，不分配内存+ 构造函数的调用
                                         //调用标注2
    cout << p2->n_ << endl;
    p2->~Test();                        // 显式调用析构函数，因为没有分配内存，所以直接调用析构函数
    return 0;
}

运行结果：

• 小结 ， 我的理解是 ：

1. 运算符 new = 先调用函数 operator new 分配空间 + 然后调用构造函数。

2. 对于operator new 函数内部，他是通过再调用malloc函数，进行空间分配的（当然也可以重写一个自己的空间分配器）。

3. placement new 指的是，不进行分配空间，而是在指定的空间上面进行调用构造函数。当然，在析构的时候，也只能显示的调用析构函数。（因为并不是真正的释放空间）

这个有一个问题：

class Test
{
public:
    Test() : n_(0)
    {
        cout << "构造函数 ： Test() : n_(0)" << endl;
    }

    void operator delete[](void* p, size_t size)
    {
        cout << "void operator delete(void* p, size_t size)" << endl;
        cout<<size<<endl;     # 问题，这个size 的输出是多少？
        free(p);
    }
};

int main(void)
{
    cout<<"sizeof ptr : "<<sizeof(int *)<<endl;

    Test * p2 = new Test[10];
    delete [] p2;
}

# 程序delete[] 函数里面size的输出是多少？ 
# 答案是：44

但是，为什么是44？
一个对象的大小是4，10个对象的大小应该是40，这个4表示的是什么？

分配空间的伪代码是：

count =10;
size =sizeof(Test)
void * _p =malloc(Count*Size+4)
void * tp =(void *)(((char*)p)+4)
for I in 0..10:
    tp=(void*)(((char*)tp)+Size*I)
    ((Test*)tp)->Super();
*(int*)_p=Count
sp =(Test*)((int*)_p+1);

也就是说，分配出来的空间的前4个字节存放的是一个int，表达的是对象数组的长度。这样delete[]的时候，才知道要delete的对象的个数是多少。

参考 ： https://blog.csdn.net/jmh1996/article/details/77647976