【C++】内存管理

---

作者简介：一名在后端领域学习，并渴望能够学有所成的追梦人。
个人主页：不 良
系列专栏：C++  Linux
学习格言：博观而约取，厚积而薄发
欢迎进来的小伙伴，如果小伙伴们在学习的过程中，发现有需要纠正的地方，烦请指正，希望能够与诸君一同成长！

---

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";
    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) = ____ ； sizeof(pchar3) = ____ ； sizeof(ptr1) = ____； strlen(char2) = ____ ； strlen(pchar3) = ____ ；

3.sizeof和strlen区别？

答案：

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.堆

静态变量和全局变量都放在静态区，char2是数组名，数组名表示数组首元素的地址，char2数组是在栈上开辟的空间进行存储的，*char2是数组首元素，所以存在栈区；“abcd”确实是在常量区的，char2[] = “abcd”是将其拷贝到栈上；pchar3是局部变量，也存在于栈上，但是pchar3指向的空间是在常量区。

2.填空题：

sizeof(num1) = 40； sizeof(char2) = 5 ； sizeof(pchar3) = 4/8； sizeof(ptr1) = 4/8； strlen(char2) = 4； strlen(pchar3) = 4 ；

指针在32位机器下是4个字节，在64位机器下是8个字节。

3.sizeof和strlen区别？

• sizeof是关键字,strlen是函数
• sizeof的参数可以是数组,指针,类型,对象,函数等.strlen的参数只能是字符指针,且必须以’\0’结尾
• 数组名做sizeof的参数不退化,做strlen的参数会退化为指针
• 编译器在编译时就计算出了sizeof的结果，而strlen函数必须在运行时才能计算出来，并且sizeof计算的是数据类型占内存的大小，而strlen计算的是字符串实际的长度.

说明：

1. 栈又叫堆栈，用于存储非静态局部变量/函数参数/返回值等等，栈是向下增长的。
2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享内存，做进程间通信。
3. 堆用于存储运行时动态内存分配，堆是向上增长的。
4. 数据段又叫静态区，用于存储全局数据和静态数据。
5. 代码段又叫常量区，用于存放可执行的代码和只读常量。

扩展：为什么说栈是向下增长的，而堆是向上增长的？

在一般情况下，在栈区开辟空间，先开辟的空间地址较高；在堆区开辟空间，先开辟的空间地址较低。

注意：在堆区开辟空间，后开辟的空间地址不一定比先开辟的空间地址高。因为在堆区，后开辟的空间也有可能使用前面某一处被释放的空间。

C语言中动态内存管理方式

malloc函数

malloc函数的功能是开辟指定字节大小的内存空间，如果开辟成功就返回该空间的首地址，如果开辟失败就返回一个NULL。传参时只需传入需要开辟的字节个数。

int* p1 = (int*) malloc(sizeof(int));//开辟一个int类型大小的空间

calloc函数

calloc函数的功能也是开辟指定大小的内存空间，如果开辟成功就返回该空间的首地址，如果开辟失败就返回一个NULL。calloc函数传参时需要传入存放的元素个数和每个元素的大小。

calloc函数开辟好内存后会将空间内容中的每一个字节都初始化为0。

int* p2 = (int*)calloc(4, sizeof (int));//存放4个int类型的整数

realloc函数

realloc函数可以调整已经开辟好的动态内存的大小，第一个参数是需要调整大小的动态内存的首地址，第二个参数是动态内存调整后的新大小。realloc函数如果开辟成功则返回开辟好的内存的首地址，开辟失败则返回NULL。

int* p3 = (int*)realloc(p1, sizeof(int)*10);//将p1的空间扩大10倍

realloc函数会根据扩容的实际情况进行异地扩容或者原地扩容。

原地扩容：扩容的空间后面有足够的空间可供扩展，realloc函数直接在原空间后方进行扩展，并返回该内存空间首地址（即原来的首地址）。

异地扩容：扩容的空间后面没有足够的空间可供扩展，此时realloc函数会在堆区中重新找一块满足要求的内存空间，把原空间内的数据拷贝到新空间中，并主动将原空间内存释放（即还给操作系统），返回新内存空间的首地址。

扩充失败：需扩展的空间后方没有足够的空间可供扩展，并且堆区中也没有符合需要开辟的内存大小的空间。结果就是开辟内存失败，返回NULL。

free函数

