【C++】内存管理：内存分布、new/delete
本篇主要介绍一下C++的内存管理相关知识。C++的内存管理和C语言保持一致。
1.C/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);
} 
先说答案。
说几个比较容易混淆的，char2和pchar3
2.C语言中动态内存管理方式
C语言中内存管理的方式就是malloc/calloc/realloc/free。详细介绍在【C语言】动态内存管理：malloc、calloc、realloc、free-CSDN博客
3.C++内存管理方式
C语言内存管理方式在C++中可以继续用，但有些地方无能为力，而且用起来比较麻烦 ，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行内存管理。
3.1 new/delete操作内置类型
直接看下面这个代码。
void Test()
{
//管理对象
int* ptr4 = new int;
int* ptr5 = new int(3);
delete ptr4;
delete ptr5;
//管理对象数组
int* ptr6 = new int[3];
delete[] ptr6;
}
C++的new和delete简化了C语言中malloc/calloc/realloc的使用，不用强转，不用求类型大小。
不用了就直接delete，有[]的就用delete[]。
C语言那一套不支持初始化，new出来的对象可以直接初始化。
//数组初始化
int* ptr6 = new int[10] { 0 };
int* ptr7 = new int[10] {1, 2, 3, 4, 5};3.2 new/delete操作自定义类型
new和delete最主要的是为了让自定义类型用起来方便。拿下面这个A类举例。
class A
{
public:
A(int a = 0) //构造
:_i(a)
{
cout << "A(int a)" << endl;
}
A(const A& a) //拷贝构造
{
cout << "A(const A& a)" << endl;
}
~A() //析构
{
cout << "~A()" << endl;
}
private:
int _i = 1;
};new一个A类的对象，会直接自动调用它的构造函数，delete时，会直接调用析构函数。
A* p1 = new A;
A* p2 = new A(1);
delete p1;
delete p2;
如果我们想弄一个链表出来，也比在C语言里简单。
struct ListNode //链表的一个节点
{
int val;
ListNode* next;
ListNode(int x)
:val(x)
,next(nullptr)
{}
};ListNode* n1 = new ListNode(1); //直接对节点初始化好了
ListNode* n2 = new ListNode(1);
ListNode* n3 = new ListNode(1);
ListNode* n4 = new ListNode(1);
n1->next = n2;
n2->next = n3;
n3->next = n4;接下来再看看new申请单个对象两个参数的，假如现在有两个参数，如下
class A
{
public:
A(int a1 = 0, int a2 = 0) //构造
:_i(a1)
,_b(a2)
{
cout << "A(int a1 = 0, int a2 = 0)" << endl;
}
A(const A& a) //拷贝构造
{
cout << "A(const A& a)" << endl;
}
~A() //析构
{
cout << "~A()" << endl;
}
private:
int _i = 1;
int _b = 1;
};A* p1 = new A;
A* p2 = new A(2, 2);
A* p3 = new A[3]; //开数组
数组的话，多大就调用多少次 ，但是这是建立在有默认构造函数的基础上，如果没有默认构造函数，像下面这样。
A(int a1, int a2 = 0) //现在不是默认构造函数
:_i(a1)
,_b(a2)
{
cout << "A(int a1 = 0, int a2 = 0)" << endl;
}在没有默认构造函数的情况下，前面的p1和p3那种写法绝对不可以了。传一个参数和传两个都是可以的，像下面这样。
A* p1 = new A(1);
A* p2 = new A(2, 2);但是数组怎么初始化？
有下面几种方式。
第一种方法用有名对象。
A aa1(1, 1);
A aa2(2, 2);
A aa3(3, 3);
A* p3 = new A[3]{ aa1, aa2, aa3 };这里严格来说这里调用的就是拷贝构造了，而且这种方法很不方便。
第二种方法就是写匿名对象。
A* p4 = new A[3]{ A(1,1), A(2,2), A(3,3) };
这比有名对象简单一点，而且我们说过，匿名对象的构造加拷贝构造编译器会会优化为一个构造。
第三种写法如下。
A* p5 = new A[3]{ {1,1}, {2,2},{3,3} };这是什么个写法？记不记得之前我们说过，单参数构造函数支持隐式类型转换，多参数也支持，就是用{}括起来。这里其实走的是类型转换。
多说一句，花括号{}括起来是初始化，如果用圆括号（）括起来就是逗号表达式，如下
A* p5 = new A[3]{ (1,1), (2,2),(3,3) }; //逗号表达式
A* p5 = new A[3]{ {1,1}, {2,2},{3,3} }; //初始化逗号表达式的结果调试看一下就知道了。
4.operator new与operator delete函数
new和delete是用户进行动态申请和释放的操作符，operator new和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。
全局函数的实现在这里就不展示了，可以自己去搜一下源代码。operator new实际上也是通过malloc来申请空间的，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足措施，如果用户提供该措施，就继续申请，否则就抛异常。operator delete最终是通过free来释放空间的。
5.new和delete的实现原理
5.1 内置类型
如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方就是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请和释放的是连续的空间，而new在申请空间失败时会抛异常，malloc会返回NULL。
5.2 自定义类型
new的原理
1.调用operator new函数申请空间。
2.在申请的空间上执行构造函数，完成对象的构造（初始化）。
//比如这句代码，我们转到反汇编看一下底层
A* p1 = new A(1);
可以看到调用的是operator new这个函数，接着调用了构造函数去初始化。
delete的原理
1.在空间上执行析构函数，完成对象中资源的清理工作。
2.调用operator delete函数释放对象的空间。
delete p1;
new T[N]的原理
1.调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请。
2.在申请的空间上执行N此构造函数。
A* p2 = new A[3];
然后就是调用多次构造函数，在这就不细看了。
delete[]的原理
1.在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理。
2.调用operator delete[]释放空间，实际在operator new[]中调用operator delete来释放空间。
5.3 扩展学习
有析构函数的类，在new一个对象出来时，会在起始位置头部多开辟4个字节，来记录自己后面要开多少字节。没有析构函数的类，编译器会做优化，不在头部多开辟空间。
比如说下面这个B类，没有写析构函数，按照内存对齐规则，大小为8个字节。
class B
{
private:
int _b1 = 1;
int _b2 = 2;
};如果要new一个B类的数组出来，如下
B* pb = new B[10]; //数组元素个数为10在内存中空间开辟如图
如果是有析构函数的类，比如说我们前面提到的A类，按照内存对齐，A类大小也是8个字节，A类开空间时就会多开4个字节。
A* pa = new A[10];
但是pa指向的位置不是从最前面指，而是跳过额外开辟的位置，指向用户所需大小的位置。
但是不是所有编译器都是这样，底层是很复杂的。
如果我们在释放空间的时候，像下面这样，pa就会出错，pb不会
delete pb; //正确写法是delete[] pb
delete pa; //正确写法是delete[] pa 
所以要匹配使用，不要乱搞。
6.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在释放空间前会调用析构函数完成空间资源的清理释放。
本篇分享就到这里，拜拜~
