【C/C++内存管理详解】

最新推荐文章于 2024-05-21 10:33:53 发布

jokr_

最新推荐文章于 2024-05-21 10:33:53 发布

阅读量1k

点赞数 24

分类专栏： C++ 文章标签： c语言 c++ java

本文链接：https://blog.csdn.net/jokr_/article/details/136120913

版权

C++ 专栏收录该内容

18 篇文章 1 订阅

订阅专栏

C/C++内存管理详解

1. C/C++内存分布
2. C语言中动态内存管理方式
3. C++中动态内存管理
- - 3.1 new/delete操作内置类型
  - **3.2 new和delete操作自定义类型**
4. operator new与operator delete函数
- - 4.1 operator new与operator delete函数
5. new和delete的实现原理
- - 5.1 内置类型
  - 5.2 自定义类型
6. 定位new表达式(placement-new)
7. 常见面试题
如何一次在堆上申请4G的内存？

1. 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";
 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);
 }

你知道下面这些问题的答案吗？
在这里插入图片描述

我们首先来了解一下C/C++中程序内存区域划分
在这里插入图片描述

在这里插入图片描述

【说明】

栈又叫堆栈–非静态局部变量/函数参数/返回值等等，栈是向下增长的。
内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口
创建共享共享内存，做进程间通信。（Linux课程如果没学到这块，现在只需要了解一下）
堆用于程序运行时动态内存分配，堆是可以上增长的。
数据段–存储全局数据和静态数据。
代码段–可执行的代码/只读常量。

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

简单来说，在一般情况下，在栈区开辟空间，先开辟的空间地址较高，而在堆区开辟空间，先开辟的空间地址较低。

例如，下面代码中，变量a和变量b存储在栈区，指针c和指针d指向堆区的内存空间：

int main()
{
	//在栈上创建对象
	int a = 10;
	int b = 20;
	cout << "a:" << &a << endl;
	cout << "b:" << &b << endl;


	//在堆上开辟空间
	int* c = (int *)malloc(sizeof(int) * 10);
	int* d = (int *)malloc(sizeof(int) * 10);
	cout << "c[]:" << c << endl;
	cout << "d[]:" << d << endl;


	return 0;
}

在这里插入图片描述
因为在栈区开辟空间，先开辟的空间地址较高，所以打印出来a的地址大于b的地址；在堆区开辟空间，先开辟的空间地址较低，所以c指向的空间地址小于d指向的空间地址。

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

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

malloc/calloc/realloc/free

malloc：它接受一个参数，即要分配的内存块的大小（以字节为单位），并返回一个指向分配内存的指针。如果分配成功，返回的指针指向一块大小足够容纳请求的字节数的内存块，如果分配失败则返回 NULL。
calloc：它接受两个参数，分别是要分配的内存块的数量和每个内存块的大小（以字节为单位）。并且他会把内存中的每一位都初始化为0，如果分配成功，返回指向分配内存的指针，如果分配失败则返回 NULL。
realloc：realloc 函数用于重新分配先前分配的内存块的大小。它接受两个参数，一个是指向先前分配的内存块的指针，另一个是新的内存块大小。 当原空间后有足够空间，则继续在原空间上申请空间，并且返回原来的地址；若空间不足，那么系统将会重新找一块空余地址开辟，并将之前原始空间的数据拷贝在该空间，并且释放原始空间。
free : free函数的作用就是将malloc、calloc以及realloc函数申请的动态内存空间释放，其释放空间的大小取决于之前申请的内存空间的大小。


	// 使用 malloc 分配一个包含 40 个字节的数组
	char* a = (char*)malloc(40);
	char* a = (char*)malloc(sizeof(int) * 4);

	// 使用 calloc 分配一个包含 40 个字节的数组
	char* a = (char*)calloc(40, sizeof(char));


	// 使用 realloc 扩展数组大小到 80 个字节
	char* b = (char*)realloc(a, 80);

3. C++中动态内存管理

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

3.1 new/delete操作内置类型

