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

这篇博客主要学习了C++内存管理方式：new/delete。

 

目录

C/C++内存分布

C语言动态内存管理方式

C++内存管理方式

new/delete操作内置类型

new/delete操作自定义类型

operator new与operator delete函数

new和delete的实现原理

内置类型

自定义类型

常见面试题

---

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

上面容易犯错的是char、*char2、pChar3、*pChar3：

char2的意思就是在常量区有“abcd\0”这样一个字符串，用这样一个字符串初始化char2数组的意思就是在栈上开辟一个数组，把“abcd\0”这样一个字符串拷贝过去到栈上，因此，char2在栈上，*char2==a，也在栈上。

pChar3虽然被const修饰，但是这不代表在常量区，只是是常变量，被const修饰代表pChar3指向的内容在常量区，但是pChar3还是在栈上。

C语言动态内存管理方式

主要使用malloc、calloc、realloc、free管理。

C++内存管理方式

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

new/delete操作内置类型

void Test()
{
	// 动态申请一个int类型的空间
	int* ptr4 = new int;
	// 动态申请一个int类型的空间并初始化为10
	int* ptr5 = new int(10);
	// 动态申请10个int类型的空间，并初始化
	int* ptr6 = new int[10]{1,2,3,4,5};
	delete ptr4;
	delete ptr5;
	delete[] ptr6;
}

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

int main()
{
	//1.用法上，变简洁了
	int* p1 = new int;
	int* p2 = new int[10];

	//2.可以控制初始化
	int* p3 = new int(10); //new一个int对象，初始化为10
	int* p4 = new int[10]{ 1,2,3,4,5 };

	//3、自定义类型，开空间+构造函数
	//4、new失败了以后抛异常，不需要手动检查
	ListNode* node1 = new ListNode(1);
	ListNode* node2 = new ListNode(2);
	ListNode* node3 = new ListNode(3);
	
	ListNode* p = CreateList(5);
	delete p1;
	delete[] p2;
	delete p3;
	delete[] p4;

	return 0;
}

基于以上4点，我们可以放弃C语言中的malloc等，C++这里的new和delete太好用了！

new/delete操作自定义类型

class A
{
public:
	A(int a=0)
	{
		_a = a;
		cout << "A(int a=0)" << endl;
	}
	~A()
	{
		cout << "~A()" << 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;
	//定义自定义类型的数组
	A* p7 = new A[5]{ 1,2,3,4,5 };
	delete p7;

	return 0;
}

new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间还会调用构造函数和析构函数。

operator new与operator delete函数

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

operator new是对malloc的封装-->失败抛异常，实现new。

operator delete是对free的封装。

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

下面再来看一个细节：

class Stack
{
public:
	Stack()
	{
		_a = (int*)malloc(4 * sizeof(int));
		_top = 0;
		_capacity = 4;
	}

private:
	int* _a;
	int _top;
	int _capacity;
};

int main()
{
	A* ptr1 = new A;//operator new + 1次构造
	A* ptr2 = new A[10];//operator new[] + 10次构造

	delete ptr1;//1次析构+operator delete
	delete[] ptr2;//10次析构+operator delete[]


	return 0;
}

在delete[] ptr2这句代码中，并没有传递10次给delete[]，那么编译器怎么知道要析构10次呢？原因就是，在创建ptr2时，编译器本来应该为ptr2分配40个字节的空间（A[10]的大小），但实际上，编译器为ptr2分配了44个字节，这一点我们可以通过其汇编代码看到：

多了4个字节，其实4个字节放在了开辟空间的前面，用于存放开辟数组的大小，当delete[]时会根据这4个字节存放的的值去析构特定的次数。

但是，如果定义内置类型，由于内置类型不需要调用析构函数，因此，不会多开辟4个字节：

会不会多开4个字节，关键在于需不需要！

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

常见面试题

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在释放空间前会调用析构函数完成空间中资源的清理