信心、毅力、勇气三者具备，则天下没有做不成的事。💓💓💓
目录
• 🌰1.operator new与operator delete函数
• 🌰3.malloc/free和new/delete的区别
✨说在前面
亲爱的读者们大家好！💖💖💖，我们又见面了，前面几篇文章中我带大家学习了C++中的第一大难关——类和对象。如果大家没有掌握好类和对象的知识，前面三篇文章讲解地很详细，可以再回去看看，复习一下，再进入今天的内容。
我们在C语言阶段学习了内存管理的相关知识，而C++中也有内存管理，今天我们将要学习C++中的内存管理。如果大家准备好了，那就接着往下看吧~
👇👇👇
💘💘💘知识连线时刻（直接点击即可）🎉🎉🎉复习回顾🎉🎉🎉
博主主页传送门：愿天垂怜的博客
🍋知识点一：C/C++内存分布
• 🌰1.C/C++中程序内存区域划分
我们电脑资源的管理主要关注CPU（图形处理器）、GPU（中央处理器）、内存（RAM）和磁盘这几个点。程序运行的本质是在CPU的控制下，处理存储在内存中的各种数据，并执行相应的指令。GPU虽然也参与计算，但其主要用途是加速图形处理。磁盘则用于长期存储数据和程序，并在需要时将它们加载到内存中。那这些数据到底怎么存储呢？
在C语言和C++中，内存可以划分成下列几个区域：
数据段和静态区的区别：
数据段是静态区（也称为全局区）的一个子集。
静态区（全局区）是一个更广泛的概念，它包含了程序中所有全局变量和静态变量的存储。这些变量在程序的整个生命周期内都存在，无论是已初始化还是未初始化。已初始化的全局变量和静态变量被存储在数据段中，而未初始化的全局变量和静态变量则通常被存储在另一个名为BSS段（Block Started by Symbol）的区域中。
我们先来看下面的一段代码以及相关的问题：
#include <iostream>
using namespace std;
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.代码段（常量区）
gloval在哪里？____C_____
staticGlobalVar在哪里？_____C______
staticVar在哪里？_____C______
localVar在哪里？_____A______
num1 在哪里？_____A______
char2在哪里？_____A______
*char2在哪里？_____A______
pChar3在哪里？_____A______
*pChar3在哪里？_____D______
ptr1在哪里？______A_____
*ptr1在哪里？_____B______
上面的选择大家需要非常熟悉，如果实在有问题可以看看下面这个图解：
globalVar、staticGlobalVar、staticVar很明显属于 全局或静态变量，所以应该存储在静态区。
localVar、num1、char2、pachar3、ptr1、ptr2、ptr3都是在函数定义的局部变量，所以存储在栈区，*char2是对数组名解引用，即为数组中第一个元素，用常字符串赋值数组，是将字符串数据拷贝至数组中，不是直接将常量放至数组中，所以*char2也存储在栈区。
*pchar3是对指针pchar3的解引用，而pchar3指向了 常字符串，所以*pchar3存储在常量区。
*ptr1、*ptr2、*ptr3都是动态开辟的空间，所以存储在堆区。
说明：
1.栈又叫堆栈——非静态局部变量/函数参数/返回值等等，栈是向下增长的。
2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。（Linux课程如果没学到这块，现在只需要了解一下）
3. 堆用于程序运行时动态内存分配，堆是可以上增长的。
4. 数据段--存储全局数据和静态数据。
5. 代码段--可执行的代码/只读常量。
• 🌰2.C语言内存管理方式
我们在C语言阶段讲过，忘了的可以看这篇文章：【C语言】动态内存分配
void Test()
{
// 1.malloc/calloc/realloc的区别是什么？
int* p2 = (int*)calloc(4, sizeof(int));
int* p3 = (int*)realloc(p2, sizeof(int) * 10);
// 这里需要free(p2)吗？
free(p3);
}【面试题】
1. malloc/calloc/realloc的区别？
2. malloc的实现原理？ glibc中malloc实现原理
• 🌰3.C++内存管理方式
C++，由于增添了许多特性，即使依旧可以延用C语言的动态管理，但是总有无法处理的地方 所以 C++ 又提供了两个新的动态管理的关键词 new 和 delete
示例1：new和delete的基本使用
#include <iostream>
using namespace std;
int main()
{
//申请一个int大小的空间
int* p1 = new int;
//申请一个10个int大小的空间
int* p2 = new int[10];
//申请对象并初始化为0
int* p3 = new int(0);
//多个对象初始化为0
int* p5 = new int[10] {1, 2, 3, 4, 5};
//释放空间
delete p1;
delete[] p2;
delete p3;
delete[] p5;
return 0;
}示例2：new自动调用构造，delete自动调用析构
#include <iostream>
using namespace std;
class A
{
public:
//构造函数
A(int a1, int a2 = 0)
:_a1(a1)
, _a2(a2)
{
cout << "A(int a1, int a2 = 0)" << endl;
}
//析构函数
~A()
{
cout << "~A()" << endl;
}
private:
int _a1 = 0;
int _a2 = 1;
};
struct ListNode
{
int val;
ListNode* next;
ListNode(int x)
:val(x)
, next(nullptr)
{}
};
int main()
{
//对于类类型，可以调用构造函数进行初始化
//A* p1 = new A;//无默认构造，error
A* p2 = new A(2, 2);
//无默认构造数组初始化的方式
//方式1
A aa1(1, 1);
A aa2(2, 2);
A aa3(3, 3);
A* p3 = new A[3]{ aa1,aa2,aa3 };
//方式2：匿名结构体
A* p4 = new A[3]{ A(1,1), A(2,2), A(3,3) };
//方式3：隐式类型转换
A* p5 = new A[3]{ {1,1},{2,2},{3,3} };
//delete可以调用析构函数释放资源
delete p2;
delete[] p3;
delete[] p4;
delete[] p5;
//创建连链表方便不少
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;
return 0;
}在C语言中，malloc或calloc等等申请的空间是否申请失败，可以利用判空来检测，那C++需要用到try/catch捕获异常：
#include <iostream>
using namespace std;
void function()
{
//throw try/catch
void* p1 = new char[1024 * 1024 * 1024];
cout << p1 << endl;
void* p2 = new char[1024 * 1024 * 1024];
cout << p2 << endl;
void* p3 = new char[1024 * 1024 * 1024];
cout << p3 << endl;
}
int main()
{
try
{
function();
}
catch (const exception& e)
{
cout << e.what() << endl;
}
return 0;
}示例3：在堆上能申请多少内存
#include <iostream>
using namespace std;
void function()
{
//throw try/catch
int n = 1;
while (1)
{
void* p1 = new char[1024 * 1024];
cout << p1 << "->" << n << endl;
n++;
}
}
int main()
{
try
{
function();
}
catch (const exception& e)
{
cout << e.what() << endl;
}
return 0;
}我们可以利用上面代码看出我们最多可以申请不到2G的内存（x86）：
🍋知识点二：new 与 delete
• 🌰1.operator new与operator delete函数
new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。
/*
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);
}
/*
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;
}
/*
free的实现
*/
#define free(p) _free_dbg(p, _NORMAL_BLOCK)通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。
• 🌰2.new 和 delete 的实现原理
🔥内置类型
如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。
🔥自定义类型
1.new的原理
1.调用operator new函数申请空间
2.在申请的空间上执行构造函数，完成对象的构造
2.delete的原理
1.在空间上执行析构函数，完成对象中资源的清理工作
2.调用operator delete函数释放对象的空间
3.new T[N]的原理
1.调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请
2.在申请的空间上执行N次构造函数
4.delete[]的原理
1. 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
2. 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间。
我们可以通过观察反汇编验证：
#include <iostream>
using namespace std;
int main()
{
A* p1 = new A(1);
delete p1;
return 0;
}new汇编代码：
delete汇编代码：
注意：使用new[] 分配，但是如果用delete删除，将不会再调用析构函数。
下面这个情况大家需谨慎：
#include <iostream>
using namespace std;
class A
{
public:
//构造函数
A(int a1 = 0, int a2 = 0)
:_a1(a1)
, _a2(a2)
{
cout << "A(int a1, int a2 = 0)" << endl;
}
//析构函数
~A()
{
cout << "~A()" << endl;
}
private:
int _a1 = 0;
int _a2 = 1;
};
class B
{
private:
int _b1 = 1;
int _b2 = 2;
};
struct ListNode
{
int val;
ListNode* next;
ListNode(int x)
:val(x)
, next(nullptr)
{}
};
int main()
{
B* p2 = new B[10];
delete p2;//ok
A* p3 = new A[10];
delete p3;//error
return 0;
}上面的p2和p3是用new[ ] 分配的，但是却用delete删除，也就是没有调用析构函数。但是，没有调用析构是不会影响程序正常运行的，而上面的程序运行时会报错，这是怎么回事呢？
其实，对于p2是没有问题的，问题是出在p3上。
我们可以计算一下A、B所实例化的对象大小。对于A和B来说，大小都为8个字节（两个int类型成员变量），所以p2和p3所指向的空间大小应该都为80个字节。我们转到反汇编：
p2指向空间的大小：
p3指向空间的大小：
我们发现，实际上，p2所指向的空间大小不是80个字节，而是84个字节，这4个字节是从哪里多出来的呢？
实际上，当A*类型的指针申请空间会多出4个字节用来存储对象的个数：
这是编译器的一种优化策略，当我们使用delete[ ]，由于不知道有几个对象，调用多少次析构，所以需要4个字节来存储对象的个数，此时p3会往前偏移4个字节取到个数；正常情况下B也是需要添加4个字节来存储对象个数的，但是由于B没有写析构函数，编译器在检查的过程中，就不调用析构函数，也不需要知道存个数了，所以直接delete也不会报错。
警示：new 和delete、new[] 和delete[]配对使用。
• 🌰3.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在释放空间前会调用析构函数完成空间中资源的清理释放
• 🌰4.定位new表达式(placement-new)
定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。
使用格式：new (place_address) type或者new (place_address) type(initializer-list)place_address必须是一个指针，initializer-list是类型的初始化列表
使用场景：
定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。
#include <iostream>
using namespace std;
int main()
{
//开空间，调用构造函数
A* p1 = new A(1);
//开空间，没有调用构造函数
A* p2 = (A*)operator new(sizeof(A));
//定位new调用构造函数
new(p2)A(1);
//先调用析构函数，再释放空间
delete p1;
//先调用析构函数，再释放空间
p2->~A();
operator delete(p2);
return 0;
} 
• ✨SumUp结语
到这里本篇文章的内容就结束了，本节讲解的是C++的内存管理。由于我们在C语言学习过C语言的内存管理，所以学习C++的相关知识难度不会有太大难度的上升。希望大家能够认真学习，打好基础，迎接接下来的挑战，期待大家继续捧场~
扫一扫
1601
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