free函数的作用就是将malloc、calloc以及realloc函数申请的动态内存空间释放。

int* p1 = (int*) malloc(sizeof(int));
int* p2 = (int*)calloc(4, sizeof (int));
int* p3 = (int*)realloc(p1, sizeof(int)*10);
free(p2);//释放申请的空间
free(p3);//释放申请的空间

malloc/realloc/calloc的区别？

• malloc -> 开空间
• calloc 等价于 malloc + memset(0) -> 开空间 + 初始化
• realloc 单独使用时能实现 malloc 的效果 (不会初始化) -> 开空间，也可以对 malloc/calloc 的空间扩容。

C++中动态内存管理方式

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

new和delete、new[]和delete[]都是操作符，而malloc/realloc/calloc/free都是函数。

new和delete操作内置类型

一、动态申请一个某种内置类型的空间

// 动态申请一个int类型的空间
int* ptr1 = new int;
//销毁
delete ptr1;

等价于：

// 动态申请一个int类型的空间
int* ptr1 = (int*)malloc(sizeof(int));
//销毁
free(ptr1);

二、动态申请一个某种类型的空间并初始化

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

等价于：

//动态申请个一个int类型的空间并初始化为10
int* ptr2 = (int*)malloc(sizeof(int));
*ptr2 = 10;
//销毁
free(ptr2);

三、动态申请多个某种类型的空间

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

等价于：

//动态申请10个int类型的空间
int* ptr3 =(int*)malloc(sizeof(int) * 10);
//销毁
free(ptr3);

四、动态申请多个某种类型的空间并初始化

//动态申请10个int类型的空间并初始化
int* ptr4 = new int[10]{1,2,3,4,5,6,7,8,9,10};
//销毁
delete[] ptr4;

等价于：

//动态申请10个int类型的空间并初始化
int* ptr4 = (int*)malloc(sizeof(int)*10);
for(int i = 0; i < 10; i++)
{
    *ptr4[i] = i + 1;
}
//销毁
free(ptr4);

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

new和delete操作自定义类型

对于下面的自定义类型：

class A {
public:
	A(int i = 0)
		:_a(i)
	{
		cout << "A()" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a = 1;
};

一、动态申请一个类的空间

//申请一个A类的空间
A* p1 = new A;
//销毁
delete p1;

等价于：

//申请一个A类的空间
A* p1 = (A*)malloc(sizeof(A));
//销毁
free(p1);

二、动态申请多个类的空间

//动态申请10个A类空间
A* p2 = new A[10];
//销毁
delete[] p2;

等价于：

//申请10个A类的空间
A* p2 = (A*)malloc(sizeof(A) * 10);
//销毁
free(p2);

new和delete操作符主要就是为了自定义类型使用的，对于自定义类型malloc只是开空间，free只是把空间释放；而在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc和free并不会去调用析构函数。

new/delete 和 malloc/free最大区别是 new/delete对于自定义类型除了开空间还会调用构造函数和析构函数，而对于内置类型两者几乎是一样的。

operator new与operator delete函数

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

operator new和operator delete的用法和malloc和free的用法完全一样，其功能都是在堆上申请和释放空间。

int* p1 = (int*)operator new(sizeof(int)* 10); //申请
operator delete(p1); //销毁

其作用等价于：

int* p2 = (int*)malloc(sizeof(int)* 10); //申请
free(p2); //销毁

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

operator new和operator delete本质是malloc和free的封装。那operator new和malloc有没有区别呢？malloc申请空间失败返回NULL，而operator new失败了抛异常。

new申请空间的时候，调用的是operator new，为什么要调用operator new而不是malloc呢？因为面向对象语言处理后基本都使用抛异常，而malloc申请空间失败返回空，不符合要求，所以使用operator new去封装malloc，申请失败抛异常。所以new申请空间还是使用的malloc，不过是封装了一下。

使用new申请空间时，先调用operator new申请空间再调用构造函数。

而使用delete释放空间时，先调用析构函数再释放空间。

使用new[N]申请空间时：调用operator new[N]，operator new[N]调用operator new，然后operator new再调用malloc函数，申请完空间之后再调用N次构造函数；

使用delete[N]释放空间时：先调用N次析构函数，再调用operator delete[N]，operator delete[N]调用operator delete，operator delete再调用free函数释放空间。

//申请空间
int* p = new int[10];
//operator new[] -> operator new -> 封装malloc
//调用10次构造函数
   
//销毁
delete[] p;  
//先调用10次析构函数
//再operator delete[] -> operator delete -> 封装free

new和delete实现原理

内置类型

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

自定义类型

new的原理

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

delete 的原理：

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

new T[N] 的原理：

• 调用 operator new[] 函数，在 operator new[] 中实际调用 operator new 函数完成 N 个对象空间的申请
• 在申请的空间上执行 N 次默认构造函数

delete [N] 的原理：

• 在释放的对象空间上执行 N 次析构函数，完成 N 个对象中资源清理的工作
• 调用 operator delete[] 释放空间，实际在 operator delete[] 中调用 operator delete 来释放空间

不是出作用域变量自动销毁吗？为什么还要手动释放内存？

出作用域销毁的是局部变量，局部变量是在栈上的；但是动态申请的空间是在堆上的，堆上的空间需要我们手动释放。

new/malloc系列，有底层实现机制，有关联交叉，如果不匹配使用，可能会出现问题，并且内存泄漏的时候并不会提醒，所以尽量要匹配使用。

下面的情况不匹配使用就会出现报错，只有使用delete[]才不会报错：

A* p = new A[10];
//free(p);//error
//delete p;//error
delete[] p;//true

和编译器的实现机制有关系，编译器会在头部多开4个字节，用来存放申请对象的个数，delete[]的时候用。

delete[]的时候地址向前挪动4个字节，取到申请对象的个数值，然后再调用对应次数的析构函数，但是并不是所有的编译器会这样做，VS是这样做的。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-k9vxWrc0-1687352580279)(null)]

