C++动态内存管理+模板

💓博主个人主页:不是笨小孩👀
⏩专栏分类:数据结构与算法👀 C++👀 刷题专栏👀 C语言👀
🚚代码仓库:笨小孩的代码库👀
⏩社区：不是笨小孩👀
🌹欢迎大家三连关注，一起学习，一起进步！！💓

动态内存管理

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

内置类型

对于内置类型new开辟的空间可以初始化，也可以不初始化，但是delete一定要匹配使用。
申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]。

void Test()
{
	//动态申请一个int的大小，不初始化
	int* p = new int;

	//动态申请一个int的大小，初始化
	int* p2 = new int(10);

	//动态申请10个int类型的大小，不初始化
	int* p3 = new int[10];

	//动态申请10个int类型的大小，初始化
	int* p4 = new int[10]{0};

	delete p;
	delete p2;
	delete[] p3;
	delete[] p4;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

对于内置类型，new就相当于malloc+memset的功能，开辟空间和初始化。

自定义类型

new对于自定义类型，除了开空间以外，还会调用它的构造函数来初始化，delete的时候也会先调用它的析构函数，然后在释放空间。

class A
{
public:
	A(int x = 2,int y = 2)
		: _x(x)
		, _y(y)
	{}

	~A()
	{}

private:
	int _x;
	int _y;
};
int main()
{
	A* a = new A(1,1);
	//开空间并且调用构造函数


	delete a;
	//调用析构函数并且释放空间
	return 0;
}
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和malloc最大的区别就是，new是开空间和初始化，但是malloc是只开空间，不进行初始化，但是构造函数目前没法显示调用，所以问题就很大。

operator new与operator delete函数

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

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

operator new实际上是malloc的一个封装，但是它作出了一定的改变，malloc开辟失败会返回空指针，但是operator new开辟空间失败会抛出一个异常。
operator delete: 该函数最终是通过free来释放空间的。

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

定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。

new (place_address) type或者new (place_address) type(initializer-list)
place_address必须是一个指针，initializer-list是类型的初始化列表。

class A
{
public:
	A(int x, int y)
		:_x(x)
		,_y(y)
	{}
private:
	int _x;
	int _y;
};
int main()
{
	A* a = (A*)malloc(sizeof(A));
	//对于开了空间但是没初始化的，可以用定位new来进行初始化
	new (a) A(1,2);

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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

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

内存泄漏

什么是内存泄漏？

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

内存泄漏的危害：

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

模板

泛型编程

编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。也就是说我们可以将逻辑相同，但是只有类型不同的这种函数，或者类，我们写一个通用的函数或类就可以解决所有情况，这就是我们的泛型编程。

函数模板

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定
类型版本。
template
返回值类型 函数名(参数列表){}

比如我们写一个交换函数：

template <class T>
void Swap(T& x, T& y)
{
	T tmp = x;
	x = y;
	y = tmp;
}

int main()
{
	int x1 = 1, x2 = 2;
	double d1 = 1.1, d2 = 2.2;
	Swap(x1, x2);
	Swap(d1, d2);
	cout << x1 << " " << x2 << endl;
	cout << d1 << " " << d2 << endl;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

注意：typename是用来定义模板参数关键字，也可以使用class(不能使用struct代替class)。

函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器。

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

函数模板实例化

用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例
化。

1. 隐式实例化：让编译器根据实参推演模板参数的实际类型。
   我们之前用的都是隐式实例化。
2. 显式实例化：在函数名后的<>中指定模板参数的实际类型

template <class T>
void Swap(T& x, T& y)
{
	T tmp = x;
	x = y;
	y = tmp;
}

int main()
{
	double d1 = 1.1, d2 = 2.2;
	Swap<double>(d1, d2);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

模板函数不允许自动类型转换，但普通函数可以进行自动类型转换，所以我们在使用函数模板时一定要确保参数的类型对应都是一样的，或者显示的实例化。

类模板

template
class 类模板名
{
// 类内成员定义
};

假设我们需要定义一个栈，我们可能存储int类型，也可能存储double类型，这时候就需要我们的类模板。

template <class T>
class Stack
{
public:
	//...
private:
	T* a;
	int size;
	int capacity;
};
1
2
3
4
5
6
7
8
9
10

类模板中函数放在类外进行定义时，需要加模板参数列表。

template <class T>
class Stack
{
public:
	Stack();
private:
	T* a;
	int size;
	int capacity;
};

template <class T>
Stack<T>::Stack()
{
	//..
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

类模板实例化

类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<> 中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

template <class T>
class Stack
{
public:
	//..
private:
	T* a;
	int size;
	int capacity;
};


int main()
{
	//Stack类名，Stack才是类型
	//类模板实例化
	Stack<int> st;
	Stack<double> st2;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

今天的分享就到这里，感谢大家的关注和支持。