这篇博客主要学习了C++内存管理方式：new/delete。
目录
C/C++内存分布
C语言动态内存管理方式
C++内存管理方式
new/delete操作内置类型
new/delete操作自定义类型
operator new与operator delete函数
new和delete的实现原理
内置类型
自定义类型
常见面试题
C/C++内存分布
我们先来看下面的一段代码和相关问题：
int globalVar = 1;static int staticGlobalVar = 1;void Test(){static int staticVar = 1;int localVar = 1;int num1[10] = { 1, 2, 3, 4 };char char2[] = "abcd";const char* pChar3 = "abcd";int* ptr1 = (int*)malloc(sizeof(int) * 4);int* ptr2 = (int*)calloc(4, sizeof(int));int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);free(ptr1);free(ptr3);}
上面容易犯错的是char、*char2、pChar3、*pChar3：
char2的意思就是在常量区有“abcd\0”这样一个字符串，用这样一个字符串初始化char2数组的意思就是在栈上开辟一个数组，把“abcd\0”这样一个字符串拷贝过去到栈上，因此，char2在栈上，*char2==a，也在栈上。
pChar3虽然被const修饰，但是这不代表在常量区，只是是常变量，被const修饰代表pChar3指向的内容在常量区，但是pChar3还是在栈上。
C语言动态内存管理方式
主要使用malloc、calloc、realloc、free管理。
C++内存管理方式
C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。
new/delete操作内置类型
void Test(){// 动态申请一个int类型的空间int* ptr4 = new int;// 动态申请一个int类型的空间并初始化为10int* ptr5 = new int(10);// 动态申请10个int类型的空间，并初始化int* ptr6 = new int[10]{1,2,3,4,5};delete ptr4;delete ptr5;delete[] ptr6;}
注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]，注意：匹配起来使用。
int main(){//1.用法上，变简洁了int* p1 = new int;int* p2 = new int[10];//2.可以控制初始化int* p3 = new int(10); //new一个int对象，初始化为10int* p4 = new int[10]{ 1,2,3,4,5 };//3、自定义类型，开空间+构造函数//4、new失败了以后抛异常，不需要手动检查ListNode* node1 = new ListNode(1);ListNode* node2 = new ListNode(2);ListNode* node3 = new ListNode(3);ListNode* p = CreateList(5);delete p1;delete[] p2;delete p3;delete[] p4;return 0;}基于以上4点，我们可以放弃C语言中的malloc等，C++这里的new和delete太好用了！
new/delete操作自定义类型
class A{public:A(int a=0){_a = a;cout << "A(int a=0)" << endl;}~A(){cout << "~A()" << endl;}private:int _a;};int main(){// new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间还会调用构造函数和析构函数A* p1 = (A*)malloc(sizeof(A));A* p2 = new A(1);free(p1);delete p2;// 内置类型是几乎是一样的int* p3 = (int*)malloc(sizeof(int)); // Cint* p4 = new int;free(p3);delete p4;A* p5 = (A*)malloc(sizeof(A) * 10);A* p6 = new A[10];free(p5);delete[] p6;//定义自定义类型的数组A* p7 = new A[5]{ 1,2,3,4,5 };delete p7;return 0;}new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间还会调用构造函数和析构函数。
operator new与operator delete函数
new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。
operator new是对malloc的封装-->失败抛异常，实现new。
operator delete是对free的封装。
operator new 实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。
下面再来看一个细节：
class Stack{public:Stack(){_a = (int*)malloc(4 * sizeof(int));_top = 0;_capacity = 4;}private:int* _a;int _top;int _capacity;};int main(){A* ptr1 = new A;//operator new + 1次构造A* ptr2 = new A[10];//operator new[] + 10次构造delete ptr1;//1次析构+operator deletedelete[] ptr2;//10次析构+operator delete[]return 0;}在delete[] ptr2这句代码中，并没有传递10次给delete[]，那么编译器怎么知道要析构10次呢？原因就是，在创建ptr2时，编译器本来应该为ptr2分配40个字节的空间（A[10]的大小），但实际上，编译器为ptr2分配了44个字节，这一点我们可以通过其汇编代码看到：
多了4个字节，其实4个字节放在了开辟空间的前面，用于存放开辟数组的大小，当delete[]时会根据这4个字节存放的的值去析构特定的次数。
但是，如果定义内置类型，由于内置类型不需要调用析构函数，因此，不会多开辟4个字节：
会不会多开4个字节，关键在于需不需要！
new和delete的实现原理
内置类型
如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：
new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申
请空间失败时会抛异常，malloc会返回NULL。
自定义类型
new的原理
1. 调用operator new函数申请空间
2. 在申请的空间上执行构造函数，完成对象的构造
delete的原理
1. 在空间上执行析构函数，完成对象中资源的清理工作
2. 调用operator delete函数释放对象的空间
new T[N]的原理
1. 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请
2. 在申请的空间上执行N次构造函数
delete[]的原理
1. 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
2. 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间
常见面试题
malloc/free和new/delete的区别
malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放。不同的地
方是：
1. malloc和free是函数，new和delete是操作符
2. malloc申请的空间不会初始化，new可以初始化
3. malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可，如果是多个对象，[]中指定对象个数即可
4. malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型
5. malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常
6. 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理