但是当我们不显示定义析构函数的时候，编译可以正常通过。因为编译器自己评估之后，不调用析构函数也可以。此时不会再去多开4个字节，个数是为了知道自己要调用多少次析构函数。

定位new表达式(placement-new)

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

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

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

#include 
using namespace std;
class A
{
public:
	//构造函数
	A(int a, int b)
		: _a(a)
		,_b(b)
	{
		cout << "A():" << this << endl;
	}
	//析构函数
	~A()
	{
		cout << "~A():" << this << endl;
	}
private:
	int _a;
	int _b;
};
// 定位new/replacement new
int main()
{
	// p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
	A* p1 = (A*)malloc(sizeof(A));
	new(p1)A(1,2); // 注意：如果A类的构造函数有参数时，此处需要传参
	p1->~A();//调用析构函数
	free(p1);//释放空间

	// p2与p1相同，都是指针，并不是对象，指向的空间因为构造函数没有执行，所以不算是对象
	A* p2 = (A*)operator new(sizeof(A));
	new(p2)A(10,20);//调用构造函数
	p2->~A();
	operator delete(p2);
	return 0;
}

常见面试题

malloc/free和new/delete的区别

malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放。

不同的地方是：

• malloc和free是函数，new和delete是操作符
• malloc申请的空间不会初始化，new可以初始化
• malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可，如果是多个对象，[]中指定对象个数即可
• malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后面跟的是空间的类型
• malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常
• 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理。

内存泄漏

内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

//1.内存申请忘记释放
int* p1 = (int*)malloc(sizeof(int));
int* p2 = new int;

// 2.异常安全问题
int* p3 = new int[10];
Func(); //这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
delete[] p3;

内存泄漏分类：C/C++ 程序中一般我们关心两种方面的内存泄漏：

堆内存泄漏 (Heap leak)

堆内存指的是程序执行中依据须要分配通过 malloc / calloc / realloc / new 等从堆中分配的一块内存，用完后必须通过调用相应的 free 或者 delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生 Heap Leak。

系统资源泄漏

指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

如何避免内存泄漏：

• 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记住匹配的去释放。
• 采用RAII思想或者智能指针来管理资源。
• 有些公司内部规范使用内部实现的私有内存管理库，该库自带内存泄漏检测的功能选项。
• 出问题了使用内存泄漏工具检测。

扩展：

如何一次在堆上申请4G的内存？

在32位的平台下，内存大小为4G，但是堆只占了其中的2G左右，所以我们不可能在32位的平台下，一次性在堆上申请4G的内存。这时我们可以选择编译器上的x64，即64位平台（x86表示32位平台），这样我们便可以一次性在堆上申请4G的内存。

int main()
{
	//0xffffffff转换为十进制就是4G
	void* p = malloc(0xfffffffful);
	return 0;
}