C/C++内存管理

1. 内存分布

C/C++程序内存分部如下图

说明：

1. 栈又叫堆栈存放的是非静态局部变量/函数参数/返回值等等，栈是向下增长的。
2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享内存，做进程间通信。
3. 堆用于程序运行时动态内存分配，堆是可以向上增长的。
4. 数据段–存储全局数据和静态数据。（就是通常说的静态区）
5. 代码段–存储可执行的代码/只读常量。（就是通常说的常量区）

这里有一段代码和一点题目，大家可以试着写一下。

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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
globalVar在哪里？____ staticGlobalVar在哪里？____
staticVar在哪里？____ localVar在哪里？____
num1 在哪里？____
char2在哪里？____ *char2在哪里？___
pChar3在哪里？____ *pChar3在哪里？____
ptr1在哪里？____ *ptr1在哪里？____

globalVar是全局变量，存储在数据段。

staticGlobalVar 和 staticVar为静态变量，存储在数据段

localVar 为局部变量，存储在栈

num1和char是数组名，代表首元素的地址，存储在栈

数组的char2内容为abcd，char2为字符a，存储在栈
pChar3为指针变量，存储在栈，指针指向的内容为常量字符串abcd，而常量字符串存储在常量区，因此pChar3为常量区的字符a，存储在常量区

ptr1为指针变量，存储在栈，*ptr1指向一块malloc的空间，因此存储的数据在堆

char2和pChar3都是字符a，但是存储的位置不同，下面就做出解释和验证。

代码验证如下图

可以看到，这两个地址差很大，足以说明是两个区域。

2. new/delete

C语言中的动态内存管理是通过malloc/calloc/realloc/free这四个函数来实现的。C++没有延用这一套方式，而是提出自己的内存管理方式——new/delete，下面将从用法和原理来介绍它们。

2.1 用法

开一个空间
类型* 指针名

这样会和C语言中的malloc形成对比

#include
using namespace std;
int main()
{
	//开一个或多个int的空间，C的方式
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = (int*)malloc(sizeof(int)*10);
	if (p1 == nullptr||p2==nullptr)
	{
		return -1;
	}
	//开一个或多个int的空间，C++的方式
	int* p3 = new int;
	int* p4 = new int[10];
	//开空间同时初始化
    int* p5 = new int(5);
	int* p6 = new int[10]{1,2,3,4,5};
	//释放空间C
    free(p1);
    free(p2);
    //释放空间C++
    delete p3;
    delete[] p4;
    delete p5;
    delete[] p6;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

1. 相比malloc，new不需要强转类型，不需要计算类型的字节数目，只需要给出需要多少个这样的空间即可。
2. malloc失败会返回nullptr，需要进行检查，new不需要进行检查，new失败了会抛异常。
3. new空间时，可以进行初始化，malloc不会初始化。
4. malloc的空间，直接free即可，new的空间要分new一个空间和多个，释放一个空间用delete，释放多个空间用delete[ ]，用法如上

对于int* p6 = new int[10]{1,2,3,4,5}; [ ] 内的是开空间的个数，{ } 内是初始化的内容，按顺序依次初始化，不够的就初始化为0。

对于内置类型，C语言和C++的内存管理方式没有什么太大的差别，对于自定义类型就有不同。

#include
using namespace std;

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};

int main()
{
	A* p1 = (A*)malloc(sizeof(A));
	A* p2 = new A(1);
	free(p1);
	delete p2;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

运行结果如下

它自动调用了构造函数和析构函数。

结论：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会

同样申请多个空间和释放多个空间也会调用构造函数和析构函数。

申请多少个空间，就会调用多少次构造函数和析构函数。

对于用法上，建议不要混用，即malloc出来的空间就用free释放，new出来的空间就用delete释放。new[ ] 申请的空间就用delete[ ]释放。

2.2 原理

2.2.1 operator new 和 operator delete

new和delete是进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。

operator new内部是通过malloc来申请空间的，operator delete内部是通过free来释放空间的。

对于自定义类型，new和delete对空间申请和释放的原理如下

new的原理：
先调用operator new函数申请空间，再在申请的空间上执行构造函数，完成对象的创建
delete的原理
先在空间上执行析构函数，然后完成对象中资源的清理工作，通过调用operator delete函数释放对象的空间
new T[N]的原理（T代表类型，N代表个数）
调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请，再在申请的空间上执行N次构造函数
delete[]的原理
先在对象空间上执行N次析构函数，完成N个对象中资源的清理，然后调用operator delete[] 释放空间，实际在operator delete[]中调用operator delete来释放空间。

除了直接通过new和delete来申请和释放空间外，还可以直接用以上全局函数来管理空间。

#include
using namespace std;

class A
{
public:
	A(int a = 0)
		: _a(a)
	{
		cout << "A():" << this << endl;
	}
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
};

int main()
{
	//A* p1 = new A;等价于下面两行
	A* p1 = (A*)operator new(sizeof(A)); //和 malloc很相似
	new(p1)A(3);
	
	//delete p1;等价于下面两行
	p1->~A();
	operator delete(p1); //类似free

	//A* p2=new A[10];
	A* p2 = (A*)operator new(sizeof(A)*10);
	for (int i = 0; i < 10; i++)//10次构造函数
	{
		new(p2 + i)A(i * 2);
	}

	//delete [] p2
	for (int i = 0; i < 10; ++i)//10次析构函数
	{
		(p2 + i)->~A();
	}
	operator delete(p2);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

初始化已分配空间的对象需要显式调用构造函数，要用到一个新知识叫定位new

3. 定位new

定位new表达式是在已分配的内存空间中调用构造函数初始化一个对象。
用法

new (指针) type 或 new (指针) type(初始化列表) //type是类型名

定位new一般用于已经分配好了空间，但是需要我们显式调用构造函数进行初始化。

上面已经对定位new进行了应用，这里就不多讲了。

4. malloc/free和new/delete的区别

1. malloc和free是函数，new和delete是操作符
2. malloc申请的空间不会初始化，new可以初始化
3. malloc的返回值是void*，需要强转为需要的类型，new不用强转
4. malloc需要计算申请空间的字节数，new只需要跟类型，如要申请多个空间在类型后加 [ ] ，并且在 [ ] 内给个数即可
5. 申请空间失败时，malloc会返回nullptr，需要检查，new失败了会抛异常，我们需要捕获异常。
6. malloc和free仅仅是完成空间的申请和释放，不会调用构造函数和析构函数，new申请空间后会调用构造函数，完成初始化，delete释放空间前会调用析构函数，完成对象里的资源清理。

有关C/C++内存管理的部分，就介绍到这了。