【C++】动态内存管理

在我们学习C++之前
在C语言中常用的动态内存管理的函数为： malloc calloc realloc free

在我们学习了C++后，也迎来了新的动态内存管理的操作符
new

new和delete

用法

内置类型

//对应类型指针接收          申请的类型      
int* p1          =   new   int；

//将创建的int变量赋值为3
int* p2=new int(3);

//申请多个int对象，并将其赋值为1和2
int* p3 = new int[2] {1, 2};

//将new申请的空间进行释放
delete p1;
delete p2;

//与new[]配合使用
delete[] p3;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

从这上面我们可以看到new其实也没有什么特别出彩的地方，初始化和申请多个对象，老哥俩也都能做到

但是我们要看的是C++对于C的区别可不是内置类型，而是自定义类型。

自定义类型

这里是malloc的自定义类型的开辟内存方法

class A 
{
public:
	A(int x = 3)
		:_x(x)
	{
		
	}
	
	~A() 
	{
		
	}
private:
	int _x;

};
int main()
{
	A* A1 = (A*)malloc(sizeof(A));
	free(A1);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

接下来是new的申请内存的使用。

class A 
{
public:
	A(int x = 3)
		:_x(x)
	{
		cout << "构造";
	}
	
	~A()	
	{
		cout <<"\n" << "析构";
	}
private:
	int _x;

};

int main()
{
	A* A1 = new A(3);
	delete A1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

这里看到结果，相信大家就看到new的一部分优势了。

new会自动调用构造函数，delete会自动调用析构函数，而free和malloc做不到

这就使new可以对开辟的对象进行初始化，而malloc做不到

抛异常

在使用malloc中时，当遇到申请空间失败时，会进行返回空地址的。
就是通过返回值来表示错误

int main()
{
	while (malloc(sizeof(1024 * 1024)))
	{
	}
}
1
2
3
4
5
6

这个代码就是不挺向堆区申请空间，直到malloc返回指针为空时结束

而在C++中，更偏向抛异常的表示方法。

int main()
{
	int* p1=nullptr;
	
		do
		{
			p1=new int[1024 * 1024];
		} while (p1);
}
1
2
3
4
5
6
7
8
9

这里不停申请会出现错误

new在使用的时候会对申请空间的错误进行抛出异常。

这个时候想要看到什么地方出错，就需要对异常进行捕获。

int main()
{
	int* p1=nullptr;
	try {
		do
		{
			p1=new int[1024 * 1024];
		} while (p1);
	}
		catch (const exception& e)
	{
		cout << e.what() << endl;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

这里就成功将错误展示了出来。

定位new

经过上面，我们知道new具有初始化对象的功能，这是malloc不曾具有的。

所以这个时候就引出了new的一个特殊用法。

不需要new来申请和销毁空间，只是对对象进行初始化

用法：

new (place_address) type

class A
{
public:
	A(int member=13)
	{
		_member = member;
	}

	~A()
	{
		cout << "\n" << "析构";
	}
private:
	int _member;

};

int main()
{
//这里的A1只是一个地址，没有进行初始化。
	A* A1 = (A*)malloc(sizeof(A));
//这里通过new来调用构造函数		地址			类型		构造函数的参数
	new 					(A1) 		A		(1);

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

这个一般来讲都是用在池化技术里的。

博主也没学到哪，所以只能稍微简单讲下

为了提高效率，所以会选择一次申请一块空间

刨析new和delete的执行与实现逻辑

这里我们从上面能看到new和delete具有以下功能

1.开辟/销毁 空间
2.抛出异常
3.调用 构造/析构 函数

功能执行顺序

这里就随便写个代码来解释它的执行

class A 
{
public:
	A()
	{
		_member = new int;
	}
	
	~A()	
	{
		cout <<"\n" << "析构";
		delete _member;
	}
private:
	int* _member;

};

int main()
{
	A* A1 = new A;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

new

通过这上面的顺序，我们能知道new一个对象所走的步骤

我们初心是为了理清楚
1.开辟空间
2.抛出异常
3.调用 构造 函数
这三步的步骤顺序。

这里为了让大家看得清楚一点，就稍微标记一下

这里我们就能看到，对于new来说

需要进行的操作步骤是：
1.用malloc来向堆区申请空间
2.对malloc进行判断，是否出错。
3.调用构造函数

delete

而delete就很简单了

这是new所走的步骤。
这里我们能看到每个变量都层层指向
所以我们原路返回，一个一个回头销毁就行

这里我们也进行标记一下

所以delete的执行顺序为
1.调用构造函数
2.用free来向堆区申请空间
3.对free进行判断，是否出错。

功能实现

这里我们知道了new和delete的底层执行顺序

这里就要来了解一下他们的实现的方式了。

1.开辟/销毁 空间
2.抛出异常
3.调用 构造/析构 函数

我们的目标是要实现这三个功能。

销毁/开辟空间，在C语言中不就有现成的吗
free和malloc函数。

所以实现第一步直接调用malloc和free即可

第二步抛出异常就是按照情况进行判断，然后进行异常的捕获

第三步调用构造析构函数不难，直接调用就可以

operator new与operator delete

这里的operator new和operator delete

是设计的全局函数，专门为new和delete的实现的函数

主要的作用是实现前两步：

1.开辟/销毁 空间
2.抛出异常

这里就能写出new和delete的实现逻辑了

malloc free与new delete的总结

综上所述

new和delete在实现的过程中调用了free和malloc的函数。

所以可以说
new和delete可以说是为了让内存开辟更适合面向对象语言的使用而诞生的

所以与其说new和malloc的区别，不如说new对于malloc的提升有哪些

提升：
1.
malloc的返回值为(void), 在使用时必须强转。new不需要，因为new后跟的是空间的类
2.
malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常
3.
申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数
而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理
4.malloc不会对申请的空间进行初始化，new可以对申请内存进行初始化。