最近在思考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;
}
运行结果：
- 小结 ， 我的理解是 ：
运算符 new = 先调用函数 operator new 分配空间 + 然后调用构造函数。
对于operator new 函数内部，他是通过再调用malloc函数，进行空间分配的（当然也可以重写一个自己的空间分配器）。
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的对象的个数是多少。
