【C++学习】C++的动态内存管理 | new和delete的底层 | 初识模板

news2024/11/14 23:30:59

1. C++的动态内存管理

2. new和delete的底层

3. 定位new

4. new和malloc 的区别总结

5. 模板

写在最后：

1. C++的动态内存管理

上一篇文章已经大致介绍完new和delete的用法，

以及C++和C语言两种动态内存管理方式的区别，这里简单总结一下：

1. 动态申请内置类型的数据：

new/malloc除了用法上面，其他方面没什么区别。

2. 动态申请自定义类型的数据：

new/malloc除了用法上面，new/delete还会调用构造函数初识化和析构函数。

2. new和delete的底层

来看：

我们可以看到，new和delete实际上是调用这两个全局函数：

operator new 和 operator delete，而这两个库函数其实我们也可以直接使用

来看代码：

#include <iostream>
using namespace std;

int main()
{
	int* p1 = new int;
	delete p1;

	int* p2 = (int*)operator new(sizeof(int));
	operator delete(p2);

	return 0;
}

我们可以看到，从用法上来看，这两个函数的用法是和malloc和free是一样的，

我这里在来看：

new的malloc之间的区别，

new的功能：开空间 + 构造函数

malloc功能：开空间

实际上，new的底层开空间就是直接使用的malloc，但是

面向对象的语言处理失败，不喜欢用返回值，更建议用抛异常，而malloc失败返回的是空，

所以实际上operator new是对malloc的一个封装，如果申请失败，operator new就会抛异常，

所以new就是使用operator new开空间 + 调用构造函数。

3. 定位new

定位new的作用是显示调用构造函数，

在平时，构造函数都是自动调用的，在创建对象的时候自动调用，

在使用new的时候也会自动调用构造函数，

来看这段代码：

#include <iostream>
using namespace std;

class A {
public:
	A()
	{
		cout << "A()" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}
};

int main()
{
	A* p1 = new A;
	delete p1;

	//使用定位new模拟new的功能
	A* p2 = (A*)malloc(sizeof(A));
	new(p2)A; 

	p2->~A();
	free(p2);

	return 0;
}

输出：

A()
~A()
A()
~A()

定位new的用法就是这样：new(p2)A；new(指针)类型。

当然，如果需要传参也可以：new(p2)A(1)，这样给构造函数传参。

4. new和malloc 的区别总结

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

总结：

前四个是特性和用法之间的不同，

后面两个是底层实现的不同：返回值/抛异常，调用构造和析构函数

5. 模板

模板是个好东西，

我先来看这样一段代码：

#include <iostream>
using namespace std;

void Swap(int& x, int& y) {
	int tmp = x;
	x = y;
	y = tmp;
}

void Swap(double& x, double& y) {
	double tmp = x;
	x = y;
	y = tmp;
}

void Swap(char& x, char& y) {
	char tmp = x;
	x = y;
	y = tmp;
}

int main()
{

	return 0;
}

我们在学了函数重载之后，可以通过这种方式，

让我们对这几个类型都能使用交换操作，但是，这样全部写一遍也太麻烦了，

这还只是三个类型，如果有更多的类型呢？

那该怎么办呢？

来看代码：

#include <iostream>
using namespace std;

//也可以这样写：template<class T>
template<typename T>
void Swap(T& x, T& y) {
	T tmp = x;
	x = y;
	y = tmp;
}

int main()
{
	int a1 = 10, b1 = 20;
	double a2 = 1.1, b2 = 2.2;
	char a3 = 'a', b3 = 'b';

	Swap(a1, b1);
	Swap(a2, b2);
	Swap(a3, b3);

	return 0;
}

使用了模板之后，就能支持所有类型的交换了，

模板的那个T就是模板参数，它定义的是类型。

这个时候又有一个问题了，那这三个Swap调用的是同一个函数吗?

我们来看看汇编怎么说：