模板实参推断：对于函数模板，编译器利用调用中的函数实参来确定模板参数，从函数实参来确定模板参数的过程被称为模板实参推断。
类型转换与模板类型参数
与往常一样，顶层const无论在形参中还是在是实参中，都被会忽略。
• const转换：可以将一个非const对象的引用（或指针）传递给const的引用（或指针）形参。
• 数组或函数指针转换：一个数组实参可以转换为一个指向其首元素的指针。类似的，一个函数实参可以抓转换一个该函数类型的指针。
template <typename T> T fobj(T, T) //实参被拷贝
template <typename T> T fret(const T&, const T&) //引用 string s1("a value");
const strng s2("another value");
fobj(s1, s2); //调用fobj(string, string); const被忽略
fret(s1, s2); //调用fret(const string&, const string&); const被忽略 int a[], b[];
fobj(a, b); //调用fobj(int*, int*);
fret(a, b); //错误
使用相同的模板参数类型的函数形参
一个模板类型形参可以用作多个函数形参的类型，由于只允许有限的几种类型转换，因此传递给这些形参的参数必须具有相同的类型。
template <typename T>
int compare(const T& v1, const T& v2)
{
if (v1 < v2) return -;
if(v2 > v1) return ;
return ;
} long lng;
compare(lng, ); //错误：不能实例化compare(long, int); template <typename A, typename B>
int compare(const A& v1, const B& v2) //实参类型不一样，但必须兼容
{
if (v1 < v2) return -;
if(v2 > v1) return ;
return ;
}
正常类型转化应用于普通函数实参
函数模板可以有用普通类型定义的参数，即，不涉及模板类型参数的类型，这种函数实参不进行特殊处理。
template <typename T>
ostream &print(ostream *os, const T &obj)
{
return os << obj;
} print(cout, ); //使用print(ostream &os, const int &obj);
ofstream f("output");
print(f, ); //使用print(ostream &os, const int &obj); 将f转换为ostream&
函数模板显示实参
在C++中，若函数模板返回类型需要用户指定，那么在定义函数模板时，模板参数的顺序是很重要的，如下代码：
template <typename T1, typename T2, typename T3> //模板一
T1 sum(T2 a, T3 b)
{
return a + b;
}
在调用的时候就需要指定T1的类型，如：sum<float>(1,2);于是sum函数的返回类型为float。
但是有时候由于设计者的糟糕设计，会导致一些问题：
template <typename T1, typename T2, typename T3> //模板二
T3 sum(T1 a, T2 b)
{
return a + b;
}
那么再进行上述调用，则会出现问题：sum<float>(1, 2);现在这个调用里指定T1类型为float,但是实际传进来的是1（int类型），会进行隐式类型转换，将1转换为float；T2的类型也可以根据sum(1,2)调用的第二个实参推断出来，这里是可能会是int。那么T3是什么类型呢？显然这里编译器无法推断T3的类型，需要在调用时指定才能推断：
sum<int, int, int>(1, 2)，这样T3就推断出来是int。
在指定显示模板实参时指定的类型是和模板参数匹配的，顺序是一一对应的，如：
- 使用sum<int>(1, 2)对上面的第一个模板进行调用，那么T1对应int，T2和T3则通过推断得出。
- 使用sum<int>(1, 2)对上面的第二个模板进行调用，那么T1对应的类型是int，T2可以根据实际穿进去的参数进行推断，这里2为int那么T2类型就是int，那么编译器就无法知道T3的实际类型了。
尾置返回类型与类型转换
函数指针和实参推断
转发
某些函数需要将一个或多个实参连同类型不变地转发给其他函数。在次情况下，我们需要保持被转发实参的所有性质，包括实参类型是否是const的以及实参是左值还是右值。
//接受一个可调用对象和另外两个参数的模板
template <typename F, typename T1, typename T2>
void flips(F f, T1 t1, T2 t2)
{
f(t2, t1)
} void f(int v1, int &v2) //注意v2是一个引用
{
cout << v1 << " " << ++t2 << endl;
} f(, i); //f改变了实参i
flip1(f, j, ); //通过flip1调用不会改变j
// void flip1(void(*fcn)(int, int&), int ti, int t2);
定义能保持类型信息的函数参数
template <typename F, typename T1, typename T2>
void flips(F f, T1 &&t1, T2 &&t2)
{
f(t2, t1)
} void f(int v1, int &v2) //注意v2是一个引用
{
cout << v1 << " " << ++t2 << endl;
} flip1(f, j, );
template <typename F, typename T1, typename T2>
void flips(F f, T1 &&t1, T2 &&t2)
{
f(t2, t1)
} void g(int &&v1, int &v2)
{
cout << v1 << " " << ++t2 << endl;
} flip1(g, j, ); //错误：不能从一个左值实例化int&&
在调用中使用std::forward保持类型信息
• forward定义在头文件utility中，与move不同，forward必须显式模板来调用。
• foeward返回该类型显式实参类型的右值引用，即，forward<T>的返回类型是T&&。
template <typename F, typename T1, typename T2>
void flips(F f, T1 &&t1, T2 &&t2)
{
f(t2, t1)
} void g(int &&v1, int &v2)
{
cout << v1 << " " << ++t2 << endl;
} flip1(f, j, ); //错误：不能从一个左值实例化int&& 修改为： template <typename F, typename T1, typename T2>
void flips(F f, T1 &&t1, T2 &&t2)
{
f(std::forward<T2> (t2), std::forward<T1> (t1))
} void g(int &&v1, int &v2)
{
cout << v1 << " " << ++t2 << endl;
} flip1(f, j, ); //i将以int&类型传递给g，42将以in&&类型传递给g