C/C++内存管理

Posted 2021-11-09 小倪同学 -_-

文章目录

• C/C++内存分布
• C/C++动态内存管理方式
• operator new与operator delete函数
• new和delete的实现原理
• • 内置类型
  • 自定义类型
• 定位new表达式(placement-new)
• 常见面试题
• • malloc/free和new/delete的区别
  • 内存泄漏
  • 如何一次在堆上申请4G的内存

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);
}

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

C语言中动态内存管理方式为malloc/calloc/realloc和free，用法如下

void Test()
{
	// malloc函数的功能是开辟指定字节大小的内存空间
	// 开辟成功就返回该空间的首地址，如果开辟失败就返回一个NULL
	int* p1 = (int*)malloc(sizeof(int));
	free(p1);

	// calloc和malloc基本类似，不同点在于calloc会将开辟空间初始化为0
	int* p2 = (int*)calloc(4, sizeof (int));

	// realloc功能是调整已开辟好的空间
	int* p3 = (int*)realloc(p2, sizeof(int)* 10);
	// free释放已开辟好的空间
	free(p3);
}

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

new/delete操作内置类型

int main()
{
	// 动态申请一个int类型的空间
	int* ptr1 = new int;
	// 动态申请一个int类型的空间并初始化为10
	int* ptr2 = new int(10);
	// 动态申请4个int类型的个空间
	int* ptr3 = new int[4];
	// 动态申请4个int类型的空间并初始化
	int* ptr4 = new int[4]{ 1, 2, 3, 4};
	delete ptr1;
	delete ptr2;
	delete[] ptr3;
	delete[] ptr4;
}

申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]

class Test
{
public:
	Test()
		: _data(0)
	{
		cout << "Test():" << this << endl;
	}
	~Test()
	{
		cout << "~Test():" << this << endl;
	}
private:
	int _data;
};
void Test1()
{
	// 申请单个Test类型的空间
	Test* p1 = (Test*)malloc(sizeof(Test));
	free(p1);
	// 申请10个Test类型的空间
	Test* p2 = (Test*)malloc(sizeof(Test) * 10);
	free(p2);
}
void Test2()
{
	// 申请单个Test类型的对象
	Test* p1 = new Test;
	delete p1;
	// 申请10个Test类型的对象
	Test* p2 = new Test[10];
	delete[] p2;
}

注意：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会。

operator new与operator delete函数

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

operator new和operator delete的用法和malloc和free的用法完全一样
operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，尝试执行空 间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常
operator delete: 该函数最终是通过free来释放空间的

观察如下代码

struct ListNode
{
	int val;
	struct ListNode* next;
	static int _count;

	ListNode(int x)
		:val(x)
		, next(nullptr)
	{}
	void* operator new(size_t n)
	{
		++_count;
		return ::operator new(n);
		// ::前为空表示全局域里的函数
	}
	void operator delete(void* p)
	{
		--_count;
		return ::operator delete(p);
	}
};
int ListNode::_count = 0;

该代码重载一个类ListNode,有专属的operator new
当我们创建new ListNode时，那么申请空间就会调用专属的operator new/operator delete，这时就可以进行一些额外的操作，上述代码可以通过_count计算还未释放的指针。

operator new与operator delete函数应用范围很小，了解即可。

new和delete的实现原理

内置类型

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

自定义类型

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表达式是在已分配的原始内存空间中调用构造函数初始化一个对象

使用格式：

new (place_address) type或者new (place_address) type(initializer-list)

place_address必须是一个指针，initializer-list是类型的初始化列表

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

struct ListNode
{
	int val;
	struct ListNode* next;
	static int _count;

	ListNode(int x)
		:val(x)
		, next(nullptr)
	{
		cout << "ListNode()" << endl;
	}

	~ListNode()
	{
		cout << "~ListNode()" << endl;
	}
};
int ListNode::_count = 0;

int main()
{
	// 构造函数自动调用
	ListNode node(1);
	ListNode* p = new ListNode(2);
	
	ListNode* n1 = (ListNode*)malloc(sizeof(ListNode));
	// 对一块空间调用构造函数初始化
	new(n1)ListNode(3);

	n1->~ListNode();
	free(n1);

	return 0;
}

用于数组拷贝构造

int main()
{
	A a[3];
	cout << endl;
	// 复制一份a数组到另外一块空间b
	A* pb1 = new A[3];
	for (int i = 0; i < 3; ++i)
	{
		pb1[i] = a[i];
	}
	cout << endl;

	// 直接拷贝构造
	A* pb2 = (A*)malloc(sizeof(A) * 3);
	for (int i = 0; i < 3; ++i)
	{
		new(pb2 + i)A(a[i]);
	}

	return 0;
}

常见面试题

malloc/free和new/delete的区别

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

不同点：

一，特点用法：

1. malloc和free是函数，new和delete是操作符
2. malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可
3. malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型

二，底层原理区别

申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理

三，处理错误方式

malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常

内存泄漏

什么是内存泄漏：

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

内存泄漏的危害：

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

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

• 堆内存泄漏(Heap leak)

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

• 系统资源泄漏

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

如何避免内存泄漏

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

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

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

#include <iostream>
using namespace std;
int main()
{
	void* p = new char[0xfffffffful];
	cout << "new:" << p << endl;
	return 0;
}

在32位的平台下，内存大小为4G，但是堆只占了其中的2G左右，所以我们不可能在32位的平台下，一次性在堆上申请4G的内存。当我们把平台改为64位时，我们便可以一次性在堆上申请4G的内存了。（64位平台内存大小为32位的2³²倍）

32位

64位