C++函数模板初阶

为何需要用到模板

在编程的时候，有时候我们经常需要用到swap函数，但是有时候需要交换的数据类型并不是一样的，这就导致swap函数我们需要写很多份，但是其函数的主体基本一致，这种做法就导致代码非常冗余。
为了避免这种代码的冗余，C++的大佬提出了模板这一概念，模板我们可以将其看作是印刷术的模具，从前对于作品的印刷需要人为抄写，有了印刷术以后只需要向模具内倒入墨汁就能自动执行了，其速度得到了很大的提高。模板也正是扮演了这一角色。

函数模板

格式：

template<class T1,class T2>
//这里的claas也可以替换成typename
//参数个数根据需求进行定义
//T是一种推导数据类型，编译器会通过实参对T的类型进行推导

这里我们看一下swap函数的函数模板：

template<class T>
void swap1(T &a, T&b)
{
	T c;
	c = a;
	a = b;
	b = c;
}



int main()
{
	int a = 10;
	int b = 20;
	swap1(a, b);
	char c = 'e';
	char d = 'f';
	swap1(c,d);


}

1.大家可以思考一下这里swap1(a,b)和swap1(c,d)调用的是否是一个函数。

答案：调用的并不是同一个函数，某个函数在调用函数模板的时候，函数模板会根据这个函数的参数类型实例化出一个函数出来，然后再调用这个函数。
对此我们可以通过汇编语言进行查看：

模板的特征：
1.模板是一种声明，只有当实例化函数的时候才会为变量分配空间。
2.一个模板被多个函数使用时，会实例化多份函数。实例化由编译器实现。不需要人为操作。

隐式类型推导

如果我们在调用函数模板的时候没有指明参数的类型，编译器会根据形参推导模板参数的类型，这种参数类型的推导就是隐式类型推导。
下面的swap1函数的调用就是一种隐式类型推导。

template<class T>
void swap1(T &a, T&b)
{
	T c;
	c = a;
	a = b;
	b = c;
}

int main()
{
	int a = 10;
	int b = 20;
	swap1(a, b);
}

显式类型推导

在学习了隐式类型推导以后，想必大家应该也能猜出什么是显式类型推导。
显式类型推导就是告诉编译器模板参数的类型。
下面代码传递了double类型的变量和int类型的变量，如果我们没有告诉编译器模板参数的类型，那么这时编译器就不知道T的类型应该是double还是int。在告诉编译器参数类型是int以后，double类型的数据传过去的时候就会被隐式类型转换成int.

template<class T>
void swap1(const T &a, const T &b)
{
	T c;
	c = a;
	a = b;
	b = c;
}



int main()
{
	int a = 10;
	double b = 20.2;
	swap1<int>(a, b);
}

显式类型推导的练习题

下面的这段代码能正常运行吗？

这道题做错的同学，应该是忘记了右值不能修改这一知识点。
我们来看一下这道题，a和b分别是int和double类型的变量，在调用函数模板的时候我们显示的告诉了编译器模板参数T的类型为int,那么double类型的b在传递的时候会发生隐式类型转换，传递过去的其实是隐式类型转换后的临时空间，而临时空间具有常性，其不能修改。但是实参是这块空间的引用，这就导致了权限被放大了，所以如果想要正常运行，需要在实参的前面+上const.
这一块忘记的同学可以看一下这篇博客：C++引用及其底层原理,再返回来看这道题，应该会有种焕然大悟的感觉。

函数模板的声明和实现分离

函数模板和普通函数的调用时机

下面这段代码：
在调用add函数的时候，调用的是函数模板还是普通函数呢？

#include<iostream>
using namespace std;



template<class T>
T add(T &a, T &b)
{
	return a+b;
}

int add(int &a,int &b)
{
	return a+b;
}



int main()
{
	int a=10;
	int b=20;
	cout<<add(a,b)<<endl;
} 

我们给出结论：当函数模板和普通函数同时满足匹配的条件时，优先调用普通函数。
这里大家可以这样想：函数模板是一个半成品，其还需要实例化出一个函数出来，而普通函数是一个成品，如果可以选择成品，编译器当然也就不会匹配半成品/函数模板了。

类模板

函数模板和类模板的用法相似：
区别就是类模板只能显示实例化：
格式：类名<参数类型> 类对象名

template<class T1>
class person {
public:
	
	T1 size;
	T1 capacity;
};



int main()
{
	person<int> p1;//必须显示告诉编译器参数T的类型
	
}

在类模板以前，普通类的类名就是类型，如student类的类型就是类名，而定义对象的方式是类型+对象名，所以我们之前定义对象都是如student s1这样的格式，但是在类模板中，一个类的类型并不是类名，而是类名+
<参数类型>,如上面person类的类型就是 person ,所以在定义给类的对象的时候需要显示的说明模板参数的类型。

类模板的声明与定义分离

在类模板中，对于该类的函数。有时我们想要进行类内声明，类外初始化。
和普通类不同，类模板的函数在类外初始化的时候需要满足下面的格式 ：

template<class T1>//告诉编译器这是一个类模板下的函数,这里和类模板是是保持一致的
返回值 类型::函数名(函数参数)
{
 	//函数主体
}

class person {
public:


	void saying();

	T1 size;
	T1 capacity;

};

template<class T1, class T2>
void person<T1, T2>::saying()
{
	cout << "hello world" << endl;
}


int main()
{
	person<int, int> p1;
	p1.saying();
}