【函数模板】

函数模板是那些被参数化的函数，它们代表的是一个函数家族

1.1 初探函数模板

函数模板提供了一种函数行为，该函数行为可以用多种不同的类型进行调用；也就是说，函数模板代表一个函数家族。

template<typename T>
inline T const& max(T const& a, T const& b)
{
     // 如果 a < b ，那么返回b，否则返回a
    return a < b ? b : a;
}

类型参数是T，它表示调用者调用这个函数时所指定的任意类型。你可以使用任何类型来实例化类型参数，只要所用类型提供模板使用的操作就可以。
例如，max模板函数中，类型T就需要支持operator<，因为a和b就是使用这个运算符来比较大小的。

通常而言，并不是把模板编译成一个可以处理任何类型的单一实体；而是对于实例化模板参数的每种类型，都从模板产生出一个不同的实体。因为所有语言的规则都是以“产生出不同实体”这个概念为基础的。

int i = 42;
...max(7,i);
/// 使用int作为模板参数T的函数模板。因此具有调用如下代码的语义
inline int const& max(int const&a, int const& b)
{
    //
    return a < b ? b : a;
}

这种用具体类型代替模板参数的过程叫实例化(instantiation)。只要调用函数模板，编译器就会自动地引发这样一个实例化过程。

如果基于一个不支持模板内部所使用操作的类型实例化一个模板，那么将会导致一个编译期错误：

std::complex<float> c1,c2; // std::complex并不支持 operator <
max(c1, c2); // 编译器错误

模板被编译两次：

1. 实例化前，编译器检查模板代码本身，查看语法是否正确；在这里会发现错误的语法如遗漏分号等。
2. 在实例化期间，检查模板代码，查看是否所有的调用都有效或者实例化参数是否支持所有模板的操作。这里会发现无效的调用，如实例化类型不支持某些函数调用等。
   这里给实际模板处理带来一个很严重的问题：当使用函数模板，并且引发模板实例化的时候，编译器需要查看模板的定义。这不同于普通函数编译链接，因为普通函数只要有声明，就可以顺利通过编译。
   也就是说声明和定义可以在不同的文件中(声明在.h, 定义在.cpp中), 模板这里需要把声明和定义放在同一个文件中，这样编译器在编译阶段才能查看所有模板操作。

1.2 实参演绎

当我们为某些实参调用一个类似max()的模板时，模板参数，也就是T，可以通过我们所传递给max的实参来决定。

1.3 模板参数

函数模板有两种类型的参数：
模板参数和调用参数。

你可以根据需要声明任意数量的模板参数。然而，在函数模板内部，不能指定缺省的模板实参。例如你可以定义两个调用参数的类型不同的max()模板：

template<typename T1, typename T2>
inline T1 max(T1 const& a, T2 const& b)
{
    return a < b ? b : a;
}

这样看起来是一种能够给max()模板传递两个不同类型调用参数的好方法，但在这个例子中，这种方法是有缺点的。主要问题是：必须声明返回类型。

返回类型，如果你使用的是其中一个参数类型，那么另一个参数的实参就可能要转换为返回类型，而不会在意调用者的意图。C++并没有提供一种"指定并且选择一个强大类型的途径“。于是，取决于调用实参的顺序，42和66.66的最大值可以是66.66，也可以是66.

另一个缺点：把第二个参数类型转换为第一个参数类型的过程将会创建一个新的局部临时对象，者导致了你不能通过引用来返回结果，因此这里的返回类型必须是T1，而不能是T1 const&。

因为调用参数的类型构造自模板参数，所以模板参数和调用参数通常是相关的。这个概念就是函数模板的实参演绎。
它让你可以像调用普通函数那样调用函数模板。

然而针对某些特定的类型，你还可以显示地实例化该模板：

template<typename T>
inline T const& max(T const& a, T const& b)
...
max<double>(4, 4.2); // 用double来实例化T

当模板参数和调用参数没有发生关联，或者不能由调用参数来决定模板参数的时候，你在调用时就必须显式指定模板参数。例如，你可以引入第三个模板实参类型，来定义函数模板的返回类型：

template<typename T1, typename T2, typename RT>
iinline RT max(T1 const& a, T2 const& b);

但是模板实参演绎并不适合返回类型，因为RT不会出现在函数调用参数的类型里面。因此，函数调用并不能演绎出RT。于是，你必须显式地指定模板实参列表：

template<typename T1, typename T2, typename RT>
inline RT max(T1 const& a, T2 const& b);

....

max(int, double, double)(4 , 4.2); // 这样可以，但是很麻烦

只显式指定第一个实参，而让演绎过程自己推导出其余的实参。通常而言，你必须指定"最后一个不能被隐式演绎的模板实参之前的"所有实参类型。因此，在上面的例子里，如果你改变模板参数的声明顺序，那么调用者就只需要指定返回类型：

template<typename RT, typename T1, typename T2>
inline RT max(T1 const& a, T2 const& b);

....

max<double>(4, 4.2); // 这样就看起来不是那么麻烦了

1.4 重载函数模板

函数模板的重载，相同的函数名可以具有不同的函数定义，这样当使用函数名进行函数调用的时候，C++编译器必须决定究竟要调用哪个候选函数。
在此之前，先了解一下不含模板的函数重载基本规则。

下面的简短程序描述了如何重载一个函数模板：

// 求两个int值得最大值
inline int const& max(int const& a, int const& b)
{
    return a < b ? b : a;
}

// 求两个任意类型值中的最大值
template<typename T>
inline T const& max(T const& a, T const& b)
{
    return a < b ? b : a;
}

// 求三个任意类型值中的最大值
template<typename T>
inline T const& max(T const& a, T const& b, T const& c)
{
    return ::max(::max(a, b), c);
}

int main () 
{
    ::max(7, 42, 68); // 调用具有3个参数的模板函数
    ::max(7.0, 42.0); // 调用max<double> （通过实参演绎）
    ::max('a', 'b');  // 调用max<char> （通过实参演绎）
    ::max(7, 42);     // 调用int重载的非模板函数
    ::max<>(7, 42);   // 调用max<int> (通过实参演绎)
    ::max<double>(7, 42); // 调用max<double> (没有实参演绎)
    ::max('a', 42.7);   // 调用int重载的非模板函数
}