C++：动态管理+模板

---

一、C++内存管理方式

在C++中，c语言内存管理方法也是可以继续使用的，但在一些特点的场景下就不能使用了。而且有些地方使用也比较麻烦。所以C++一般是通过new和delete操作符进行动态内存管理

1.1 new/delete操作内置类型

void test()
{
	//动态申请一个int类型的内存
	int* ptr = new int;
	delete ptr;

	//动态申请一个int类型的内存，并初始化为5
	int* ptr1 = new int(5);
	delete ptr1;

	//动态申请六个int类型的内存,也可以初始化
	int* ptr2 = new int[6] {1,2,3,4};
	delete[] ptr2;

}

int main()
{
	test();
	return 0;
}

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

1.2 new和delete操作自定义类型

class A
{
public:
	A(int a)
		:_a(a)
	{
		cout << "A(int a = 1)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}


private:
	int _a;
};


void test1()
{
	A* p1 = (A*)malloc(sizeof(A));
	free(p1);

	//malloc/free 与 new/delete最大的区别是：new会调用自定义类型的默认构造函数，delete会调用析构函数
	A* p2 = new A(0);
	delete p2;

	//如果自定义类型没有默认构造函数我们可以也可以这样初始化它。
	A* p3 = new A[3]{A(1),A(2),A(3)};
	delete[] p3;


}

1.3 对比malloc和free

1. 对于申请内置类型的数据：new/malloc除了用法上面，其他反面没什么区别。
2. 对于动态申请自定义类型的数据：new/malloc最大的区别是：new可以开空间也会调用构造函数初始，delete先调用析构函数，再释放空间。

1.4 operator new和operator delete函数

operator new和operator delete它们是两个全局函数，而new和delete是操作符。但new和delete底层下是调用operator new和operatror delete。而operator new：实际是在调用malloc，只不过如果动态申请内存失败会抛异常。operatror delete实际也是在调用free。

1.5 定位new表达式

定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。
使用格式：
new (place_address) type或者new (place_address) type(initializer-list)place_address必须是一个指针，initializer-list是类型的初始化列表
使用场景：
定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。

void test2()
{
	A* ptr1 = (A*)malloc(sizeof(A));
	//显示调用构造函数
	new(ptr1)A(5);

	//显示调用构造函数
	ptr1->~A();

}

二、常见的问题

2.1malloc/free和new/delete的区别

malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要手动释放。不同的地方：

1. malloc和free是函数，new和delete是操作符。
2. malloc申请的空间不会初始化，new可以初始化。
3. malloc申请空间是，需要手动计算空间的大小。new只需再后面加上空间的类型就可以了，如果是多个对象，在[]中指定对象个数就好了。
4. malloc的返回类型是void*，需要强制转换。new不需要。
5. malloc申请空间失败返回NULL，因此使用时必须判空。new不需要，但需要捕获异常。
6. 申请自定义类型对象时，mallc/free只会开辟空间，不会调用构造函数和析构函数。new在申请空间后会调用构造函数初始化，delete会调用析构函数后释放空间资源。

2.2 内存泄漏

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

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

---

三、函数模板

3.1 概念

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

3.2 格式

template<typename T1,typename T2…>
返回类型 函数名(参数列表){}
例子：

//tyoedname是定义模板参数的关键字，也可以用class(但不能用struct)
template<typename T>
void Swap(T& x, T& y)
{
	T tmp = x;
	x = y;
	y = tmp;
}

3.3 函数模板的实例化

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

3.3.1 隐式实例化

隐式实例化：编译器根据实参推演模板参数的实际类型

template<class T>
T Add(const T& x, const T& y)
{
	return x + y;
}

void test4()
{
	int i1 = 1, i2 = 2;
	double d1 = 1.1, d2 = 2.2;

	//隐式实例化
	cout << Add(i1, i2) << endl;
	cout << Add(d1, d2) << endl;
}

3.3.2 显示实例化

显式实例化：在函数名后的<>中指定模板参数的实际类型

template<class T>
T Add(const T& x, const T& y)
{
	return x + y;
}

template<class T>
T* Alloc(int i)
{
	return new T[i];
}

void test4()
{
	int i1 = 1, i2 = 2;
	double d1 = 1.1, d2 = 2.2;

	//隐式实例化
	cout << Add(i1, i2) << endl;
	cout << Add(d1, d2) << endl;

	//这种写法编译不能通过，因为编译器无法确定类型。
	//cout << Add(i1, d2) << endl;

	//但我们能自己转换类型
	cout << Add((double)i1, d2) << endl;

	//或者显示实例化
	cout << Add<int>(i1, d2) << endl;

	//并且有些函数必须要显示实例化
	Alloc<int>(10);

}

四、类模板

4.1 格式

template<class T1, class T2, ..., class Tn>
class 类模板名
{
 // 类内成员定义
};

例：

//普通类，类名和类型是一样的
//类模板，类名和类型不一样，类名：stack,类型：stack<T>
template<class T>
class stack
{
public:
	stack(int capacity)
		:_capacity(capacity)
	{
		_arr = new T[_capacity];
		_top = 0;
	}

	~stack()
	{
		delete[] _arr;
		_top = _capacity = 0;
	}

	void push(T x);

private:
	T* _arr;
	int _top;
	int _capacity;
};

template<class T>
void stack<T>::push(T x)
{
	_arr[top++] = x;
}

4.2 类模板的实例化

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

---