动态内存管理

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;								 //相当于malloc
	int* ptr2 = new int(1);								 //相当于calloc
	int* 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);