max.hpp
/* The following code example is taken from the book * "C++ Templates - The Complete Guide" * by David Vandevoorde and Nicolai M. Josuttis, Addison-Wesley, 2002 * * (C) Copyright David Vandevoorde and Nicolai M. Josuttis 2002. * Permission to copy, use, modify, sell and distribute this software * is granted provided this copyright notice appears in all copies. * This software is provided "as is" without express or implied * warranty, and with no claim as to its suitability for any purpose. */ template <typename T> inline T const& max (T const& a, T const& b) { // if a < b then use b else use a return a < b ? b : a; }
使用max.hpp
/* The following code example is taken from the book * "C++ Templates - The Complete Guide" * by David Vandevoorde and Nicolai M. Josuttis, Addison-Wesley, 2002 * * (C) Copyright David Vandevoorde and Nicolai M. Josuttis 2002. * Permission to copy, use, modify, sell and distribute this software * is granted provided this copyright notice appears in all copies. * This software is provided "as is" without express or implied * warranty, and with no claim as to its suitability for any purpose. */ #include <iostream> #include <string> #include "max.hpp" int main() { int i = 42; std::cout << "max(7,i): " << ::max(7,i) << std::endl; double f1 = 3.4; double f2 = -6.7; std::cout << "max(f1,f2): " << ::max(f1,f2) << std::endl; std::string s1 = "mathematics"; std::string s2 = "math"; std::cout << "max(s1,s2): " << ::max(s1,s2) << std::endl; }
实际上，templates 会被编译两次：
1. 不实例化，只是对 template 程序代码进行语法检查以发现诸如「缺少分号」等等的语法错误。
2. 实例化时，编译器检查 template 程序代码中的所有调用是否合法，诸如「未获支持之函数调用」便会在这个阶段被检查出来。
这会导致一个严重问题：当 function template 被运用而引发实例化过程时，某些时候编译器需要用到template 的原始定义。一般情况下，对普通的（non-template）functions而言，编译和链接两步骤是各自独立的，编译器只检查各个functions的声明语句是否和调用语句相符，然而template 的编译破坏了这个规则。
2.2 自变量推导（Argument Deduction）
当我们使用某一类型的自变量调用 max()时，template parameters 将以该自变量类型确定下来。
如果 我们针对参数类型 T const& 传递两个 ints，编译器必然能够推导出 T 是int。注意这里并不允许「自动类型转换」。是的，每个T 都必须完全匹配其自变量。例如：
template <typename T> inline T const& max(T const& a, T const& b); ... max(4, 7); // OK，两个 T 都被推导为 int max(4, 4.2); // 错误：第一个 T 被推导为 int，第二个 T 被推导为 double
有三种方法可以解决上述问题：
1. 把两个自变量转型为相同类型：
max(static_cast<double>(4), 4.2); // OK 2. 明确指定 T 的类型： max<double>(4, 4.2); // OK 3. 对各个 template parameters 使用不同的类型（译注：意思是不要像上面那样都叫做 T）。 下一节详细讨论这些问题。
2.3 Template Parameters（ 模 板参 数 ）
Function templates 有两种参数：
1. Template parameters（模板参数），在function template 名称前的一对角（尖）括号中声明：
template <typename T> // T 是个 template parameter
2. Call parameters（调用参数），在 function template 名称后的小（圆）括号中声明：
... max (T const& a, T const& b); // a 和 b 是调用参数
template parameters 的数量可以任意，但你不能在 function templates 中为它们指定预设自变量值（这一点与 class templates 不同）。例如你可以在 max()template 中定义两个不同类型的调用参数：
template <typename T1, typename T2> inline T1 max (T1 const& a, T2 const& b) { return a < b ? b : a; } ... max(4, 4.2); // OK。返回类型和第一自变量类型相同
这似乎是一个可以为 max()template 的参数指定不同类型的好办法，但它也有不足。问题在于你必须声明返回值的类型。如果你使用了其中一个类型，另一个类型可能被转型为该类型。C++ 没有提供一个机制用以选择「效力更大的类型, the more powerful type」（然而你可以藉由某些巧妙的template 编程手段来提供这种机制，参见 15.2.4 节）。因此，对于42和66.66两个调用自变量，max()的返回值要么是double 66.66，要么是int 66。另一个缺点是，把第二参数转型为第一参数的类型，会产生一个局部临时对象（local temporary object），因而无法以by reference 方式传回结果。因此在本例之中，返回类型必须是 T1，不能是 T1 const&。
由于call parameters 的类型由template parameters 建立，所以两者往往互相关联。我们把这种概念称为 function template argument deduction（函数模板自变量推导）。它使你可以像调用一个常规（意即 non-template）函数一样来调用 function template。
然而正如先前提到的那样，你也可以「明确指定类型」来实例化一个 template：
template <typename T> inline T const& max (T const& a, T const& b); ... max<double>(4,4.2); // 以 double 类型实例化 T
当template parameters和call parameters之间没有明显联系，而且编译器无法推导出template arameters 时，你必须明确地在调用时指定template arguments。例如你可以为max()引入第三个template argument type 作为返回类型：
template <typename T1, typename T2, typename RT> inline RT max (T1 const& a, T2 const& b);
然而「自变量推导机制」并不对返回类型进行匹配，而且上述的RT 也并非函数调用参数（call parameters）中的一个；因此编译器无法推导出 RT。你不得不像这样明确指出 template arguments：
template <typename T1, typename T2, typename RT> inline RT max (T1 const& a, T2 const& b); ... max<int,double,double>(4, 4.2); // OK，但是相当冗长（译注：因为其实只需明写第三自变量类型，却连前两个自变量类型都得写出来）
以上我们所看到的是，要么所有function template arguments 都可被推导出来，要么一个也推导不出来。另有一种作法是只明确写出第一自变量，剩下的留给编译器去推导，你要做的只是把所 有「无法被自动推导出来的自变量类型」写出来。因此，如果把上述例子中的参数顺序改变一下， 调用时就可以只写明返回类型：
template <typename RT, typename T1, typename T2> inline RT max (T1 const& a, T2 const& b); ... max<double>(4,4.2); // OK，返回类型为 double
此例之中，我们调用 max()时，只明确指出返回类型RT 为double，至于T1 和T2 两个参数类型会被编译器根据调用时的自变量推导为int 和 double。注意，这些max()修改版本并没带来什么明显好处。在「单一参数」版本中，如果两个自变量的 类型不同，你可以指定参数类型和回返值类型。总之，为尽量保持程序代码简单，使用「单一参 数」的 max()是不错的主意。讨论其它 template 相关问题时，我们也会遵守这个原则。
2.4 重载（Overloading）Function Templates
就像常规（意即non-template）functions一样，function templates 也可以被重载（译注：C++标准库中的许多STL算法都是如此）。这就是说，你可以写出多个不同的函数定义，并使用相同的函数名称；当客户调用其中某个函数时，C++编译器必须判断应该调用哪一个函数。即使不牵扯templates，这个推断过程也非常复杂。本节讨论的是，一旦涉及templates，重载将是一个怎样的过程。
/* The following code example is taken from the book * "C++ Templates - The Complete Guide" * by David Vandevoorde and Nicolai M. Josuttis, Addison-Wesley, 2002 * * (C) Copyright David Vandevoorde and Nicolai M. Josuttis 2002. * Permission to copy, use, modify, sell and distribute this software * is granted provided this copyright notice appears in all copies. * This software is provided "as is" without express or implied * warranty, and with no claim as to its suitability for any purpose. */ // maximum of two int values inline int const& max (int const& a, int const& b) { return a < b ? b : a; } // maximum of two values of any type template <typename T> inline T const& max (T const& a, T const& b) { return a < b ? b : a; } // maximum of three values of any type 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); // calls the template for three arguments ::max(7.0, 42.0); // calls max<double> (by argument deduction) ::max('a', 'b'); // calls max<char> (by argument deduction) ::max(7, 42); // calls the nontemplate for two ints ::max<>(7, 42); // calls max<int> (by argument deduction) ::max<double>(7, 42); // calls max<double> (no argument deduction) ::max('a', 42.7); // calls the nontemplate for two ints }
这个例子说明：non-template function 可以和同名的 function template 共存，也可以和其相同类型的具现体共存。当其它要素都相等时，重载解析机制会优先选择 non-template function，而不选择由 function template 实例化后的函数实体。上述第四个调用便是遵守这条规则：
::max(7, 42); // 两个自变量都是 int，吻合对应的 non-template function
但是如果可由 template 产生更佳匹配，则 template 具现体会被编译器选中。前述的第二和第三个调用说明了这一点：
::max(7.0, 42.0); // 调用 max<double>（经由自变量推导） ::max('a', 'b'); // 调用 max<char>（经由自变量推导）
调用端也可以使用空的 template argument list，这种形式告诉编译器「只从 template 具现体中挑选适当的调用对象」，所有template parameters 都自call parameters 推导而得：
::max<>(7, 42); // 调用 max<int>（经由自变量推导）
另外，「自动类型转换」只适用于常规函数，在templates 中不予考虑，因此前述最后一个调用调用的是 non-template 函数。在该处，'a' 和 42.7 都被转型为 int：
::max('a', 42.7); // 本例中只有 non-template 函数才可以接受两个不同类型的自变量
下面是一个更有用的例子，为指针类型和 C-style 字符串类型重载了 max()template：
/* The following code example is taken from the book * "C++ Templates - The Complete Guide" * by David Vandevoorde and Nicolai M. Josuttis, Addison-Wesley, 2002 * * (C) Copyright David Vandevoorde and Nicolai M. Josuttis 2002. * Permission to copy, use, modify, sell and distribute this software * is granted provided this copyright notice appears in all copies. * This software is provided "as is" without express or implied * warranty, and with no claim as to its suitability for any purpose. */ #include <iostream> #include <cstring> #include <string> // maximum of two values of any type template <typename T> inline T const& max (T const& a, T const& b) { return a < b ? b : a; } // maximum of two pointers template <typename T> inline T* const& max (T* const& a, T* const& b) { return *a < *b ? b : a; } // maximum of two C-strings inline char const* const& max (char const* const& a, char const* const& b) { return std::strcmp(a,b) < 0 ? b : a; } int main () { int a=7; int b=42; ::max(a,b); // max() for two values of type int std::string s="hey"; std::string t="you"; ::max(s,t); // max() for two values of type std::string int* p1 = &b; int* p2 = &a; ::max(p1,p2); // max() for two pointers char const* s1 = "David"; char const* s2 = "Nico"; ::max(s1,s2); // max() for two C-strings }
注意，所有重载函数都使用by reference方式来传递自变量。一般说来，不同的重载形式之间最好只存在「绝对必要的差异」。各重载形式之间应该只存在「参数个数的不同」或「参数类型 的明确不同」，否则可能引发各种副作用。举个例子，如果你以一个「by value 形式的 max()」重载一个「by reference 形式的 max()」（译注：两者之间的差异不够明显），就无法使用「三自变量」版本的 max()来取得「三个 C-style 字符串中的最大者」：
/* The following code example is taken from the book * "C++ Templates - The Complete Guide" * by David Vandevoorde and Nicolai M. Josuttis, Addison-Wesley, 2002 * * (C) Copyright David Vandevoorde and Nicolai M. Josuttis 2002. * Permission to copy, use, modify, sell and distribute this software * is granted provided this copyright notice appears in all copies. * This software is provided "as is" without express or implied * warranty, and with no claim as to its suitability for any purpose. */ #include <iostream> #include <cstring> #include <string> // maximum of two values of any type (call-by-reference) template <typename T> inline T const& max (T const& a, T const& b) { return a < b ? b : a; } // maximum of two C-strings (call-by-value) inline char const* max (char const* a, char const* b) { return std::strcmp(a,b) < 0 ? b : a; } // maximum of three values of any type (call-by-reference) template <typename T> inline T const& max (T const& a, T const& b, T const& c) { return max (max(a,b), c); // error, if max(a,b) uses call-by-value } int main () { ::max(7, 42, 68); // OK const char* s1 = "frederic"; const char* s2 = "anica"; const char* s3 = "lucas"; ::max(s1, s2, s3); // ERROR }
本例中针对三个 C-style 字符串调用 max()，会出现问题。以下这行述句是错误的：
return ::max (::max(a,b), c);
因为C-style字符串的max(a,b)重载函数创建了一个新而暂时的区域值（a new, temporary local value），而该值却以 by reference 方式被传回（那当然会造成错误）。
这只是细微的重载规则所引发的非预期行为例子之一。当函数调用动作发生时，如果不是所有重载形式都在当前范围内可见，那么上述错误可能发生，也可能不发生。事实上，如果把「三自变量」版本的 max()写在接受两个ints的max()前面（于是后者对前者而言不可见），那么在调用「三自变量」max()时，会间接调用「双自变量」max() function template：
/* The following code example is taken from the book * "C++ Templates - The Complete Guide" * by David Vandevoorde and Nicolai M. Josuttis, Addison-Wesley, 2002 * * (C) Copyright David Vandevoorde and Nicolai M. Josuttis 2002. * Permission to copy, use, modify, sell and distribute this software * is granted provided this copyright notice appears in all copies. * This software is provided "as is" without express or implied * warranty, and with no claim as to its suitability for any purpose. */ // maximum of two values of any type template <typename T> inline T const& max (T const& a, T const& b) { return a < b ? b : a; } // maximum of three values of any type template <typename T> inline T const& max (T const& a, T const& b, T const& c) { return max (max(a,b), c); // uses the template version even for ints } // because the following declaration comes // too late: // maximum of two int values inline int const& max (int const& a, int const& b) { return a < b ? b : a; }
就目前而言，你应该遵循一条准则：总是把所有形式的重载函数写在