【C++】C++的心脏：深入理解内存管理中的 new 和 delete

欢迎来到CILMY23的博客

🏆本篇主题为： C++的心脏：深入理解内存管理中的 new 和 delete

🏆个人主页：CILMY23-CSDN博客

🏆系列专栏：Python | C++ | C语言 | 数据结构与算法 | 贪心算法 | Linux

🏆感谢观看，支持的可以给个一键三连，点赞关注+收藏。

---

✨写在前头：

C/C++中的内存管理是非常重要的，正确的管理内存可以，优化性能，避免内存泄漏，防止野指针和内存损坏，提高资源管理效率，增强程序的可维护性和可扩展性，在过去我们写C语言的内存管理主要是malloc，realloc，free，calloc等等来管理我们的内存，这次我们将在复习C语言中内存管理的基础上，继续了解C++中的内存管理。

---

目录

C/C++的内存分布 

C语言中的内存管理

C语言中动态内存管理方式：malloc/calloc/realloc/free

C++中的内存管理 

3.1  new/delete的使用

3.2 operator new 和 operator delete

3.3 new 和 delete 的实现原理

3.3.1 内置类型

3.3.2 自定义类型

3.4 定位new 

---

C/C++的内存分布 

因为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. 选择题：
选项 : A.栈  B.堆  C.数据段(静态区)  D.代码段(常量区)    globalVar在哪里？____   staticGlobalVar在哪里？____    staticVar在哪里？____   localVar在哪里？____
num1 在哪里？____

char2在哪里？____ * char2在哪里？___    pChar3在哪里？____ * pChar3在哪里？____    ptr1在哪里？____ * ptr1在哪里？____
2. 填空题：
sizeof(num1) = ____; 
sizeof(char2) = ____;     
strlen(char2) = ____;   
sizeof(pChar3) = ____;    
strlen(pChar3) = ____;    
sizeof(ptr1) = ____;

 解答和解析我们放置文章末尾。

C语言中的内存管理

C语言中动态内存管理方式：malloc/calloc/realloc/free

这一部分可以回顾一下C语言中是如何写的，链接放在文章末尾了,在这里就不展开阐述了

C++中的内存管理 

在 C++ 中，new 和 delete 是用于动态内存分配和释放的操作符。不同于C 语言中的标准函数调用 malloc 和 free，new 和 delete 是操作符，它们还会调用类的构造函数和析构函数，

3.1  new/delete的使用

例如： 

int main()
{
    int* p1 = new int;       // 分配内存给一个整数
    int* p2 = new int[10];   // 分配内存给一个包含 10 个整数的数组

    delete p1;               // 释放 p1 指向的内存
    delete[] p2;             // 释放 p2 指向的整个数组的内存

    return 0;
}

代码解析：

1. int* p1 = new int; 创建一个整型数据的内存空间，并返回一个指向这个整型数据的指针，这个指针被存储在 p1 中。
2. int* p2 = new int[10]; 创建一个包含 10 个整型数据的动态数组，并返回一个指向数组首元素的指针，这个指针被存储在 p2 中。
3. delete p1; 语句释放指针变量 p1 所指向的单个整型数据的内存空间。
4. delete[] p2; 语句释放指针变量 p2 所指向的整个整型数组的内存空间。

注意：在使用 new 和 delete 时，必须确保每个 new 都有一个对应的 delete，一个用 new[] 分配的数组，必须用 delete[] 释放，这样可以正确地释放内存空间。

 代码2：

int main()
{
    int* p3 = new int(10);     // 分配内存并初始化为10
    int* p4 = new int[10]{1,2,3,4}; // 动态分配大小为10的整型数组，并用列表初始化前四个元素

    delete p3; // 释放p3指向的单个整数的内存
    delete[] p4; // 释放p4指向的整型数组的内存

    return 0;
}

代码解析：

1. int* p3 = new int(10);创建一个整型数据的内存空间，并返回一个指向这个整型数据的指针，这个指针被存储在 p3 中，并用 10 初始化。

2. int* p4 = new int[10]{1,2,3,4}; 创建一个包含 10 个整型数据的动态数组，并返回一个指向数组首元素的指针，这个指针被存储在 p4 中，数组中用花括号来初始化前四个整型数据，数组中未显式初始化的剩余元素将被自动初始化为0

3. delete p3;释放p3指向的内存空间。

4. delete[] p4;释放p4指向的整个数组的内存空间。

代码3：对自定义类型而言，new 会自动调用对应的构造函数，delete 会调用对应的析构函数，这里采用双向链表作为例子。

struct ListNode
{
	ListNode(int val)
		:_next(nullptr)
		,_prev(nullptr)
		,_val(val)
	{}


	ListNode* _next;
	ListNode* _prev;
	int _val;
};

