【 C++ 】C/C++内存管理

目录

一、C/C++内存分布

二、C++内存管理方式

1.new/delete操作内置类型

2.new和delete操作自定义类型

 四、operator new与operator delete函数

 五、new和delete的实现原理

1.内置类型

2.自定义类型

 六、定位new表达式(placement-new)

---

一、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);
}

来看如下问题：

1. 选择题：
选项: A.栈 B.堆 C.数据段 D.代码段
globalVar在哪里？__C__ staticGlobalVar在哪里？__C__
staticVar在哪里？__C__ localVar在哪里？__A__
num1 在哪里？__A__
char2在哪里？__A__ *char2在哪里？__A__
pChar3在哪里？__A__ *pChar3在哪里？__D__
ptr1在哪里？__A__ *ptr1在哪里？__B__
 
2. 填空题：
sizeof(num1) = __40__;
sizeof(char2) = __5__; strlen(char2) = __4__;
sizeof(pChar3) = __4/8__; strlen(pChar3) = __4__;
sizeof(ptr1) = __4/8__;

我们看如下解析图片：

  C/C++程序内存分配的几个区域：

• 栈又叫堆栈--非静态局部变量/函数参数/返回值等等，栈是向下增长的。
• 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口 创建共享共享内存，做进程间通信。（Linux课程如果没学到这块，现在只需要了解一下）
• 堆用于程序运行时动态内存分配，堆是可以上增长的。
• 数据段：存储全局数据和静态数据。
• 代码段：可执行的代码/只读常量。

二、C++内存管理方式

C语言内存管理方式中的malloc，calloc，realloc在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式： 通过new和delete操作符进行动态内存管理。

1.new/delete操作内置类型

new和delete最基本的使用方式

int main()
{
	// 动态申请一个int类型的的空间
	int* ptr1 = new int;

	// 动态申请一个int类型的的空间，并且初始化为10
	int* ptr2 = new int(10);

	// 动态申请10个int类型的空间
	int* ptr3 = new int[10];

    // 动态申请10个int类型的空间并且初始化，有几个就初始化几个，其余都为零，但是在C++11才支持
	int* ptr4 = new int[10]{ 1,2,3,4,5 };

	delete ptr1;
	delete ptr2;
	delete[] ptr3;
    delete[] ptr4;

	return 0;
}

调试结果如下：

•  注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用 new[]和delete[]，注意：匹配起来使用。

2.new和delete操作自定义类型

首先给出结论：

• 申请空间时：malloc只开空间，new既开空间又调用构造函数初始化。
• 释放空间时：free只释放空间，delete既释放空间又会调用析构函数。

先看一下malloc和free：

 由图片可以看出，malloc只对开辟了空间，没有调用构造函数来实现初始化。

再看一下new和delete：

运行程序之后会得到如下结果：

 由此可见，new开辟了空间，同时也调用了构造函数从而实现初始化；delete调用了析构函数从而释放空间。

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

malloc和new在开辟空间时还有一个点是不同的，当malloc开辟失败时会返回一个空指针，因此我们在平日用malloc开辟时要对指针判空；new在开辟失败时则会抛异常，可以对异常进行捕获。

 四、operator new与operator delete函数

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

• 注意：这里的operator new和operator delete并不是对new和delete的重载，而是两个库函数。

operator new 实际是通过malloc来申请空间 ，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。 operator delete 最终是通过free来释放空间的 。 operator new实现了对malloc的封装，而operator delete实现了对free的封装 。

通过如下代码来对比operator new、operator delete和malloc、free的区别：

int main()
{
	Stack* ps2 = (Stack*)operator new(sizeof(Stack));
	operator delete(ps2);

	Stack* ps1 = (Stack*)malloc(sizeof(Stack));
	assert(ps1);
	free(ps1);
}

new和delete的流程图：

 五、new和delete的实现原理

1.内置类型

如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。

2.自定义类型

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来释放空间

 六、定位new表达式(placement-new)

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

使用格式：

new (place_address) type或者new (place_address) type(initializer-list)

• 注意：place_address必须是一个指针，initializer-list是类型的初始化列表

使用场景：

定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化

class Test
{
public:
	Test(int date = 2)
		: _data(date)
	{
		cout << "Test():" << this << endl;
	}
	~Test()
	{
		cout << "~Test():" << this << endl;
	}
private:
	int _data;
};
int main()
{
	// pt现在指向的只不过是与Test对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	Test* pt1 = (Test*)malloc(sizeof(Test));
    //new (place_address) type
	new(pt1)Test; // 注意：如果Test类的构造函数有参数时，此处需要传参
 
    //new(place_address) type(initializer - list)
	Test* pt2 = (Test*)malloc(sizeof(Test));
	new(pt2)Test(10);
}