【C++初阶】模版初识-优快云博客

函数模板

在我们写排序的时候时常会用到要交换两个数据的场景：

void Swap(int& left, int& right)
{
 int temp = left;
 left = right;
 right = temp;
}
 
void Swap(double& left, double& right)
{
 double temp = left;
 left = right;
 right = temp;
}
 
void Swap(char& left, char& right)
{
 char temp = left;
 left = right;
 right = temp;
}

就算有函数重载支持一个函数传入不同类型的参数，但是每一种数据类型都要写一个，感觉不是很方便，而且这些函数只有函数参数的类型不一样，其他都一样。

auto虽然可以识别类型，但是不能做参数。

可不可以写一个跟类型无关的代码也叫叫做泛型编程跟类型无关。

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

函数模板格式

template 返回值类型函数名(参数列表){}

template<typename T>
void Swap( T& left, T& right)
{
 T temp = left;
 left = right;
 right = temp;
}

T的位置可以自己命名。

那么对于不同类型使用的时候：

原因：模版函数的推演（由编译器执行）

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

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

这里函数模版的typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)

多个类型情况：

这里的函数的所有参数都是一个类型，如果我们函数参数是多个类型，模版该如何定义：

模版参数是很类似函数参数的，函数参数可以定义多个，模版参数也可以定义多个。只是，函数参数定义的是形式参数对象，模版参数定义的是类型。

template<class T1,class T2>
void func(const T1& x, const T2& y)
{
	cout << x << endl;
	cout << y << endl;
	//这里也凸显了coutC++输入输出流的好处，不仅可以打印自定义类型，而
	//可以配合模版识别打印类型
}

不能一个模版参数推导成两种类型：比如：

解决方式：

第一种就是将上述模版参数修改成两个。

第二种方式使用强制类型转换：

cout << Add(1, (int)2.2) << endl;

第三种：以上使用的方式都叫做推演实例化，通过实参传递，去推导模版参数的类型，生成对应的函数。还有一种方式显示实例化：

cout << Add<int>(1, 2.2) << endl;
cout << Add<double>(1, 2.2) << endl;

真正显示实例化场景：

 template<class T>
 T* func1()
 {
	 T* p = new T[10];
	 return p;

 }
 //这个函数没有参数，没法推演函数参数类型，只能显示实例化调用

 template<class T>
 T* func1(int t)
 {
	 T* p = new T[10];
	 return p;

 }
 //这个函数参数类型和模版参数类型推演无关，无法推演。
 int main()
 {
	 double* p = func1<double>();
	 double* p = func1<double>(2);

	 return 0;
 }

函数模板可以和普通函数一起存在不会出现调用歧义：

遵循规则：有合适的就调用更为合适的。

类模板：

对于一个类的数据，比如我们原先定义的栈类，我要修改栈类存储的数据是int 还是char 最开始都是使用宏定义的方式,这里引入类模版：

类模版只能显示实例化

 template<class T>
 class Stack
 {
 public:
 private:
	 T* _a;
	 int top;
	 int capacity;
 };

 int main()
 {

	 Stack<int> st1;
	 Stack<double> st2;
	 return 0;
 }

普通类：类名就是类型

类模版实例化的类：类名不是类型，类名<数据类型>才是整个类的类型。

Stack<int> st1;
Stack<double> st2;

不是同一个类型。显示实例化的类型不同，他们就是不同的类。

类模板只能够推演实例化

构造函数的写法：函数名和类名相同而不是和类型相同：

 Stack(int n = 4)
 {
	 cout << "Stack creat" << endl;
	 _a = new T[n];
	 _top = 0;
	 _capcity = n;
 }
 ~Stack()
 {
	 cout << "Stack destory" << endl;
	 dalete[] _a;
	 _top = 0;
	 _capcity = n;
 }

类模版的声明和定义分离：

要指定类域

template<class T>
class Stack
{
public:
 Stack(int n = 4);
 ~Stack()
 {
	 cout << "Stack destory" << endl;
	 dalete[] _a;
	 _top = 0;
	 _capcity = n;
 }
private:
 T* _a;
 int top;
 int capacity;
};
template<class T>
Stack<T>::Stack(int n )
{
 cout << "Stack creat" << endl;
 _a = new T[n];
 _top = 0;
 _capcity = n;
}

二者放在一个文件中，后续放在两个文件中报错的问题后续知识补充。