🔥艾莉丝努力练剑：个人主页
❄专栏传送门：《C语言》、《数据结构与算法》、C/C++干货分享&学习过程记录、Linux操作系统编程详解、笔试/面试常见算法：从基础到进阶
⭐️为天地立心，为生民立命，为往圣继绝学，为万世开太平
🎬艾莉丝的简介：
C++的两个参考文档：
老朋友（非官方文档）：cplusplus
官方文档（同步更新）：cppreference
目录
2.1 malloc、calloc、realloc、free
四、详解operator new与operator delete函数
4.1 （核心重点）operator new与operator delete函数
一、内存分布问题详解
1.1 【做一做】例题（选择+填空）
void Test()
{
static int staticVar = 1;
int localVar = 1;
int num1[10] = { 1, 2, 3, 4 };
char char2[] = "abcd";
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) = ____；
正确答案：
1、选择题答案：
CCCAA
AAADAB
2、填空题答案：
40 5 4 4 4 4
1.1.1 示意图
1.1.2 答案解析
1、选择题：
选项：A. 栈 B. 堆 C. 数据段(静态区) D. 代码段(常量区)
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__
解析：
char2局部变量在栈区；
char2是一个数组，把后面常量串拷贝过来到数组中，数组在栈上，所以*char2在栈上；
pChar3局部变量在栈区；
*pChar3得到的是字符串常量字符在代码段；
ptr1局部变量在栈区；
*ptr1得到的是动态申请空间的数据在堆区。
2、填空题：
sizeof(num1) = __40__;
解析：数组大小,10个整形数据一共40字节。
sizeof(char2) = __5__;
解析：包括\0的空间。
strlen(char2) = __4__;
解析：不包括\0的长度。
sizeof(pChar3) = __4__;
解析：pChar3为指针。
strlen(pChar3) = __4__;
解析：字符串“abcd”的长度，不包括\0的长度。
sizeof(ptr1) = __4__;
解析：ptr1是指针。
1.2 示例代码展示
void main()
{
static int staticVar() = 1;
int localVar = 1;
int num1[10] = { 1,2,3,4 };
char char2[] = "abcd";
*char2 += 1;
//(*(char*)pChar3) += 1;
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);
const int i = 10;
int j = 1;
cout << &i << endl;
cout << &j << endl;
cout << (void*)pChar3 << endl;
}
int main()
{
//1、malloc/calloc/realloc的区别是什么？
int* p2 = (int*)calloc(4, sizeof(int));
int* p3 = (int*)realloc(p2, sizeof(int) * 50);
cout << p2 << endl;
cout << p3 << endl;
//这里需要free(p2)吗？
free(p3);
int* p5 = new int; //单个对象
int* p6 = new int[10]; //数组
int* p7 = new int(5); //单个对象
//不要误以为是5个空间，这里是初始化为5的意思
int* p8 = new int[10] {1, 2, 3, 10}; //数组
//这里把数组前4个分别初始化成1,2,3,10，后面6个没有给值，初始化成0
//delete替代了free
delete p5;
delete[] p6;
delete p7;
delete[] p8;
//以后工作中98%~99%不会再用malloc了
}1.3 内存分布
栈和堆两个内存区域的增长方向——
C/C++中的程序内存区域划分如下所示——
补充说明：
1、栈又叫堆栈-非静态局部变量/函数参数/返回值等等，栈是向下增长的。
2、内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信（如果Linux如果没学到这块，现在先了解一下）。
3、堆用于程序运行时动态内存分配，堆是可以上增长的。
4、数据段-存储全局数据和静态数据。
5、代码段-可执行的代码/只读常量。
1.4 虚拟地址空间
1.5 区域的定义
二、老友重逢：C语言内存管理方式
2.1 malloc、calloc、realloc、free
uu们如果忘记了可以去看看博主以前写得那篇【动态内存管理】的文章——
【动态内存管理】深入详解：malloc和free、calloc和realloc、常见的动态内存的错误、柔性数组、总结C/C++中程序内存区域划分
当时博主画了这张图——
2.2 例题
void Test()
{
// 1.malloc/calloc/realloc的区别是什么？
int* p2 = (int*)calloc(4, sizeof(int));
int* p3 = (int*)realloc(p2, sizeof(int) * 10);
// 2.这里需要free(p2)吗？
free(p3);
}【面试题】
1、malloc/calloc/realloc的区别？
malloc：动态开辟；
calloc：动态开辟，并且初始化为0；
realloc：扩容，分两种——
2、malloc的实现原理？【CTF】GLibc堆利用入门-机制介绍——glibc中malloc实现。
三、C++的内存管理方式：new / delete
C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因
此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。
这里插个题外话：等工作了，几乎不会再用malloc了，98%~99%的都用new了。
补充：new失败返回——抛异常；malloc失败返回——NULL。
3.1 new/delete操作内置类型
void Test()
{
// 动态申请一个int类型的空间
int* ptr4 = new int;
// 动态申请一个int类型的空间并初始化为10
int* ptr5 = new int(10);
// 动态申请10个int类型的空间
int* ptr6 = new int[3];
delete ptr4;
delete ptr5;
delete[] ptr6;
}
注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]，这里注意要匹配起来使用。
3.2 new和delete操作自定义类型
class A
{
public:
A(int a = 0)
: _a(a)
{
cout << "A():" << this << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a;
};
int main()
{
// new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间还会调用构造函数和析构函数
A* p1 = (A*)malloc(sizeof(A));
A* p2 = new A(1);
free(p1);
delete p2;
// 内置类型是几乎是一样的
int* p3 = (int*)malloc(sizeof(int)); // C
int* p4 = new int;
free(p3);
delete p4;
A* p5 = (A*)malloc(sizeof(A) * 10);
A* p6 = new A[10];
free(p5);
delete[] p6;
return 0;
}注意：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会。
四、详解operator new与operator delete函数
4.1 （核心重点）operator new与operator delete函数
4.1.1 概念
new 和 delete是用户进行动态内存申请和释放的操作符，operator new和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层是通过operator delete全局函数来释放空间的。
4.1.2 代码展示
/*
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来释放空间的（底层）。
五、探究new和delete的实现原理
5.1 内置类型
如果申请的是内置类型的空间，new 和 malloc，delete 和 free 基本类似。
不同的地方在于——
new / delete申请和释放的是单个元素的空间，new[ ] 和 delete[ ] 申请的是连续空间，而且new 在申请空间失败时会抛异常（C++特性），malloc会返回NULL。
5.2 自定义类型
5.2.1 new 和 delete的原理
5.2.1.1 new 的原理
1、调用operator new函数申请空间；
2、在申请的空间上执行构造函数，完成对象的构造。
5.2.1.2 delete 的原理
1、在空间上执行析构函数，完成对象中资源的清理工作；
2、调用operator delete函数释放对象的空间。
5.2.2 new T[N] 和 delete[ ]的原理
5.2.2.1 new T[N] 的原理
1、调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请；
2、在申请的空间上执行N次构造函数。
5.2.2.2 delete[ ]的原理
1、在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理；
2、调用operator delete[ ]来释放空间，实际上就是在operator delete[ ]中调用了operator delete来释放空间。
PS：严重怀疑就是设计者的强迫症（Bushi）。
5.3 扩展学习（编译器底层）
六、了解定位new表达式(placement-new)
定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。
使用格式：
new (place_address) type或者new (place_address) type(initializer-list)
place_address必须是一个指针，initializer-list是类型的初始化列表
使用场景：
定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。
class A
{
public:
A(int a = 0)
: _a(a)
{
cout << "A():" << this << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a;
};
// 定位new/replacement new
int main()
{
// p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
A* p1 = (A*)malloc(sizeof(A));
new(p1)A;
// 注意：如果A类的构造函数有参数时，此处需要传参
p1->~A();
free(p1);
A* p2 = (A*)operator new(sizeof(A));
new(p2)A(10);
p2->~A();
operator delete(p2);
return 0;
}
Windows操作系统崩溃——蓝层
软件闪退——软件的问题（不是手机的问题）
七、malloc/free和new/delete的区别
以后我们在面试里面经常会碰到这种问你“XX和XX的区别”的题目，既然这类题能够这么问，就说明被比较的两者是具有相似性的。比如问“引用和指针的区别”。
7.1 共同点
malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放。
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在释放空间前会调用析构函数完成空间中资源的清理释放。
八、内存池和池化技术
8.1 内存池
8.2 池化技术
本文的完整代码
Test.cpp：
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
//void main()
//{
// static int staticVar() = 1;
// int localVar = 1;
// int num1[10] = { 1,2,3,4 };
// char char2[] = "abcd";
//
// *char2 += 1;
// //(*(char*)pChar3) += 1;
//
// 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);
//
// const int i = 10;
// int j = 1;
// cout << &i << endl;
// cout << &j << endl;
// cout << (void*)pChar3 << endl;
//}
//
//int main()
//{
// //1、malloc/calloc/realloc的区别是什么？
// int* p2 = (int*)calloc(4, sizeof(int));
// int* p3 = (int*)realloc(p2, sizeof(int) * 50);
// cout << p2 << endl;
// cout << p3 << endl;
//
// //这里需要free(p2)吗？
// free(p3);
//
// int* p5 = new int; //单个对象
// int* p6 = new int[10]; //数组
//
// int* p7 = new int(5); //单个对象
// //不要误以为是5个空间，这里是初始化为5的意思
// int* p8 = new int[10] {1, 2, 3, 10}; //数组
// //这里把数组前4个分别初始化成1,2,3,10，后面6个没有给值，初始化成0
//
// //delete替代了free
// delete p5;
// delete[] p6;
// delete p7;
// delete[] p8;
// //以后工作中98%~99%不会再用malloc了
//}
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()
{
//只开空间，不调用构造初始化
A* p1 = (A*)malloc(sizeof(A));
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);
return 0;
}
int globalVar = 1;
static int staticGlobalVar = 1;
// 1、用法
// 2、初始化和析构的特性
// 3、错误的处理
//void Func()
//{
// int i = 0;
// int* ptr = nullptr;
// if (i == 495)
// {
// int x = 0;
// //加这个变量只是为了不成为空语句
// }
//
// ptr = new int[1024 * 1024];
// cout << i++ << ":" << ptr << endl;
//}
//
//int main()
//{
// Func();
//
// return 0;
//}
// 1、用法
// 2、初始化和析构的特性
// 3、错误的处理
//void Func()
//{
// int i = 1;
// int* ptr = nullptr;
// do {
// if (i == 495)
// {
// int x = 0;
// //加这个变量只是为了不成为空语句
// }
//
// ptr = new int[1024 * 1024];
// cout << i++ << ":" << ptr << endl;
// } while (ptr);
//
// cout << i++ << ":" << ptr << endl;
//}
//
//int main()
//{
// try
// {
// Func();
// }
// catch (const exception& e)
// {
// cout << e.what() << endl;
// }
//
// return 0;
//}
//class A
//{
//public:
// A(int a = 0)
// :_a(a)
// {
// cout << "A():" << this << endl;
// }
//
// ~A()
// {
// cout << "~A():" << this << endl;
// }
//private:
// int _a;
//};
//
//int main()
//{
// //A* p2 = (A*)operator new(sizeof(A));
// A* p1 = new A(1);
// delete p1;
//
// A* p2 = new A[10];
// delete[] p2;
//
// return 0;
//}
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A():" << this << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a;
};
int main()
{
A* p = new A(1);
A* ptr = (A*)operator new(sizeof(A));
//显示调用构造函数
new(ptr)A(1);
ptr->~A();
operator delete(ptr);
return 0;
}结尾
往期回顾：
【C++】类和对象（下）：初始化列表、类型转换、Static、友元、内部类、匿名对象/有名对象、优化
【C/C++】类和对象（中）：（二）类的默认成员函数——拷贝构造，赋值拷贝——赋值运算符重载
【C/C++】类和对象（中）：（一）类的默认成员函数——构造函数，析构函数
【C/C++】类和对象（上）：（二）实例化——类实例化出对象，对象大小，this指针，对比C++/C两种语言实现Stack
【C/C++】类和对象（上）：（一）类和结构体，命名规范——两大规范，新的作用域——类域
🗡博主在这里放了一只小狗，大家看完了摸摸小狗放松一下吧！🗡
૮₍ ˶ ˊ ᴥ ˋ˶₎ა
转载自CSDN-专业IT技术社区
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
原文链接：https://blog.csdn.net/2401_89899187/article/details/151686315
