C/C++动态内存管理

c语言中用malloc/calloc/realloc/free进行动态内存管理，malloc/calloc/realloc用来在堆上开辟空间，free将申请的空间释放掉。
当一个程序需要内存的时候，它就调用malloc函数，malloc函数从内存池中提取一块何时内存，并向改程序返回一个指向这块内存的指针（此时这块内存没有被初始化！）。
函数原型： void * malloc（size_t size）;
malloc函数的参数是需要分配的内存字节数。如果从内存池中提取内存成功，他返回一个指向被分配的内存块起始位置的指针；如果失败，则返回一个空指针。
此外还有两个分配函数：calloc和realloc
函数原型：void *calloc（size _ t n , size _ t size）。(开辟n个长度为size的连续空间)他再返回指向内存的指针之前把它初始化为0；
void * realloc(void *ptr,size_t new_size);

void Test()
{
// malloc
int * p1 = ( int*) malloc(5 * sizeof( int));
if ( p1 != NULL)
{
free( p1);
p1 = NULL;
}
// calloc 该函数会将申请的内存空间初始化为0
int * p2= ( int*) calloc(5, sizeof( int));
if ( p2 != NULL)
{
free( p2);
p2 = NULL;
}
// relloc，改变原有内存空间大小，若不能改变，则将会开辟一段新的内存，将原有内存的内容拷贝过去，但不会对新开辟的空间进行初始化
int * p3 = ( int*) malloc(10 * sizeof( int));
realloc( p3, 100*sizeof( int));

c++进行动态内存管理
new/delete 是c++的一个关键字，同时也是操作符。
new进行内存管理：

new的过程：
当我们使用关键字new在堆上动态创建一个对象时，它实际上做了三件事：获得一块内存空间，调用构造函数，返回正确的指针。：如果我们创建的是简单类型的变量，那么第二步会被省略。

例如创建一个简单的类：

class A
{
  int i;
  public:
     A(int _i)
     :i(_i*_i)
      {}
    void Say()
    {
       printf("i = %d\n")
    }
};

//调用new：
A * pa = new A(3);那么上述动态创建一个对象的过程大致相当于以下三句话（只是大致上）：
A * pa = (A *)malloc(sizeof(A));
pa->A::A(3);
return pa;
从效果上看，这三句话也得到了一个有效的指向堆上的A对象的指pa，但区别在于，当malloc失败时，它不会调用分配内存失败处理程序new_handler，而使用new的话会的。
new的三种形态：
1，new operator —
2 ,operator new
3 ,placement new
new oprator就是我们平时用的new，它的第一步是调用operator new完成的，这new实际上就像加减乘除一样的操作符，所以它是可以重载的！operator new默认情况下首先调用分配内存的代码，尝试得到一段堆上的空间，如果成功就返回，如果失败，则转去调用一个new_hander，然后继续重复前面过程。placement new是用来实现定位构造的，因此可以实现new operator三步操作中的第二步，也就是在取得了一块可以容纳指定类型对象的内存后，在这块内存上构造一个对象。
new[]
调用operator new分配空间。
调用N次构造函数分别初始化每个对象。

delete[]
调用N次析构函数清理对象。
调用operator delete释放空间。
delete释放对象数组时：千万不能丢失”[]”
如果用new 创建对象数组，那么只能使用对象的无参数构造函数。例如
Obj *objects = new Obj[100]; // 创建100 个动态对象
Obj *objects = new Obj[100] (1); // 创建100 个动态对象的同时赋初值1
在用delete 释放对象数组时，留意不要丢了符号‘[]’。例如
delete []objects; // 正确的用法
delete objects; // 错误的用法
后者相当于delete objects[0]，漏掉了另外99 个对象。

实现NEW_ARRAY/DELETE_ARRAY宏，模拟new[]/delete[]申请和释放数组。
1.模拟实现new[]:

#define NEW_ARRAY(PTR, TYPE, N)                 \
    do                                              \
    {                                               \
        PTR = (TYPE*)operator new(sizeof(TYPE)*N + 4);  \
        (*(int*)PTR) = N;                           \
        PTR = (TYPE*)((char*)PTR + 4);              \
        for (size_t i = 0; i < N; ++i)              \
        new(PTR + i)TYPE;                       \
} while(false);

2.模拟实现delete[]:

#define DELETE_ARRAY(PTR, TYPE)         \
    do                                  \
    {                                   \
    size_t N = *((int*)PTR - 1);        \
    for (size_t i = 0; i < N; ++i)      \
        PTR[i].~TYPE();                    \
    PTR = (TYPE*)((char*)PTR - 4);      \
    operator delete(PTR);               \
    } while (false);