看到关于模版很好的一篇总结，转载下，便于查阅。不过最后静态断言的例子，我没能编译通过，待研究。
独一无二的C++模板 (1) 收藏
断断续续地看了《C++Templates》很长时间，在叹服于模板的神奇之余，也不得不承认这是一块充满陷阱的湿地。每次想要动手神奇一把，都会被某编译错误给无情地挡回；看英文似的，水平不够，只能“读得懂，写不出”；成了饥饿的小白鼠，远处放着奶酪，近处却是一鼠夹。此次总结，希望把最近的模板实践都剖析出要点，避免再犯相同的错误。
模板的魅力
当前，对于多数C++程序员来说，模板常常意味着类型的简单替换。例如：
- template<typename T>
- T max(T const & a, T const & b)
- {
- return (a>b)?a:b;
- }
或 std::vector<T> 这样的用法。诚然，这是一种编程模式：一些类、函数、代码，宏观上的操作是相同的，不同的仅是被操作的类型，于是把类型特别提出来用一记号表示，并由template关键字声明，成为一通用的类、函数、代码；使用时，只要把特定的类型代替进去即可。在很多支持泛型的语言中，如C#、Java等等，模板就是这样用的。但是，读过《C++ Templates》或《Modern C++ Design》或《C++ Template Metaprogramming》的朋友都知道，C++的模板，包含的内容更多，功能也更为强大。
对于C++模板精髓，我想主要是SFINAE（Substitution failure is not an error）原则。SFINAE原则意味着，函数实例若不能匹配某个函数模板，这不算编译错误，还可以尝试去匹配其它函数模板。这个保护性的原则，提高了函数模板的重载能力，进而使得编译时类型推导成为可能。如下面的代码
- #include <cstdio>
- template<typename C> char check(int C::*);
- template<typename T> float check(...);
- template<typename T>
- bool IsClassType() {
- return sizeof(check<T>(0))==1 ;
- };
- class One;
- int main()
- {
- printf("Is A Class Type %d\n",IsClassType<std::size_t>());
- printf("Is A Class Type %d\n",IsClassType<One>());
- return 0;
- }
对于模板template<typename C> char check(int C::*)，只有当C类型为类时，才可能有int C::* 这样的类型（表示一个指针，指向C类的某int型成员），这样才能匹配此模板。而对于template<typename T> float check(...)，可匹配任意类型的T。所以当check<int>(0)不能匹配前者时，它会匹配后者，从而使IsClassType能得到正确的结果。利用SFINAE原则，可以做很多类型推导：判断一个类型是否为某类型或某类类型（如判断T是否为class类型），类型是否相等（T1与T2是否为同一类型），类型选择（根据某类型，选择T1类或T2类），判断两类型是否有继承关系等等。
模板的另一重要特性为静态性。这点是指模板的实例化是编译时进行时，程序运行时，已经是模板实例的结果了。利用这一点，可以优化代码。如上面的程序中，计算IsClassType<One>()，实际上已经在编译时计算完毕了，在程序中，直接替代为true；而不是在程序运行进再根据T的类型，重新计算sizeof(check<T>(0))是否等于1。再看一个例子，这程序显示了模板的计算能力（当然，这些计算都是编译时进行了；程序运行时，就能直接输出结果了；具体原理说明见此）：
- #include <iostream>
- template<int N>
- class Pow3 {
- public:
- enum { result=3*Pow3<N-1>::result };
- };
- template<>
- class Pow3<0> {
- public:
- enum { result = 1 };
- };
- int main()
- {
- std::cout << "Pow3<7>::result = " << Pow3<7>::result
- << '\n';
- }
模板的分类与使用
模板分为函数模板和类模板，有着显著的不同！不能因为两者都能进行类型替换（最主要的能力），而认为两者都差不了多少。在细节上，正是这些差异，使我写出模板常常不能顺利地通过编译器编译。
函数模板，一般的形式为：
template<typname T>
RetType fun(T t);
而类模板，一般形式为：
template<typename T>
class MyClass;
函数模板的模板参数，不能有默认值（目前标准是这样），而类模板可以有；函数模板可以重载，重载的方式很多；但类模板是不能重载的，只能有一个基本模板。
对于第一个差异，常常出现的问题是，使用多了stl::vector<T, Allocate = std::allocate<T> >，也认为函数模板也能带默认的参数。而事实是，目前的标准里不允许这样，虽然编译器实现这个功能并不困难；而对待这样的语法错误，不同的编译器会给出不同的信息，其中VC给的信息非常不助于解决问题----“默认模板参数应该是出现在类模板中”，gcc则直接指出了“函数模板不能有默认参数”。
对于第二个差异，实际上是体现了类模板与函数模板发挥作用的不同方式：函数模板走的是“重载路线”，而类模板走的是“特化路线”。这两种方式所体现的，正是C++模板不同于普通泛型（类型替换）的特别之处。
重载函数模板
函数模板实际表式的是一系列逻辑相似的函数族。例如前面的T max(T const&, T const &)函数模板。当代码上求max(1,2)时，编译器根据参数1,2的类型，推断出T为int，从而产生了一个函数int max(int const &, int const&)。这个过程叫做函数模板的实参演绎。当出现函数模板重载的情况时，如：
- #include <cstdio>
- template<typename T>
- int fun(T)
- {
- return 1;
- }
- template<typename T>
- int fun(T*)
- {
- return 2;
- }
- int main()
- {
- int a=10;
- printf("%d\n",fun(a));
- printf("%d\n",fun(&a));
- return 0;
- }
输出结果为1,2。这个例子表明，对于函数模板，编译器会根据参数的类型，去选择最适合的函数。这个“最适合”往往是对参数限制得最多的一种选择。这也是之前对于类类型的One，check函数模板会被选择为char check(int C::*)的原因。
(chg注，在编译过程，实参演绎，选择好最匹配的函数后会实例化，如果实例化过程中出现错误，如有实参不支持的操作，会编译报错。即使存在次匹配的函数，如果用次匹配函数实例化不会出错也还是会实例化最匹配的函数，即使它内部有该实参不支持的操作。另外只要没有被实例话编译生成实际代码，而如果最匹配的函数实例化成功，那么对于次匹配函数假设用该实参实例化它会出差（有实参不支持的操作）也没关系，因为只要它没有被实例化使用，就不会出错)
再举一个详细点的例子：对于自定义的list和vector两种数据结构，两者有基本相同的外部接口；但前者由链表实现，后者由数组实现，能支持随机访问；具体说来，这两者使用的迭代器不同，一个是bi_iterator（双向访问），一个是random_iterator（随机访问）。因此，要对list进行排序，要使用一种支持双向迭代器的方法link_sort()，而对于vector有更高效的quick_sort()，它仅支持随机访问迭代器。现在希望能统一接口，实现一sort函数，可以接受list和vector两种类型（stl里还有其它类型）的容器。代码如下：
- class bi_iterator;
- class random_iterator;
- class list
- {
- public:
- typedef bi_iterator iterator;
- iterator begin();
- iterator end();
- };
- class vector
- {
- public:
- typedef random_iterator iterator;
- iterator begin();
- iterator end();
- };
- template<typename container>
- void sort(container &c)
- {
- typename container::iterator tag;
- _sort_select(c, tag);
- }
- template<typename container>
- void _sort_select(container &c, bi_iterator & tag)
- {
- link_sort(c.begin(), c.end());
- }
- template<typename container>
- void _sort_select(container &c, random_iterator & tag)
- {
- quick_sort(c.begin(), c.end());
- }
这同样是函数重载的例子，编译器根据_sort_select()的第二个参数tag，确定调用的是那一个函数模板，再生成相应的函数实例。上面的代码中，tag的值是多少其实并不重要，有用的是tag的类型，编译器据此来判断选择哪一个函数模板。编译后，tag被优化掉，并没有在程序中占用空间。（注意：typename container::iterator tag这一句里的关键字typename是用于强调iterator是模板参数container里的一个类型，避免一些语法上的起义发生。）
当然，为统一接口，还可以给list,vector都添加sort()方法。
特化类模板
特化是指通使用指定的模板实参来特殊化一个类，目标常常是优化基于某些类型的类实现。
例如
- template <typename T, int N> // 基本模板
- stack
- {
- public:
- void push(T const & t);
- T pop();
- T const & top();
- private:
- T elements[N];
- };
- template<int N>
- stack<string, N> // 局部特化
- {
- public:
- void push(string const & t);
- string pop();
- string const & top();
- private:
- string elements[N];
- };
stack<T,N>是一个栈的类模板，T表示元素的类型，N表示栈的大小（整数可以做为模板参数）。对于一个字符串string的栈，我们期待更优化的实现。所以可以把T特化成具体的类型string，重新实现此模板（包括方法和成员）。由于这里只特化了一个模板参数，因此叫局部特化。
前面编译时计算Pow3的例子，也是类模板特化的例子：计算是递归进行的，计算Pow3<N>::result，需要先得到Pow3<N-1>::result；而最后的边界条件是通过特化得到的，即Pow3<0>::result=1。
下面再看一个特化的例子：
- template<typename T1, typename T2> // 基本模板
- struct IsSameType
- {
- enum {result = false};
- };
- template<typename T>
- struct IsSameType<T,T> //特化为T1=T2=T
- {
- enum {result = true};
- };
此例中：IsSameType<T1, T2>::result 的值表征了T1,T2两个类型是否为同一类型。
如果基本模板的成员不完整，而特化的模板却是完整的类模板，这样又能起另一作用：
- #define StaticAssert(X) \
- { \
- Assert< (X) > assert; \
- }
- template<bool condition>
- struct Assert;
- template<>
- struct Assert<true>
- {
- };
可以看到，类模板template<bool condition>struct Assert只有声明（bool值也可以做为模板参数的实参），没有定义，而struct Assert<true>是有定义的。这就意味着，如果定义变量 Assert<false> v，则会得到一个编译错误。利用这种有缺陷的类模板，我们得到了一个静态断言StaticAssert。组合上面的代码，我们可以写出这样一个max的函数模板：
- template<typename T>
- T max(T & t1, T & t2)
- {
- StaticAssert( !IsClassType<T>() )
- return (t1>t2)?t1:t2;
- }
这个max()，要求T类型不能是类类型。因为若T为类，t1，t2可能是大对象，像代码中那样直接返回大对象是非常低效的。
注意：函数模板也可以特化，这与类模板特化是基本一致的。但在强大的实参演绎机制与重载机制前面，函数模板的特化往往不被提及