动态内存管理

c语言动态内存管理：

     开辟空间：malloc   calloc  realloc  

     释放空间：free（ptr）；

void test(){int* ptr1 = (int*)malloc(sizeof(int)); //开辟四个字节的空间int* ptr2 = (int*)calloc(4,sizeof(int)); //开辟四个字节的空间并且用4，进行初始化int* ptr3 = (int*)realloc(ptr2,sizeof(int)*5);         //在已开辟的空间后面在续加开辟5*4个字节free(ptr1);free(ptr3);}

c++动态内存管理：

      开辟空间：new      开辟指定大小的空间

                         new[ ]   开辟数组空间

      释放空间：delete   释放空间

                        delete[ ] 释放数组空间

malloc/free  new/delete  new[ ]/delete[ ]  一定要配套使用，否则很可能会出现内存泄漏的情况。

new/new[ ] 和 delete/delete[ ]  其实根本上还是调用了malloc和free来实现动态开辟和释放的功能。

void test2(){int* ptr1 = new int; //相当于mallocint* ptr2 = new int(1); //相当于callocint* ptr3 = new int [10]; //开辟1个数组，10个元素。delete ptr1;delete ptr2;delete[] ptr3;                                                                   //释放指针ptr3指向的数组空间}

总结：
1. operator new/operator delete operator new[]/operator delete[] 和 malloc/free用法一样。

2. 他们只负责分配空间/释放空间，不会调用对象构造函数/析构函数来初始化/清理对象。

3. 实际operator new和operator delete只是malloc和free的一层封装。
new做了两件事
1. 调用operator new分配空间。

 2. 调用构造函数初始化对象。
delete也做了两件事
1. 调用析构函数清理对象 2. 调用operator delete释放空间
new[N]
1. 调用operator new分配空间。 

2. 调用N次构造函数分别初始化每个对象。
delete[]
1. 调用N次析构函数清理对象。

 2. 调用operator delete释放空间。

new和delete的运行原理：

用宏模拟实现new[ ]和delete[ ]:

#define NEW_ARRAY(PTR,TYPE,N)\do        \{         \  PTR = (TYPE*)operator new(sizeof(TYPE)*N+4);/*开辟空间*/ \  (*(int*)TYPE) = N;                                      \  PTR = (TYPE*)((char*)PTR+4);                            \  for(size_t i = 0; i < N; i++)                           \      new(PTR+i)TYPE;            /*进行初始化*/             \}while(false);#define DELETE_ARRAY(PTR,TYPE)      \do                              \{       size_t N=0;                 \N = *((TYPE*)((char*)PTR-4));   \PTR = (TYPE*)PTR                \for(size_t i = 0; i < N; i++)   \   PTR[i].~TYPE();              \PTR = (TYPR*)((char*)PTR-4)     \operator delete(PTR)            \}while(false);