🔥个人主页：小张同学
🎬作者简介：C++研发方向学习者
📖个人专栏： 《C语言》《数据结构》《C++深度剖析：从入门到深耕》
⭐️人生格言：无视中断，不弃热枕，方得坚持之道。
前言：
如果你写过 C/C++ 项目，大概率遇到过这些 “崩溃瞬间”：调试时突然弹出的 “内存访问冲突” 弹窗、上线后监控面板里莫名飙升的内存占用、排查了 3 天才找到的 “隐藏式内存泄漏”…… 这些问题的根源，几乎都指向同一个核心 ——内存管理。
目录
四、operator new与operator delete函数（重点讲解）
六、定位new表达式（placement-new）（了解即可）
一、C/C++中的内存分布
我们从C语言开始就接触到了内存的相关问题，对内存都有一定的了解，那么我们先从一个内存分布的小题目入手：
1.1 内存分布的题目：
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);
}选择题：
选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
globalVar在哪里？____
staticGlobalVar在哪里？____
staticVar在哪里？____
localVar在哪里？____
num1 在哪里？____
char2在哪里？____
*char2在哪里？___
pChar3在哪里？____
*pChar3在哪里？____
ptr1在哪里？____
*ptr1在哪里？___
答案与解析：
globalVar在哪里？_C_
staticGlobalVar在哪里？_C_
staticVar在哪里？_C_
localVar在哪里？_A_
num1 在哪里？_A_
globalVar全局变量在静态区， staticGlobalVar静态全局变量在静态区，staticVar静态局部变量在静态区 ，localVar局部变量在栈区，num1局部变量在栈区
char2在哪里？_A_
*char2在哪里？_A_
pChar3在哪里？_A_
*pChar3在哪里？_D_
ptr1在哪里？_A_
*ptr1在哪里？_B_
char(等价于&char2[0]，第一个元素的地址)局部变量在栈区 ，char2是一个数组，把后面常量串拷贝过来到数组中(数组在栈上)*char2是数组的第一个元素的值，所以*char2在栈上；
pChar3局部变量在栈区 ，*pChar3得到的是字符串常量字符，在代码段；
ptr1局部变量在栈区 ，*ptr1得到的是动态申请空间的数据，在堆区；
大家可以看图结合着解析一块理解：
1.2 概念说明：
1. 栈又叫堆栈——非静态局部变量/函数参数/返回值等等，栈是向下增长的。
2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口
创建共享共享内存，做进程间通信。（Linux里面会学到这块，现在只需要了解一下）
3. 堆用于程序运行时动态内存分配，堆是可以上增长的。
4. 数据段--存储全局数据和静态数据。
5. 代码段--可执行的代码/只读常量。
二、C语言中的动态内存管理方式
2.1 malloc：
malloc函数的功能是开辟指定字节大小的内存空间，如果开辟成功就返回该空间的首地址，如果开辟失败就返回一个NULL。传参时只需传入需要开辟的字节个数。malloc不会初始化所开辟的内存空间！
2.2 calloc：
calloc函数的功能也是开辟指定大小的内存空间，如果开辟成功就返回该空间的首地址，如果开辟失败就返回一个NULL。calloc函数传参时需要传入开辟的内存用于存放的元素个数和每个元素的大小。calloc函数开辟好内存后会将空间内容中的每一个字节都初始化为0。
2.3 realloc：
realloc函数可以调整已经开辟好的动态内存的大小，第一个参数是需要调整大小的动态内存的首地址，第二个参数是动态内存调整后的新大小。 realloc函数与上面两个函数一样，如果开辟成功便返回开辟好的内存的首地址，开辟失败则返回NULL。
realloc函数调整动态内存大小的时候有三种扩展情况：
1、原地扩。需扩展的空间后方有足够的空间可供扩展，此时，realloc函数直接在原空间后方进行扩展，并返回该内存空间首地址(即原来的首地址)。
2、异地扩。需扩展的空间后方没有足够的空间可供扩展，此时，realloc函数会在堆区中重新找一块满足要求的内存空间，把原空间内的数据拷贝到新空间中，并主动将原空间内存释放(即还给操作系统)，返回新内存空间的首地址。
3、扩充失败。需扩展的空间后方没有足够的空间可供扩展，并且堆区中也没有符合需要开辟的内存大小的空间。结果就是开辟内存失败，返回一个NULL。
2.4 综合问题：
void Test ()
{
// 1.malloc/calloc/realloc的区别是什么？
int* p1 = (int*)malloc(4 * sizeof (int));
int* p2 = (int*)calloc(4, sizeof (int));
int* p3 = (int*)realloc(p2, sizeof(int)*10);
// 这里需要free(p2)吗？
free(p3 );
}这里是不需要free(p2)的。
因为我们在realloc时有两种情况，第一种是原地扩容：那么p2和p3的地址是一样的，释放一次就行了。第二种异地扩容：原来p2指向的内存块已经被realloc自动释放了，所以也是不需要考虑手动释放p2的。（详见上方realloc部分）
面试题：
1.malloc/calloc/realloc的区别？
malloc：分配指定字节内存，不初始化，数据随机。
calloc：分配内存并初始化为 0，需指定元素个数和单个元素字节数。
realloc：调整已分配内存大小，可扩容或缩容，可能复用原内存或重新分配并复制数据，有两种情况，原地扩容或者异地扩容，这个在上面也提到过。
2.malloc的实现原理？
基于brk（调整数据段地址）和 mmap（映射新内存区域）系统调用，结合内存池管理（按大小分类维护空闲块，分配时快速匹配，减少系统调用开销）
这个问题可以通过这个视频来深入了解：【CTF】GLibc堆利用入门-机制介绍_哔哩哔哩_bilibili
大家如果想更多的了解C语言内存管理的相关内容，可以到草莓熊大佬的CSDN博客中去了解：
三、C++的内存管理方式
C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因 此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。
3.1 new/delete操作内置类型：
#include<iostream>
using namespace std;
int main()
{
// 动态申请一个int类型的空间
int* p1 = new int; // 单个对象
// 动态申请10个int类型的空间
int* p2 = new int[10];// 数组
// 动态申请一个int类型的空间并初始化为10
int* p3 = new int(10); // 单个对象
// 前四个初始化1234，后面的默认初始化为0
int* p4 = new int[10] {1, 2, 3, 4}; // 数组
delete p1;
delete[] p2;
delete p3;
delete[] p4;
return 0;
}注意：
申请和释放单个元素的空间，使用new和delete操作符；
申请和释放连续的空间，使用 new[]和delete[]。
注意：匹配起来使用。
大家可能会觉得这些操作我们之前使用malloc和手动赋值初始化等操作也可以实现，虽然没这么方便，但也不是完全不行，那C++到底为什么要引入新的new/delete呢？我们接着往下看看自定义类型的操作。
3.2 new/delete操作自定义类型：
#include<iostream>
using namespace std;
class A
{
public:
A(int a = 0)
: _a(a)
{
cout << "A():" << this << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a;
};
struct ListNode
{
ListNode* _next;
int _val;
ListNode(int val)
:_next(nullptr)
, _val(val)
{
//...
}
};
int main()
{
// new/delete 和 malloc/free 最大区别是
// new/delete对于【自定义类型】除了开空间还会调用构造函数/析构函数
//mallc只能开空间，不调用构造初始化
A* p1 = (A*)malloc(sizeof(A));
//free也是，只能销毁，不能调用析构
free(p1);
A* p2 = new A;
A* p3 = new A(10);
delete p2;
delete p3;
ListNode* n1 = new ListNode(1);
ListNode* n2 = new ListNode(2);
ListNode* n3 = new ListNode(3);
//而malloc需要ListBuyNode，详见数据结构—单链表部分
// new/delete 和 malloc/free对内置类型是几乎是一样的
int* p4 = (int*)malloc(sizeof(int));
int* p5 = new int;
free(p4);
delete p5;
return 0;
}我们可以发现new/delete在处理自定义类型的时候会比malloc等操作好很多，会调对应的构造函数和析构函数。
注意：new/delete 和 malloc/free 最大区别是 new/delete对于【自定义类型】除了开空间还会调用构造函数/析构函数。
3.3 申请空间失败时的处理：
malloc在空间申请失败后会返回NULL，而new在申请空间失败时会抛异常。
#include<iostream>
using namespace std;
//这个程序退出码不为0，异常退出，跟malloc不一样，new申请失败会抛异常
void func()
{
int i = 1;
int* ptr = nullptr;
do {
if (i == 493)//为了方便调试，在
{
int x = 0;
}
ptr = new int[1024 * 1024];//throw
cout << i++ << ":" << ptr << '\n';
} while (ptr);
cout << i++ << ":" << ptr << '\n';
}
int main()
{
//捕获异常
try
{
func();//可以直接跳跃函数到异常
}
catch (const exception& e)
{
cout << e.what() << '\n';//打印错误信息
}
return 0;
}
这里利用了一个小技巧方便调试，用编译器那个条件断点停在第493次。
我们发现：到495次时出现异常，直接跳转到打印错误信息
四、operator new与operator delete函数（重点讲解）
new和delete是用户进行动态内存申请和释放的操作符，operator new 和 operator delete 是系统提供的全局函数， new 在底层调用 operator new 全局函数来申请空间， delete 在底层通过 operator delete 全局函数来释放空间。
下面大家来看看他们的底层代码：
4.1 operator new函数：
/*
operator new：
该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间
失败，尝试执行空间不足应对措施，如果改应对措施用户设置了，则继续申请，否
则抛异常。
*/
void* __CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
// try to allocate size bytes
void* p;
while ((p = malloc(size)) == 0)
if (_callnewh(size) == 0)
{
// report no memory
// 如果申请内存失败了，这里会抛出bad_alloc 类型异常
static const std::bad_alloc nomem;
_RAISE(nomem);
}
return (p);
}4.2 operator delete函数：
/*
operator delete:
该函数最终是通过free来释放空间的
*/
void operator delete(void* pUserData)
{
_CrtMemBlockHeader* pHead;
RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
if (pUserData == NULL)
return;
_mlock(_HEAP_LOCK); /* block other threads */
__TRY
/* get a pointer to memory block header */
pHead = pHdr(pUserData);
/* verify block type */
_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
_free_dbg(pUserData, pHead->nBlockUse);
__FINALLY
_munlock(_HEAP_LOCK); /* release other threads */
__END_TRY_FINALLY
return;
}4.3 free的实现：
free其实是一个宏函数，是_free_dbg(p, _NORMAL_BLOCK)的别名。
/*
free的实现
*/
#define free(p) _free_dbg(p, _NORMAL_BLOCK)通过上述两个全局函数的实现知道：
operator new 实际也是通过malloc来申请空间，如果 malloc 申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。
4.4 扩展知识补充：
#include<iostream>
using namespace std;
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A();" << this << '\n';
}
~A()
{
cout << "~A();" << this << '\n';
}
private:
int _a;
};
int main()
{
//A* p3 = (A*)operator new(sizeof(A));//可以显示调用
//可以看看反汇编
A* p1 = new A(1);
delete p1;
A* p2 = new A[10];//看反汇编为啥会是44或48，而不是40;
//（MSVC：通常添加4字节计数（32位）或8字节计数（64位））
//但是把析构注释掉就又是40了
delete[] p2;
return 0;
}我们先通过转到反汇编来看一下new和delete的底层反汇编：
从底层反汇编来看，new在使用时会先调用operator new，再调用构造函数；delete会先调用一个封装好的函数，这个函数再去先调用析构，再调用operator delete的。
下面我们来解决一下为什么在有构造函数的情况下p2底层申请的空间是48或44，而不是40：
这是因为在 C++ 中，当使用new[ ]动态分配对象数组时，如果类 A 有析构函数，编译器会在分配的内存块开头额外存储一个 “数组长度信息”，用于在delete[ ]时知道需要调用多少次析构函数。
具体分析：1、有析构函数的情况：
- 假设 sizeof(A) 是 4（比如 A 是简单的类，包含一个 int 成员等）。
- 当用new A[10] 时，编译器实际分配的内存不仅要存 10 个A对象（共 10×4=40 字节），还要额外存一个 “数组长度”（MSVC：通常添加4字节计数（32位）或8字节计数（64位），用来记录数组元素个数10）。
- 所以总分配内存是 40+4=44 或 40+8=48 字节，这就是反汇编看到44/48的原因。
- 后续delete[ ]时，会根据这个额外存储的长度信息，调用 10 次A的析构函数，再释放内存。
2、没有析构函数的情况：
- 如果把A的析构函数注释掉，编译器判断不需要额外记录 “数组长度”（因为这里的A类没啥需要释放的资源，不需要调用析构函数，也就不需要知道要调用多少次）。
- 此时分配的内存就是 10×4=40 字节，所以反汇编看到的是 40 。
简单来说，类是否有析构函数，会影响new[ ]时是否额外分配 “数组长度信息” 的空间，从而导致总分配内存大小不同。
值得一提是这也就是为啥我们前面提到new和delete要匹配使用，如果不匹配的话那这里释放的就有问题了，从中间那个位置开始释放掉了。但是我们知道空间的释放只可以从起始位置开始释放，不可以分段释放。
五、new和delete的底层实现原理
5.1 内置类型：
如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：
new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。
5.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表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。
6.1 使用格式：
new (place_address) type
或者
new (place_address) type(initializer-list)
place_address必须是一个指针，initializer-list是类型的初始化列表
6.2 使用场景：
定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。
#include<iostream>
using namespace std;
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A();" << this << '\n';
}
~A()
{
cout << "~A();" << this << '\n';
}
private:
int _a;
};
//定位new表达式的使用
int main()
{
// p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
A* p1 = (A*)operator new(sizeof(A));
//显示调用构造函数
new(p1)A(1);//1为初始化的值
//有参数就需要传，这里其实可以传也可以不传，看你实现的构造函数
//p1->A(1);
p1->~A();//析构可以直接这样用，构造不行;
operator delete(p1);
A* p2 = (A*)operator new(sizeof(A));
new(p2)A;
p2->~A();
operator delete(p2);
return 0;
}关于为什么可以p1->~A()，而不能p1->A()：
构造函数（Constructor）的特殊性
构造函数没有"地址"：构造函数不是普通的成员函数，它在编译时没有函数指针
构造函数不可被直接调用：因为调用构造函数意味着创建一个新对象，这需要特定的上下文（内存位置）
构造函数的调用是隐式的：由编译器在对象创建时自动安排
析构函数（Destructor）的特殊性
析构函数有地址：虽然不能直接取地址，但可以通过指针调用
析构函数清理已有对象：它操作的是一个已经存在的对象
析构函数的调用可以是显式的：在对象的生命周期结束时
下面给大家一个具体的应用场景，大家不需看懂代码，体会其中定位new的应用即可：
七、malloc/free与new/delete的对比
7.1 共同点：
- 都是从堆上申请空间，并且需要用户手动释放。
7.2 不同点：
- 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在释放空间前会调用析构函数完成空间中资源的清理释放
这些特点大家不用硬背，结合着用法、核心特性、原理来记忆就可以，其中第六点是最重要的。
本篇博客的完整原代码：
往期回顾：
C++ 类和对象（五）：初始化列表、static、友元、内部类等7大知识点全攻略-CSDN博客
C++ 类和对象（四）：const成员函数、取地址运算符重载全精讲-CSDN博客
C++ 类和对象（三）：拷贝构造函数与赋值运算符重载之核心实现-CSDN博客
C++ 类和对象（二）：实例化、this指针、构造函数、析构函数详解-CSDN博客
结语：
C++ 内存管理重要在实践出真知，从内存分布到new/delete底层，每一个知识点都需要在代码里体会摸透，希望这篇博客能帮你扫清疑惑。欢迎大家在评论区里讨论！如果文章对你有帮助的话，欢迎评论，点赞，收藏加关注，感谢大家的支持。
转载自CSDN-专业IT技术社区
原文链接：https://blog.csdn.net/zhangzhangip/article/details/157509784
