在使用类模板创建对象时，程序员需要显式的指明实参（也就是具体的类型）。例如对于下面的 Point 类：
template<typename T1, typename T2> class Point;
我们可以在栈上创建对象，也可以在堆上创建对象：
Point<int, int> p1(10, 20); //在栈上创建对象
Point<char*, char*> *p = new Point<char*, char*>("东京180度", "北纬210度"); //在堆上创建对象因为已经显式地指明了 T1、T2 的具体类型，所以编译器就不用再自己推断了，直接拿来使用即可。
而对于函数模板，调用函数时可以不显式地指明实参（也就是具体的类型）。请看下面的例子：
//函数声明
template<typename T> void Swap(T &a, T &b);
//函数调用
int n1 = 100, n2 = 200;
Swap(n1, n2);
float f1 = 12.5, f2 = 56.93;
Swap(f1, f2);
虽然没有显式地指明 T 的具体类型，但是编译器会根据 n1 和 n2、f1 和 f2 的类型自动推断出 T 的类型。这种通过函数实参来确定模板实参（也就是类型参数的具体类型）的过程称为模板实参推断。
在模板实参推断过程中，编译器使用函数调用中的实参类型来寻找类型参数的具体类型。
模板实参推断过程中的类型转换
对于普通函数（非模板函数），发生函数调用时会对实参的类型进行适当的转换，以适应形参的类型。这些转换包括：
1、算数转换：例如 int 转换为 float，char 转换为 int，double 转换为 int 等。
2、派生类向基类的转换：也就是向上转型，请猛击《C++向上转型（将派生类赋值给基类）》了解详情。
3、const 转换：也即将非 const 类型转换为 const 类型，例如将 char * 转换为 const char *。
4、数组或函数指针转换：如果函数形参不是引用类型，那么数组名会转换为数组指针，函数名也会转换为函数指针。
5、用户自定的类型转换。
例如有下面两个函数原型：
void func1(int n, float f);
void func2(int *arr, const char *str);
它们具体的调用形式为：
int nums[5];
char *url = "http://www.gamecolg.com";
func1(12.5, 45);
func2(nums, url);
对于 func1()，12.5 会从double转换为int，45 会从int转换为float；对于 func2()，nums 会从int [5]转换为int *，url 会从char *转换为const char *。
而对于函数模板，类型转换则受到了更多的限制，仅能进行「const 转换」和「数组或函数指针转换」，其他的都不能应用于函数模板。例如有下面几个函数模板：
template<typename T> void func1(T a, T b);
template<typename T> void func2(T *buffer);
template<typename T> void func3(const T &stu);
template<typename T> void func4(T a);
template<typename T> void func5(T &a);
它们具体的调用形式为：
int name[20];
Student stu1("张华", 20, 96.5); //创建一个Student类型的对象
func1(12.5, 30); //Error
func2(name); //name的类型从 int [20] 换转换为 int *，所以 T 的真实类型为 int
func3(stu1); //非const转换为const，T 的真实类型为 Student
func4(name); //name的类型从 int [20] 换转换为 int *，所以 T 的真实类型为 int *
func5(name); //name的类型依然为 int [20]，不会转换为 int *，所以 T 的真实类型为 int [20]对于func1(12.5, 30)，12.5 的类型为 double，30 的类型为 int，编译器不知道该将 T 实例化为 double 还是 int，也不会尝试将 int 转换为 double，或者将 double 转换为 int，所以调用失败。
请读者注意 name，它本来的类型是int [20]：
1、对于func2(name)和func4(name)，name 的类型会从 int [20] 转换为 int *，也即将数组转换为指针，所以 T 的类型分别为 int * 和 int。
2、对于func5(name)，name 的类型依然为 int [20]，不会转换为 int *，所以 T 的类型为 int [20]。
可以发现，当函数形参是引用类型时，数组不会转换为指针。这个时候读者要注意下面这样的函数模板：
template<typename T> void func(T &a, T &b);
如果它的具体调用形式为：
int str1[20];
int str2[10];
func(str1, str2);
由于 str1、str2 的类型分别为 int [20] 和 int [10]，在函数调用过程中又不会转换为指针，所以编译器不知道应该将 T 实例化为 int [20] 还是 int [10]，导致调用失败。
为函数模板显式地指明实参（也就是具体的类型）
函数模板的实参推断是指「在函数调用过程中根据实参的类型来寻找类型参数的具体类型」的过程，这在大部分情况下是奏效的，但是当类型参数的个数较多时，就会有个别的类型无法推断出来，这个时候就必须显式地指明实参。
下面是一个实参推断失败的例子：
template<typename T1, typename T2> void func(T1 a)
{
T2 b;
}
func(10); //函数调用func() 有两个类型参数，分别是 T1 和 T2，但是编译器只能从函数调用中推断出 T1 的类型来，不能推断出 T2 的类型来，所以这种调用是失败的，这个时候就必须显式地指明 T1、T2 的具体类型。
「为函数模板显式地指明实参」和「为类模板显式地指明实参」的形式是类似的，就是在函数名后面添加尖括号< >，里面包含具体的类型。例如对于上面的 func()，我们要这样来指明实参：
func<int, int>(10);
显式指明的模板实参会按照从左到右的顺序与对应的模板参数匹配：第一个实参与第一个模板参数匹配，第二个实参与第二个模板参数匹配，以此类推。只有尾部（最右）的类型参数的实参可以省略，而且前提是它们可以从传递给函数的实参中推断出来。
对于上面的 func()，虽然只有 T2 的类型不能自动推断出来，但是由于它位于类型参数列表的尾部（最右），所以必须同时指明 T1 和 T2 的类型。对代码稍微做出修改：
template<typename T1, typename T2> void func(T2 a)
{
T1 b;
}
//函数调用
func<int>(10); //省略 T2 的类型
func<int, int>(20); //指明 T1、T2 的类型由于 T2 的类型能够自动推断出来，并且它位于参数列表的尾部（最右），所以可以省略。
显式地指明实参时可以应用正常的类型转换
上面我们提到，函数模板仅能进行「const 转换」和「数组或函数指针转换」两种形式的类型转换，但是当我们显式地指明类型参数的实参（具体类型）时，就可以使用正常的类型转换（非模板函数可以使用的类型转换）了。
例如对于下面的函数模板：
template<typename T> void func(T a, T b);
它的具体调用形式如下：
func(10, 23.5); //Error
func<float>(20, 93.7); //Correct
在第二种调用形式中，我们已经显式地指明了 T 的类型为 float，编译器不会再为「T 的类型到底是 int 还是 double」而纠结了，所以可以从容地使用正常的类型转换了。
709