一、动态申请单个某类型的空间

	//动态申请一个空间
	int* a1 = new int;	//申请

	delete a1;		//销毁

	//上述相当于：
	int* a1 = (int* )malloc(sizeof(int));	//申请

	free(a1)	//销毁

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

	//动态申请10个int型空间
	int* a2 = new int[10];	//申请

	delete[] a2;	//销毁


	//上述相当于
	int* a2 = (int *)malloc(sizeof(int) * 10);	//申请

	free(a2);	//销毁

三、动态申请单个某类型的空间并初始化

	//动态申请单个空间并初始化
	int* a3 = new int(1);	//申请并初始化

	delete a3;	//销毁

	//相当于
	int* a3 = (int*)malloc(sizeof(int));	
	*a3 = 1;	

	free(a3);

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

	int* a4 = new int[10]{ 1,2,3,4,5,6,7,8,9 };		//申请并初始化

	delete[] a4;	//销毁

注意：申请和销毁多个类型空间的时候，使用的分别是 int[ ] 和 delete[ ].

3.2 new和delete操作自定义类型

对于程序的内置类型，new/delete 和 malloc/free 几乎没有什么区别，只是new和delete的写法更加简单。

new/delete 和 malloc/free最大区别是 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;
	
	return 0;
}

在这里插入图片描述
建议在C++中使用new和delete.
因为：1. 用法上进行调整，更简洁好用 . 2. 定义类型，new支持开空间+构造函数初始化

4. operator new与operator delete函数

4.1 operator new与operator delete函数

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

实际上operator new就是通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，尝试执行空间不足应对措施，如果该应对措施用户设置了，则继续申请，否则抛异常。

operator new 是对malloc的封装
operator delete 是对free的封装
在这里插入图片描述

5. 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来释放空间。

6. 定位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;
class A
{
public:
	A(int a = 0) //构造函数 
		:_a(a)
	{}

	~A() //析构函数
	{}
private:
	int _a;
};
int main()
{
	//new(place_address)type 形式
	A* p1 = (A*)malloc(sizeof(A));
	new(p1)A;

	//new(place_address)type(initializer-list) 形式
	A* p2 = (A*)malloc(sizeof(A));
	new(p2)A(2021);

	//析构函数也可以显示调用
	p1->~A();
	p2->~A();
	return 0;
}

注意： 在未使用定位new表达式进行显示调用构造函数进行初始化之前，malloc申请的空间还不能算是一个对象，它只不过是与A对象大小相同的一块空间，因为构造函数还没有执行。

7. 常见面试题

malloc/free和new/delete的区别？

共同点：
都是从堆上申请空间，并且需要用户手动释放。
不同点：

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

内存泄漏

什么是内存泄漏，内存泄漏的危害？
内存泄漏：

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

内存泄漏的危害：

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

void MemoryLeaks()
{
	// 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。
系统资源泄漏
指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

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

内存泄漏非常常见，解决方案分为两种：
1、事前预防型。如智能指针等。
2、事后查错型。如泄漏检测工具。

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

在堆上申请4G的内存：

#include <iostream>
using namespace std;
int main()
{
	//0xffffffff转换为十进制就是4G
	void* p = malloc(0xfffffffful);
	cout << p << endl;

	return 0;
}

在32位的平台下，内存大小为4G，但是堆只占了其中的2G左右，所以我们不可能在32位的平台下，一次性在堆上申请4G的内存。这时我们可以将编译器上的win32改为x64，即64位平台，这样我们便可以一次性在堆上申请4G的内存了。
在这里插入图片描述

jokr_

关注

24
点赞
踩
26

收藏

觉得还不错? 一键收藏
3
评论
【C/C++内存管理详解】

new的原理调用operator new函数申请空间在申请的空间上执行构造函数，完成对象的构造delete的原理在空间上执行析构函数，完成对象中资源的清理工作调用operator delete函数释放对象的空间new T[N]的原理调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请在申请的空间上执行N次构造函数delete[]的原理在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理。
复制链接

扫一扫