【C++】初始模板

泛型编程，即编写一种与数据类型无关的通用代码，是代码服用的一种手段，而模板是泛型编程的基础，泛型编程能有效提高我们编写代码的效率，减少代码体积。

函数模板

函数模板在使用时被参数化，根据实参的类型产生函数的特定类型版本。

语法：

template<class T/typename T...>
T func(T x, T y)
{
    //函数体
    //...
}

class和typename表示不确定类型，根据实参确定类型，这里template<class T/typename T>称为模板参数，这里无论用class还是typename都没有差别，往下就可以定义一个函数了，涉及到类型就用T来表示就可以了，下面简单写一个Add函数，用来表示各种类型的加法：

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

调用：

int main()
{
	int i1 = 10;
	int i2 = 20;
	double d1 = 1.1;
	double d2 = 2.2;
	
	int ret1 = Add(1, 2);
	double ret2 = Add(1.1, 2.2);
	int ret3 = Add(i1, i2);
	double ret4 = Add(d1, d2);
	int ret5 = Add<int>(10, 20);
	double ret6 = Add<double>(3.3, 5.5);
	return 0;
}

以上都是每次实参的类型都是一致时的调用，有可能相加的两个数的类型并不一致，此时可以考虑给两个模板参数，但是返回值也是一个问题，因为默认要返回精度更高的那一个，其实不这样搞也是可以的，只需在传参时指明出来就好了，以下是两种不同类相相加传参的方法：

1、强制类型转换

int main()
{
	int ret1 = Add((int)2.2, 10);
	double ret2 = Add((double)10, 2.2);

	return 0;
}

根据我们的需要，可以把不同的类型强制转换为我们需要的相同类型。

2、显示指明模板参数类型

int main()
{
	int ret1 = Add<int>(2.2, 10);
	double ret2 = Add<double>(10, 2.2);

	return 0;
}

语法就是在函数后面加上尖括号< >，尖括号里面加上我们需要的类型，那么编译器在传参时就把实参的类型都当场我们指定的类型了。

函数模板的匹配原则

函数模板本身不是一个函数，可以理解为他只是一张蓝图，我们用这张蓝图实例化出来的才是真正的函数，其实函数模板的原理和我们的函数重载差不多，只不过重载是每一种类型可能都是我们自己写的，而函数模板是根据我们传递的参数类型，由编译器来根据我们传递的参数来推演出这些代码。

其实和重载的区别就在于是我们手动实现，还是交由编译器推演来实现罢了。

函数模板的匹配原则

如果存在与函数模板同名的一个非模板函数存在，并且调用同名函数时参数类型与非模板函数参数类型匹配，会优先调用非模板函数：

//函数模板
template<class T>
T Add(T x, T y)
{
	cout << "调用了T Add(T x, T y)" << endl;
	return x + y;
}

//非模板函数
int Add(int x, int y)
{
	cout << "调用了int Add(int x, int y)" << endl;
	return x + y;
}

int main()
{
	int i1 = 1;
	int i2 = 2;
	Add(i1, i2);

	double d1 = 1.1;
	double d2 = 2.2;
	Add(d1, d2);

	return 0;
}

结果： 

---

 如果是存在一个只有一个模板参数的模板函数和一个有两个模板参数的模板函数，如果实参的类型相同会调用只有一个模板参数的模板函数，如果实参的类型不同，则会调用有两个模板参数的模板函数：

//只有一个模板参数的模板函数
template<class T>
T Add(T x, T y)
{
	cout << "调用了T Add(T x, T y)" << endl;
	return x + y;
}

//有两个模板参数的模板函数
template<class T1,class T2>
T1 Add(T1 x, T2 y)
{
	cout << "调用了T1 Add(T1 x, T2 y)" << endl;
	return x + y;
}

int main()
{
	double d1 = 1.1;
	double d2 = 2.2;
	Add(d1, d2);

	int i1 = 1;
	int i2 = 2;
	Add(i1, d1);
	return 0;
}

结果： 

 

类模板

我们在使用C语言写栈时，是否遇到过这种情况，如果我们的栈需要存的是double类型时，要把栈的实现修改一下，如果我们的栈需要存储的是int类型时，要把栈的实现修改一下......也就是说我们不能存在两个栈，一个栈存的是double类型，一个栈存的是int类型，除非我们实现两个存储类型不同的栈，有人会说，那已经写好了一个栈了，把代码拷贝一份，在改一下存储类型不就好了吗？确实，但是这样代码的体积就会变大，而且栈的逻辑都是相同的，会出现很多除了类型不同但是逻辑相同的重复代码，而使用类模板就很好解决了这个问题，我们只有一份通用的模板，你要实例化什么类型的栈就传参就好了，这大大减少了代码的重复，也减少了程序的体积。

语法：

template<class T1, class T2, ......, class Tn>
class stack
{
	//实现...
	//...
};

实例化：

int main()
{
	stack<int> st1;
	stack<double> st2;
	return 0;
}

类模板实例化对象必须显示的带上类型，这和函数模板不同，而且需要注意，st1的类型是stack<int>，st2的类型是stack<double>，而stack只是类名。