【C++】动态内存管理

C语言中使用malloc/calloc/realloc/free进行动态内存管理，malloc/calloc/realloc用来在堆上开辟空间，free将申请的空间释放掉。

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++中动态内存管理
C++中通过new和delete运算符进行动态内存管理。

void Test ()
{
int* p1 = new int; // 动态分配1个int（4个字节）的空间
int* p2 = new int(1); // 动态分配1个int（4个字节）的空间并初始化为1
int* p3 = new int[5]; // 动态分配5个int（20个字节）的空间
delete p1 ;
delete p2 ;
delete[] p3 ;
}

特别注意：new和delete、new[]和delete[]一定匹配使用

class A
{
public:
    A()
        :_a(0)
    {
        cout << "A()" << endl;
    }
    ~A()
    {
        cout << "~A()" << endl;
    }
private:
    int* _a;
};
void Test()
{
    A* p1 = (A*)malloc(sizeof (A));
    A* p2 = new A;
    A* p3 = new A(20);
    A* p4 = new A[10];
    free(p1);
    delete p2;
    delete p3;
    delete[] p4;
}

int main()
{
    Test();
    return 0;
}

当我们只为p1用malloc/free动态分配内存空间/释放空间时我们运行程序，会发现什么也没有输出：

而我们为p2用new/delete动态分配内存空间/释放空间时会发现它调用构造函数和析构函数：

【malloc/free和new/delete的区别和联系】
1. 它们都是动态管理内存的入口。
2. malloc/free是C/C++标准库的函数，new/delete是C++操作符。
3. malloc/free只是动态分配内存空间/释放空间。而new/delete除了分配空间还会调用构造函数和析构函数进行初始化与清理（清理成员）。
4. malloc/free需要手动计算类型大小且返回值会void*，new/delete可自己计算类型的大小，返回对应类型的指针。

剖析new/delete、new[]/delete[]到底做了些什么事情
new:
调用operator new分配空间。
调用构造函数初始化对象。

A* p2 = new A;

delete:
调用析构函数清理对象
调用operator delete释放空间

delete p2;

new[]
调用operator new分配空间。
调用N次构造函数分别初始化每个对象。

delete []
调用N次析构函数清理对象。
调用operator delete释放空间。

实现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);