struct ListNode* CreateListNode(int val)
{
	struct ListNode* newnode = (struct ListNode*)malloc(sizeof(struct ListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return 0;
	}
    
}

int main()
{
	ListNode* node1 = new ListNode(1);
	ListNode* node2 = new ListNode(2);
	ListNode* node3 = new ListNode(3);


	return 0;
}

C++中的 new 和 delete 对自定义类型会 开辟/释放空间+调用对应的构造函数/析构函数。

3.2 operator new 和 operator delete

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

new 为什么不去直接调用malloc？

实际上是因为直接调用 malloc 不适合，面向对象编程选择抛异常的情况来解决开辟空间失败的问题，malloc 失败后会返回0，于是 operator new 的意义也就有了，但是这个全局函数的底层仍然是用的 malloc 开辟空间。

operator new 和 operator delete本质

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

new的顺序是先分配空间后调用构造函数。

 delete 先调用析构函数还是先释放内存？

 答：一定是先调用析构函数然后再释放内存

3.3 new 和 delete 的实现原理

3.3.1 内置类型

如果申请的是内置类型的空间，new 和 malloc，delete 和 free 基本类似，

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

3.3.2 自定义类型

•  new的原理

1. 调用 operator new 函数申请空间
2. 在申请的空间上执行构造函数，完成对象的构造

• delete的原理

1. 在空间上执行析构函数，完成对象中资源的清理工作
2. 调用 operator delete 函数释放对象的空间

• new T[N]的原理

1. 调用 operator new[] 函数，在 operator new[] 中实际调用 operator new 函数完成N个对象空间的申请
2. 在申请的空间上执行N次构造函数
3. operator 在申请的空间会多存一个 个数 空间，方便 delete[] 调用对应次数的析构函数，但是如果用户没有写析构函数，编译器就不会多开这个空间。

• delete[]的原理

1. 通过读取delete的个数字节空间，从而知道析构函数的次数
2. 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
3. 调用 operator delete[] 释放空间，实际在 operator delete[] 中调用 operator delete 来释放空间  

3.4 定位new 

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

使用格式：
new (place_address) type 或者 new (place_address) type(initializer-list)
place_address 必须是一个指针，initializer-list是类型的初始化列表

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

 

---

💡总结

1️⃣const 修饰的并不代表它就在常量区，const 修饰的变量为常变量

2️⃣在使用 new 和 delete 时，必须确保每个 new 都有一个对应的 delete，new 对应 delete，new[] 对应 delete[]。

3️⃣C++中的 new 和 delete 对自定义类型会 开辟/释放空间+调用对应的构造函数和析构函数。

4️⃣new/delete 申请和释放的是单个元素的空间，new[] 和 delete[] 申请的是连续空间，而且 new 在申请空间失败时会抛异常，malloc会返回NULL。

5️⃣operator new 抛异常，实际是为了封装，然后实现 new，作为 new 开空间的存在。 

6️⃣operator new[] 会额外申请空间，但是对内置类型并不会单独开辟一个存次数的内存空间，对自定义类型还取决于析构函数的有无。

7️⃣operator new[] 是为了封装new，如果有需要就会额外申请空间用来存放次数。

C++管理方式的优点：

1.从用法上，C++的内存管理方式更简洁

2.C++的内存管理可以控制初始化了。

3.C++中的new和delete对自定义类型会 开辟/释放空间+调用对应的构造函数和析构函数。

4.new失败了以后会抛异常，不需要手动检查。

缺点：

1.没有原地扩容这个概念，扩容需要自己操作

---

C/C++内存分布练习题解析：

1.关于选择题 

• - `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)` 计算的是整个数组的大小。因为 `num1` 是一个包含10个 `int` 类型的数组，如果我们假设 `int` 类型占用4字节，那么 `sizeof(num1) = 4 * 10 = 40` 字节。
• `sizeof(char2)` 会包含字符串的全部内容加上一个结尾的空字符 `\0`。因为 `char2` 是 `"abcd"`，所以 `sizeof(char2) = 5` 字节（'a', 'b', 'c', 'd', 和 `\0`）。
• `strlen(char2)` 只计算字符串的长度，不包含结尾的空字符。所以 `strlen(char2) = 4`。
• `sizeof(pChar3)` 计算的是指针的大小，不是它指向的内容的大小。指针大小依赖于系统架构，例如在一个64位系统上，`sizeof(pChar3) = 8` 字节（这个值可能因系统不同而有所不同）。
• `strlen(pChar3)` 计算的是指针指向的字符串的长度，等于 `strlen("abcd") = 4`。
• `sizeof(ptr1)` 同 `sizeof(pChar3)`，计算的是指针的大小，与指向的内容大小无关。如果是在64位系统上，`sizeof(ptr1) = 8` 字节。

---

 C语言动态内存管理往期文章：

【C语言】内存操作篇---动态内存管理----malloc，realloc，calloc和free的用法【图文详解】_c语言 内存操作-CSDN博客 【C语言】动态内存管理------常见错误，以及经典笔试题分析，柔性数组【图文详解】_动态内存错误笔试题-CSDN博客

---

感谢各位同伴的支持，本期C++就讲解到这啦，如果你觉得写的不错的话，可以给个一键三连，点赞，关注+收藏，若有不足，欢迎各位在评论区讨论。