【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在释放空间前会调用析构函数完成空间资源的清理释放。

本篇分享就到这里，拜拜~