说起C++的模板及模板特化， 相信很多人都很熟悉 ，但是说到模板特化的几种类型，相信了解的人就不是很多。我这里归纳了模板特化的几种类型， 一是特化为绝对类型； 而是特化为引用，指针类型；三是特化为另外一个模板类。

这里用一个简单的例子来说明这三种情况：
// general version
template<class T>
class Compare
{
public:
    static bool IsEqual(const T& lh, const T& rh)
    {
        return lh == rh;
    }
};

这是一个用于比较的模板类，里面可以有多种用于比较的函数， 以IsEqual为例。
 
一、特化为绝对类型

也就是说直接为某个特定类型做特化，这是我们最常见的一种特化方式， 如特化为float, double等
// specialize for float
template<>
class Compare<float>
{
public:
    static bool IsEqual(const float& lh, const float& rh)
    {
        return abs(lh - rh) < 10e-3;
    }
};

// specialize for double
template<>
class Compare<double>
{
public:
    static bool IsEqual(const double& lh, const double& rh)
    {
        return abs(lh - rh) < 10e-6;
    }
};

二、特化为引用，指针类型

这种特化我最初是在stl源码的的iterator_traits特化中发现的， 如下：
template <class _Iterator>
struct iterator_traits

{
  typedef typename _Iterator::iterator_category iterator_category;
  typedef typename _Iterator::value_type        value_type;
  typedef typename _Iterator::difference_type   difference_type;
  typedef typename _Iterator::pointer           pointer;
  typedef typename _Iterator::reference         reference;
};

// specialize for _Tp*
template <class _Tp>
struct iterator_traits<_Tp*>

{
  typedef random_access_iterator_tag iterator_category;
  typedef _Tp                         value_type;
  typedef ptrdiff_t                   difference_type;

typedef _Tp*                        pointer;
  typedef _Tp&                        reference;
};

// specialize for const _Tp*
template <class _Tp>
struct iterator_traits<const _Tp*>

{
  typedef random_access_iterator_tag iterator_category;
  typedef _Tp                         value_type;
  typedef ptrdiff_t                   difference_type;
  typedef const _Tp*                  pointer;
  typedef const _Tp&                  reference;
};

当然，除了T*, 我们也可以将T特化为 const T*, T&, const T&等，以下还是以T*为例：
// specialize for T*
template<class T>
class Compare<T*>
{
public:
    static bool IsEqual(const T* lh, const T* rh)
    {
        return Compare<T>::IsEqual(*lh, *rh);
    }
};

这种特化其实是就不是一种绝对的特化， 它只是对类型做了某些限定，但仍然保留了其一定的模板性，这种特化给我们提供了极大的方便， 如这里， 我们就不需要对int*, float*, double*等等类型分别做特化了。

三、特化为另外一个模板类

这其实是第二种方式的扩展，其实也是对类型做了某种限定，而不是绝对化为某个具体类型，如下：
// specialize for vector<T>
template<class T>
class Compare<vector<T> >
{
public:
    static bool IsEqual(const vector<T>& lh, const vector<T>& rh)
    {
        if(lh.size() != rh.size())

return false;

       else
        {
            for(int i = 0; i < lh.size(); ++i)
            {
                if(lh[i] != rh[i]) return false;
            }
        }
        return true;
    }
};

这就把IsEqual的参数限定为一种vector类型， 但具体是vector<int>还是vector<float>， 我们可以不关心， 因为对于这两种类型，我们的处理方式是一样的，我们可以把这种方式称为“半特化”。

当然， 我们可以将其“半特化”为任何我们自定义的模板类类型：
// specialize for any template class type
template <class T1> 
struct SpecializedType
{
    T1 x1;
    T1 x2;
};

template <class T>
class Compare<SpecializedType<T> >
{
public:
    static bool IsEqual(const SpecializedType<T>& lh, const SpecializedType<T>& rh)
    {
        return Compare<T>::IsEqual(lh.x1 + lh.x2, rh.x1 + rh.x2);
    }
};

这就是三种类型的模板特化， 我们可以这么使用这个Compare类：
// int
    int i1 = 10;
    int i2 = 10;
    bool r1 = Compare<int>::IsEqual(i1, i2);

    // float
    float f1 = 10;
    float f2 = 10;
    bool r2 = Compare<float>::IsEqual(f1, f2);

    // double
    double d1 = 10;
    double d2 = 10;
    bool r3 = Compare<double>::IsEqual(d1, d2);

    // pointer
    int* p1 = &i1;
    int* p2 = &i2;

bool r4 = Compare<int*>::IsEqual(p1, p2);

    // vector<T>
    vector<int> v1;
    v1.push_back(1);
    v1.push_back(2);

    vector<int> v2;
    v2.push_back(1);
    v2.push_back(2);
    bool r5 = Compare<vector<int> >::IsEqual(v1, v2);

    // custom template class 
    SpecializedType<float> s1 = {10.1f,10.2f};
    SpecializedType<float> s2 = {10.3f,10.0f};
    bool r6 = Compare<SpecializedType<float> >::IsEqual(s1, s2);

    关于template一本很全面的介绍C++ Template的书在china-pub上可以找得到：http://www.china-pub.com/computers/common/info.asp?id=17709，也有中文翻译版本(哈哈，刚才看了一下，英文版缺货，中文版绝版，幸亏偶买的早)。

    如果再配合看这本：《Modern C++ Design: Generic Programming and Design Patterns Applied》http://www.china-pub.com/computers/common/info.asp?id=12302，这个也有中文版的，ms也是侯捷翻译的，不过我不喜欢他的风格。

    常用的C++ STL库就是template的一个很好的demo，这方面的书很多。《泛型编程与STL》http://www.china-pub.com/computers/common/info.asp?id=14364这本书貌似大家的评价不错，不过我没有看过，本来打算买，无奈囊肿羞涩，不过我还是决定省吃俭用买下来看看。《C++标准程序库——自修教程与参考手册》http://www.china-pub.com/computers/common/info.asp?id=7645，这本书全面的介绍STL的应用，这本书很适合做为参考手册用。又是侯捷翻译的，很贵，多贵？可以演一桌水浒了！！（这就是我为什么特烦他了，他的书都死贵，从这个角度上说我还是支持盗版）以前好几个师弟买了，我都蹭书看，呵呵。侯捷还自己写了一本《STL源码剖析》http://www.china-pub.com/computers/common/info.asp?id=6384，不过真相知道STL怎么回事，还是自己跟源代码最好。

    微软的ATL（Active Template Library）库也是一个很牛的demo，它比STL更难理解一点，不过基本的思想都差不多。《ATL技术内幕》（<ATL Internals>）是一本不错的书http://www.china-pub.com/computers/common/info.asp?id=12480，这本书可以让你知道ATL深层的机制，不是专门教你怎么用ATL开发的，比较好的ATL开发的书国内都没有，只有一些关于COM的书中零零星星的提到，很多年以前出过基本翻译的，不过早绝版了。Amazon上还有本叫《Inside ATL》微软出的http://www.amazon.com/gp/product/1572318589/qid=1137230246/sr=8-1/ref=pd_bbs_1/102-5612415-4809763?n=507846&s=books&v=glance，不过这本没看过，国内没有引进。要真正学会ATL还需要很多COM和Windows的基本知识，这就会掉到另两个更大的坑里面！

    另一个关于Template的是TMP(Template MetaProgramming)，关于TMP编程的一本好书是：《C++ Template Metaprogramming》http://www.amazon.com/gp/product/0321227255/qid=1114520696/sr=1-4/ref=sr_1_4/102-5612415-4809763?s=books&v=glance&n=283155，据说中文版由荣耀和侯捷翻译，06年将会出版，不过我觉得看英文的最好。TMP将C++的template技术发挥到了极致的境界，越看越觉得舒服，并且感慨：牛人都是怎么炼成的阿？

    其实，还是那句老话：“聪明在于学习，天才在于积累”，只是在寻寻觅觅中，忘记了最根本的。

　　本文描述了模板元编程技术的起源、概念和机制，并介绍了模板元编程技术在Blitz++和Loki程序库中的应用。
　　要害字
　　编译期计算 模板元编程 Blitz++ Loki
　　导言
　　1994年，C++标准委员会在圣迭哥举行的一次会议期间Erwin Unruh展示了一段可以产生质数的代码。这段代码的非凡之处在于质数产生于编译期而非运行期，在编译器产生的一系列错误信息中间夹杂着从2到某个设定值之间的所有质数：
// Prime number computation by Erwin Unruh
template <int i> strUCt D { D(void*); operator int(); };
template <int p, int i> struct is_prime {
enum { prim = (p%i) && is_prime<(i > 2 ? p : 0), i -1> :: prim };
};
template < int i > struct Prime_print {
Prime_print<i-1> a;
enum { prim = is_prime<i, i-1>::prim };
void f() { D<i> d = prim; }
};
struct is_prime<0,0> { enum {prim=1}; };
struct is_prime<0,1> { enum {prim=1}; };
struct Prime_print<2> { enum {prim = 1}; void f() { D<2> d = prim; } };
#ifndef LAST
#define LAST 10
#endif
main () {
Prime_print<LAST> a;
}
　　类模板D只有一个参数为void*的构造器，而只有0才能被合法转换为void*。1994年，Erwin Unruh采用Metaware 编译器编译出错信息如下（以及其它一些信息，简短起见，它们被删除了）：
Type `enum{}′ can′t be converted to tXPe `D<2>′ ("primes.cpp",L2/C25).
Type `enum{}′ can′t be converted to txpe `D<3>′ ("primes.cpp",L2/C25).
Type `enum{}′ can′t be converted to txpe `D<5>′ ("primes.cpp",L2/C25).
Type `enum{}′ can′t be converted to txpe `D<7>′ ("primes.cpp",L2/C25).
　　如今，上面的代码已经不再是合法的C++程序了。以下是Erwin Unruh亲手给出的修订版，可以在今天符合标准的C++编译器上进行编译：
// Prime number computation by Erwin Unruh
template <int i> struct D { D(void*); operator int(); };
template <int p, int i> struct is_prime {
enum { prim = (p==2) (p%i) && is_prime<(i>2?p:0), i-1> :: prim };
};
template <int i> struct Prime_print {
Prime_print<i-1> a;
enum { prim = is_prime<i, i-1>::prim };
void f() { D<i> d = prim ? 1 : 0; a.f();}
};
template<> struct is_prime<0,0> { enum {prim=1}; };
template<> struct is_prime<0,1> { enum {prim=1}; };
template<> struct Prime_print<1> {
enum {prim=0};
void f() { D<1> d = prim ? 1 : 0; };
};
#ifndef LAST
#define LAST 18
#endif
main() {
Prime_print<LAST> a;
a.f();
}
　　在GNU C++ (MinGW Special) 3.2中编译这段程序时，编译器将会给出如下出错信息（以及其它一些信息，简短起见，它们被删除了）：
Unruh.cpp:12: initializing argument 1 of `D<i>::D(void*) [with int i = 17]'
Unruh.cpp:12: initializing argument 1 of `D<i>::D(void*) [with int i = 13]'
Unruh.cpp:12: initializing argument 1 of `D<i>::D(void*) [with int i = 11]'
Unruh.cpp:12: initializing argument 1 of `D<i>::D(void*) [with int i = 7]'
Unruh.cpp:12: initializing argument 1 of `D<i>::D(void*) [with int i = 5]'
Unruh.cpp:12: initializing argument 1 of `D<i>::D(void*) [with int i = 3]'
Unruh.cpp:12: initializing argument 1 of `D<i>::D(void*) [with int i = 2]'
　　这个例子展示了可以利用模板实例化机制于编译期执行一些计算。这种通过模板实例化而执行的非凡的编译期计算技术即被称为模板元编程。
　　顺便说一句，因为编译器的出错信息并未被标准化，所以，假如你在Visual C++、Borland C++等编译器上看不到这么具体的出错信息，请不必讶异。
一个可以运行的模板元编程例子
　　模板元编程（Template Metaprogramming）更准确的含义应该是“编‘可以编程序的’程序”，而模板元程序（Template Metaprogram）则是“‘可以编程序的’程序”。也就是说，我们给出代码的产生规则，编译器在编译期解释这些规则并生成新代码来实现我们预期的功能。
　　Erwin Unruh的那段经典代码并没有执行，它只是以编译出错信息的方式输出中间计算结果。让我们来看一个可以运行的模板元编程例子 — 计算给定整数的指定次方：
// xy.h
//原始摸板
template<int Base, int Exponent>
class XY
{
public:
enum { result_ = Base * XY<Base, Exponent-1>::result_ };
};
//用于终结递归的局部特化版
template<int Base>
class XY<Base, 0>
{
public:
enum { result_ = 1 };
};
　　模板元编程技术之根本在于递归模板实例化。第一个模板实现了一般情况下的递归规则。当用一对整数<X, Y>来实例化模板时，模板XY<X, Y>需要计算其result_的值，将同一模板中针对<X, Y-1>实例化所得结果乘以X即可。第二个模板是一个局部特化版本，用于终结递归。
　　让我们看看使用此模板来计算5^4 （通过实例化XY<5, 4>）时发生了什么：
// xytest.cpp
#include <iostream>
#include "xy.h"
int main()
{
std::cout << "X^Y<5, 4>::result_ = " << XY<5, 4>::result_;
}
　　首先，编译器实例化XY<5, 4>，它的result_为5 * XY<5, 3>::result_，如此一来，又需要针对<5, 3>实例化同样的模板，后者又实例化XY<5, 2>…… 当实例化到XY<5, 0>的时候，result_的值被计算为1，至此递归结束。
　　递归模板实例化的深度和终结条件
　　可以想象，假如我们以非常大的Y值来实例化类模板XY，那肯定会占用大量的编译器资源甚至会迅速耗尽可用资源（在计算结果溢出之前），因此，在实践中我们应该有节制地使用模板元编程技术。
　　虽然 C++标准建议的最小实例化深度只有17层，然而大多数编译器都能够处理至少几十层，有些编译器答应实例化至数百层，更有一些可达数千层，直至资源耗尽。
　　假如我们拿掉XY模板局部特化版本，情况会如何？
// xy2.h
//原始摸板
template<int Base, int Exponent>
class XY
{
public:
enum { result_ = Base * XY<Base, Exponent-1>::result_ };
};
　　测试程序不变：
// xytest2.cpp
#include <iostream>
#include "xy2.h"
int main()
{
std::cout << "X^Y<5, 4>::result_ = " << XY<5, 4>::result_;
}
　　执行如下编译命令：
C:\>g++ -c xytest2.cpp
　　你将会看到递归实例化将一直进行下去，直到达到编译器的极限。
　　GNU C++ (MinGW Special) 3.2的默认实例化极限深度为500层，你也可以手工调整实例化深度：
C:\>g++ -ftemplate-depth-3400 -c xytest2.cpp
　　事实上，就本例而言，g++ 3.2答应的实例化极限深度还可以再大一些（我的测试结果是不超过3450层）。
　　因此，在使用模板元编程技术时，我们总是要给出原始模板的特化版（局部特化版或完全特化版或兼而有之），以作为递归模板实例化的终结准则。 利用模板元编程技术解开循环
　　模板元编程技术最早的实际应用之一是用于数值计算中的解循环。举个例子，对一个数组进行求和的常见方法是：
// sumarray.h
template <typename T>
inline T sum_array(int Dim, T* a)
{
T result = T();
for (int i = 0; i < Dim; ++i)
{
result += a[i];
}
return result;
}
　　这当然可行，但我们也可以利用模板元编程技术来解开循环：
// sumarray2.h
// 原始模板
template <int Dim, typename T>
class Sumarray
{
public:
static T result(T* a)
{
return a[0] + Sumarray<Dim-1, T>::result(a+1);
}
};
// 作为终结准则的局部特化版
template <typename T>
class Sumarray<1, T>
{
public:
static T result(T* a)
{
return a[0];
}
};
　　用法如下：
// sumarraytest2.cpp
#include <iostream>
#include "sumarray2.h"
int main()
{
int a[6] = {1, 2, 3, 4, 5, 6};
std::cout << " Sumarray<6>(a) = " << Sumarray<6, int>::result(a);
}
　　当我们计算Sumarray<6, int>::result(a)时，实例化过程如下：
Sumarray<6, int>::result(a)
= a[0] + Sumvector<5, int>::result(a+1)
= a[0] + a[1] + Sumvector<4, int>::result(a+2)
= a[0] + a[1] + a[2] + Sumvector<3, int>::result(a+3)
= a[0] + a[1] + a[2] + a[3] + Sumvector<2, int>::result(a+4)
= a[0] + a[1] + a[2] + a[3] + a[4] + Sumvector<1, int>::result(a+5)
= a[0] + a[1] + a[2] + a[3] + a[4] + a[5]
　　可见，循环被展开为a[0] + a[1] + a[2] + a[3] + a[4] + a[5]。这种直截了当的展开运算几乎总是比循环来得更有效率。
　　也许拿一个有着600万个元素的数组来例证循环开解的优势可能更有说服力。生成这样的数组很轻易，有爱好，你不妨测试、对比一下。
　　（感谢一位不知名的朋友的测试。他说：“据在Visual C++ 2003上实测编译器应当进行了尾递归优化，可以不受上面说的递归层次的限制，然而连加的结果在数组个数达到4796之后就不再正确了，程序输出了空行，已经出错” — 2003年12月30日补充） 模板元编程在数值计算程序库中的应用
　　Blitz++之所以“快如闪电”（这正是blitz的字面含义），离不开模板元程序的功劳。Blitz++淋漓尽致地使用了元编程技术，你可以到这些文件源代码中窥探究竟：
dot.h
matassign.h
matmat.h
matvec.h
metaprog.h
product.h
sum.h
vecassign.h
　　让我们看看Blitz++程序库dot.h文件中的模板元程序：
template<int N, int I>
class _bz_meta_vectorDot {
public:
enum { loopFlag = (I < N-1) ? 1 : 0 };
template<class T_expr1, class T_expr2>
static inline BZ_PROMOTE(_bz_typename T_expr1::T_numtype, _bz_typename T_expr2::T_numtype)
f(const T_expr1& a, const T_expr2& b)
{
return a[I] * b[I] + _bz_meta_vectorDot<loopFlag * N, loopFlag * (I+1)>::f(a,b);
}
template<class T_expr1, class T_expr2>
static inline BZ_PROMOTE(_bz_typename T_expr1::T_numtype, _bz_typename T_expr2::T_numtype)
f_value_ref(T_expr1 a, const T_expr2& b)
{
return a[I] * b[I] + _bz_meta_vectorDot<loopFlag * N, loopFlag * (I+1)>::f(a,b);
}
template<class T_expr1, class T_expr2>
static inline BZ_PROMOTE(_bz_typename T_expr1::T_numtype, _bz_typename T_expr2::T_numtype)
f_ref_value(const T_expr1& a, T_expr2 b)
{
return a[I] * b[I] + _bz_meta_vectorDot<loopFlag * N, loopFlag * (I+1)>::f(a,b);
}
template<class T_expr1, class P_numtype2>
static inline BZ_PROMOTE(_bz_typename T_expr1::T_numtype, P_numtype2)
dotWithArgs(const T_expr1& a, P_numtype2 i1, P_numtype2 i2=0,
P_numtype2 i3=0, P_numtype2 i4=0, P_numtype2 i5=0, P_numtype2 i6=0,
P_numtype2 i7=0, P_numtype2 i8=0, P_numtype2 i9=0, P_numtype2 i10=0)
{
return a[I] * i1 + _bz_meta_vectorDot<loopFlag * N, loopFlag * (I+1)>::dotWithArgs
(a, i2, i3, i4, i5, i6, i7, i8, i9);
}
};
template<>
class _bz_meta_vectorDot<0,0> {
public:
template<class T_expr1, class T_expr2>
static inline _bz_meta_nullOperand f(const T_expr1&, const T_expr2&)
{ return _bz_meta_nullOperand(); }
template<class T_expr1, class P_numtype2>
static inline _bz_meta_nullOperand
dotWithArgs(const T_expr1& a, P_numtype2 i1, P_numtype2 i2=0,
P_numtype2 i3=0, P_numtype2 i4=0, P_numtype2 i5=0, P_numtype2 i6=0,
P_numtype2 i7=0, P_numtype2 i8=0, P_numtype2 i9=0, P_numtype2 i10=0)
{
return _bz_meta_nullOperand();
}
};
　　这段代码远比它乍看上去的简单。_bz_meta_vectorDot类模板使用了一个临时变量loopFlag来存放每一步循环条件的评估结果，并使用了一个完全特化版作为递归终结的条件。需要说明的是，和几乎所有元程序一样，这个临时变量作用发挥于编译期，并将从运行代码中优化掉。
　　Todd是在Blitz++数值数组库的主要作者。这个程序库（以及MTL和POOMA等程序库）例证了模板元程序可以为我们带来更加高效的数值计算性能。Todd宣称Blitz++的性能可以和对应的Fortran程序库媲美。
Loki程序库：活用模板元编程技术的典范
　　模板元编程的价值仅仅在于高性能数值计算吗？不仅如此。Loki程序库以对泛型模式的开创性工作闻名于C++社群。它很巧妙地利用了模板元编程技术实现了Typelist组件。Typelist是实现Abstract Factory、Visitor等泛型模式不可或缺的基础设施。
　　就像C++标准库组件std::list提供对一组数值的操作一样，Typelist可以用来操纵一组类型，其定义非常简单（摘自Loki程序库Typelist.h单元）：
template <class T, class U>
struct Typelist
{
typedef T Head;
typedef U Tail;
};
　　显然，Typelist没有任何状态，也未定义任何操作，其作用只在于携带类型信息，它并未打算被实例化，因此，对于Typelist的任何处理都必然发生于编译期而非运行期。
　　Typelist可以被无限扩展，因为模板参数可以是任何类型（包括该模板的其他具现体）。例如：
　　Typelist<char, Typelist<int, Typelist<float, NullType> > >
　　就是一个包含有char、int、float三种类型的Typelist。
　　按照Loki的约定，每一个Typelist都必须以NullType结尾。NullType的作用类似于传统C字符串的“\0”，它被声明于Loki程序库的NullType.h文件中：
class NullType;
　　NullType只有声明，没有定义，因为Loki程序库永远都不需要创建一个NullType对象。
　　让我们看看IndexOf模板元程序，它可以在一个Typelist中查找给定类型的位置（摘自Loki程序库的Typelist.h单元）：
template <class TList, class T>
struct IndexOf;
template <class T>
struct IndexOf<NullType, T>
{
enum { value = -1 };
};
template <class T, class Tail>
struct IndexOf<Typelist<T, Tail>, T>
{
enum { value = 0 };
};
template <class Head, class Tail, class T>
struct IndexOf<Typelist<Head, Tail>, T>
{
private:
enum { temp = IndexOf<Tail, T>::value };
public:
enum { value = (temp == -1 ? -1 : 1 + temp) };
};
　　IndexOf提供了一个原始模板和三个局部特化版。算法非常简单：假如TList（就是一个Typelist）是一个NullType，则value为-1。假如TList的头部就是T，则value为0。否则将IndexOf施行于TList的尾部和T，并将评估结果置于一个临时变量temp中。假如temp为-1，则value为-1，否则value为1 + temp。
　　为了加深你对Typelist采用的模板元编程技术的熟悉，我从Loki程序库剥离出如下代码，放入一个typelistlite.h文件中：
// typelistlite.h
// 声明Nulltype
class NullType;
// Typelist的定义
template <class T, class U>
struct Typelist
{
typedef T Head;
typedef U Tail;
};
// IndexOf的定义
// IndexOf原始模板
template <class TList, class T> struct IndexOf;
// 针对NullType的局部特化版
template <class T>
struct IndexOf<NullType, T>
{
enum { value = -1 };
};
// 针对“Tlist头部就是我们要查找的T”的局部特化版
template <class T, class Tail>
struct IndexOf<Typelist<T, Tail>, T>
{
enum { value = 0 };
};
// 处理Tlist尾部的局部特化版
template <class Head, class Tail, class T>
struct IndexOf<Typelist<Head, Tail>, T>
{
private:
enum { temp = IndexOf<Tail, T>::value };
public:
enum { value = (temp == -1 ? -1 : 1 + temp) };
};
　　测试程序如下：
// typelistlite_test.cpp
#include <iostream>
#include "typelistlite.h"
// 自定义类型Royal
class Royal {};
// 定义一个包含有char、int、Royal和float的Typelist
typedef Typelist<char, Typelist<int, Typelist<Royal, Typelist<float, NullType> > > > CIRF;
int main()
{
std::cout << "IndexOf<CIRF, int>::value = " << IndexOf<CIRF, int>::value << "\n";
std::cout << "IndexOf<CIRF, Royal>::value = " << IndexOf<CIRF, Royal>::value << "\n";
std::cout << "IndexOf<CIRF, double>::value = " << IndexOf<CIRF, double>::value << "\n";
}
　　程序输出如下：
IndexOf<CIRF, int>::value = 1
IndexOf<CIRF, Royal>::value = 2
IndexOf<CIRF, double>::value = -1
　　结束语
　　模板元编程技术并非都是优点，比方说，模板元程序编译耗时，带有模板元程序的程序生成的代码尺寸要比普通程序的大，而且通常这种程序调试起来也比常规程序困难得多。另外，对于一些程序员来说，以类模板的方式描述算法也许有点抽象。
　　编译耗时的代价换来的是卓越的运行期性能。通常来说，一个有意义的程序的运行次数（或服役时间）总是远远超过编译次数（或编译时间）。为程序的用户带来更好的体验，或者为性能要求严格的数值计算换取更高的性能，值得程序员付出这样的代价。
　　很难想象模板元编程技术会成为每一个普通程序员的日常工具，相反，就像Blitz++和Loki那样，模板元程序几乎总是应该被封装在一个程序库的内部。对于库的用户来说，它应该是透明的。模板元程序可以（也应该）用作常规模板代码的内核，为要害的算法实现更好的性能，或者为非凡的目的实现非凡的效果。
　　模板元编程技术首次正式亮相于Todd Veldhuizen的Using C++ Template Metaprograms论文之中。这篇文章首先发表于1995年5月的C++ Report期刊上，后来Stanley Lippman编辑C++ Gems一书时又收录了它。参考文献中给出了这篇文章的链接，它还描述了许多本文没有描述到的内容。

只有使用C++语言的少数用户才努力尝试去理解模板的基本原理。然而那些希望去探索更多高级用法的人往往发现自己需要努力去理解模板是如何被语言所支持的，因为缺乏明确的说明。一个很大的问题在于一些工具只实现了C++标准的一个子集。本文将指出它们共同的缺陷并深入剖析如何使用C++模板快速产生可重用和高效的代码。

模板功能应用的典型是通过一系列模板类形成的完整类库，特别是STL和ATL。标准C++库(STL)提供了很多可重用和灵活的类及算法，而ATL则是使用C++进行COM编程的事实标准。要掌握这些及其它的模板库，理解模板是如何工作的这一基础是非常重要的。

函数模板

int main()
{
    0 cout<<add(2,3)<<endl;
    1 cout<<add(2.1,3)<<endl;
    2 cout<<add(2,3.2)<<endl;
    3 cout<<add(2.2,3.3)<<endl;
    4 cout<<add("hello eone ","world")<<endl;
    return 0;
}

     也可以通过宏定义#define add(a,b) ((a)+(b))来实现,但是指针(字符串)不能直接相加.对于2,3,4需要进行模板特化.

通过重载函数，我们能够完成多种不同数据类型的相同操作。要实现两个double数值的加法和两个整数类型的加法，我们可以使用一个重载函数：

int add(const int x, const int y)

{

return x + y;

}

double add(const double x, const double y)

{

return x + y;

}

这时，编译器将根据它们的参数正确地解决这一问题。

// 调用int add(const int, const int);

const int z1 = add(3, 2);

// 调用double add(const double, const double);

const double z2 = add(3.0, 2.0);

如果我们需要处理其它类型，我们就不得不提供其他函数重载。对每个不同的数据类型实现一个函数重载，它们都遵循相同的模式，每当我们需要调用针对某一数据类型的函数时，原则上编译器为我们生成相应的代码。而一个模板函数则以如下方式实现：

template<class T>

const T add(const T &t1, const T &t2)

{

return t1 + t2;

}

从概念上来说，编译器通过模板关键字(后面跟随着模板由一或多个模板参数构成的参数列表)来识别模板。当为某一具体类型调用add时，编译器将根据模板定义并用给定的类型替换出现在模板中的参数。在这个例子中，模板参数列表由一个独立的类型模板参数T构成。使用一个模板函数替代函数重载，编译器可以自动为所需的新类型生成代码

我们可以对任何拥有+操作符定义的类型使用add模板。假设一个自定义的String类提供了字符串连接并知道如何将自身写入到std::ostream。因为String与该模板函数兼容，因此我们可以调用它来实现字符串相加：

// 示例字符串

const string strBook("book");

const string strWorm("worm");

// 显示 "bookworm".

cout << add(strBook, strWorm) << endl;

Seeing that we intended to add two String values, the compiler will generate the appropriate add function on our behalf, which would look something like:

const String add(const String &t1, const String &t2)

{

return t1 + t2;

}

显式实例化

调用模板函数时，编译器将先把正确的类型实例化模板。虽然标准允许显式模板实例化，然而并非所有厂商都能够正确地实例它。例如，Visual C++ 6.0 会潜在地调用错误的函数：:

template<class T>

int getSize(void) {

return sizeof(T);

}

// 输出4，应该为8

cout << "double: " << getSize<double>() << endl;

// 输出4，正确

cout << "int: " << getSize<int>() << endl;

跨平台代码设计者不希望依赖于显式模板函数实例化，除非有更好的编译器能够对它提供有效的支持

类似于函数模板，模板也可以应用于类。模板可以用于根据普通模式提供一系列类。如果我们需要一套完整的算术运算来补充add函数，我们可以考虑使用一个类。通过模板，它就可以根据类型参数化为一个普通类：

template<class T>

class CCalculator

{

public:

CCalculator(const T &x, const T &y) : m_x(x), m_y(y){ }

~CCalculator(void){ }

const T add(void){ return m_x + m_y; }

const T sub(void){ return m_x - m_y; }

const T mult(void){ return m_x * m_y; }

const T div(void){ return m_x / m_y; }

private:

const T m_x;

const T m_y;

};

要实例化模板类，我们需要提供一个指定类型：

// 创建一个整数计算对象

CCalculator<int> calc(5, 2);

// 结果应该为 10

const int z = calc.mult();

如函数模板一样，编译器为模板不同类型的引用创建不同的类。这为代码重用提供了一个强大的机制，允许单个模板用于任何兼容的数据类型

模板编辑模型

在编写模板类时，函数定义通常与它们的声明一起保存在头文件中，而不使用另外的.cpp文件。否则可能会导致链接错误。这是因为大多数编译器要求模板定义在以头文件为单位的转译单元中有效

这个行为的原因是模板只是一个模式，同样它们不直接产生代码(直到编译器遇到一个应用实例)。如果我们创建一个CCalculator<int> 实例并调用其中的某个类方法，编译器将需要找到函数定义。如果头文件中包含了该定义则一切都会是正确的。但是如果定义存在于.cpp文件中，编译器不能期望在此时找到匹配的模式并利用其产生所需的代码。然而，C++标准提供了一个机制对编译器进行辅助。Export关键字可以使通知编译器我们提供了一个分离的编辑模板：

// MyTemplateFunction.h

template<class T>

void myTemplateFunction(const T &t1);

// MyTemplateFunction.cpp

export template <class T>

void myTemplateFunction(const T &t1)

{

...

}

现在，大多数编译器要求模板定义通过头文件包含被显式添加到转译单元，虽然标准期望能够独立定义于.cpp文件中。这两个不同的模板编辑模型即为包含模型和分离模型。在编写时，我所知的支持分离模型的唯一的编译器是Comeau C++。Comeau 的使用了不少方法来实现对标准中所定义的export关键字用法，但目前也还只是beta版本而已

typename关键字

另一个与模板相关的关键字是typename关键字，它有两种用法。参数下面的模板类：

template<class T>

void myFunction(void)

{

// 这里可能会有问题

T::x1 * x2;

}

初次讲到的时候可能会以为myFunction声明了一个T::x1类型的指针变量x2。然而，这个函数也能够表示类T的成员变量x1与全局变量x2的二进制乘法操作。使用typename关键字可以告诉编译器某个未知标识符是一个类型：

// T:x1 是一个类型，而x2是一个指针

typename T:x1* x2;

第二种用法是在指定模板参数时替换class关键字：

// 下面的两种方法是等效的...

template<class T1, class T2>;

template<typename T1, typename T2>;

标准允许以上任意一种方法，它们都是合法的。

成员函数模板

除了全局模板函数外，语言也支持成员模板函数：一个类可以拥有带有模板参数列表的成员函数。参考下面的非模板类，它的构造函数被模板化：

class CTypeSize

{

public:

template<class T>

CTypeSize(const T &t1) :

m_nSize(sizeof(t1))

{

}

~CTypeSize(void){ };

int getSize(void) const{ return m_nSize; }

private:

const int m_nSize;

};

当模板成员函数被调用时，编译器使用模板模式为给定类型生成代码。这种情况下，我们能够使用任意类型变量创建一个CtypeSize实例：

// 显示12

CTypeSize t1("Hello World");

cout << t1.getSize() << endl;

// 在VC++6/Win32中显示8

CTypeSize t2(7.0);

cout << t2.getSize() << endl;

某些时候，成员模板是实现拷贝构造函数最有效的方法，参考一个只有一个交易会的简单容器类：

template<class T>

class CSingle

{

public:

CSingle(const T &t1) : m_Value(t1) { }

~CSingle(void){ }

T m_Value;

};

它导致下面的问题：

// 创建一个整数容器

CSingle<int> x(7);

// 这里需要一个拷贝构造...

CSingle<double> y(x);

通过使用成员模板，拷贝构造就能够轻松完成：

template<class S>

CSingle(const CSingle<S> &s1) : m_Value(s1.m_Value) { }

当编辑器能够将类型T的实例转换为类型S时，这是可行的；这是因为double可以从一个整数构造。

总结

模板是C++的一个强大特征，它允许从数据类型中抽象出算法。本文介绍了模板定义和实例化的基础，包括函数、类及成员模板的区别。

模板类和模板函数都是非常有用的工具。例如sqr()函数可以计算平方数，任何定义了乘法运算的数据类型（数字，矩阵）都适用。标准容器类(如list)都是模板，这样对于每个新类型无需重写了，这正是使用旧版的C++时真正头疼的事情，因此我认为ISO的标准是个伟大的进步。然而，在这个过程中有些东西用得过头了。

例如：标准库中得string 和iostream 都是使用"character traits"类型作为参数。这意味着同一个basic_string<>类可以用于ASCII字符串，也可用于Unicode，甚至用于火星人的三字节字符串（原则虽然如此，但许多版本都只是实现了ASCII字符串，看起来有点滑稽）。标准要求这些常用类必须实现成模板形式，而这些类几乎涉及到所有C++应用。

但是这对性能和调试会带来许多麻烦。下面几个试验解释了这个问题（本试验使用的编译器为VC++6.0)。编译器同时支持新风格的iostream（使用模板）和经典风格的iostream, 因此我们能比较他们二者的版本实现。第一个测试程序当然是使用"Hello, Word"了，新风格的编译时间是经典风格的2倍。另一个更正规的例子大约有200行，每行输出10个变量用于计数。这个测试程序最显著的结论是编译速度：新风格版本花了10秒编译完成，而旧版本只使用了1.5秒。10秒时间可并不少，可以完成很多事情。另外，新风格版本的可执行文件的大小为115K，而旧版本只有70K。你的测试数据可能有些出入，但是整体结论是一样的：当使用新版本时，会有更慢的编译速度和更大的可执行文件。这并不是因为微软公司编译器的问题，使用GCC测试也会得到同样的结论。

当然，和过去不一样，可执行文件的大小并不是那么重要，现在，可编程设备种类正快速增长，包括许多信息应用，如遥控、手机、智能冰箱、基于蓝牙技术的咖啡机等等，在这些应用中内存近几年都会是十分宝贵的资源。使用标准iostream 而产生的额外的二进制文件，来源于内联了整个模板类的代码，要是没有code bload工具，你很难优化那些重要的操作。对我来说，编译时间问题更严重一些，因为这样意味着更长的等待，从而失去了开发中非常重要原则：互动原则。

现在我们来考虑调试的问题。标准库中string 类的模板实现非常聪明，但并不适合于调试。你会面临使用超长名字的编译器和调试器的信息：

class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char>>

同样对于非常有用的容器 map < string,string > , 你可以去想象其复杂性。这些名字太长了，以至于产生数十个内部名字被截断的警告。对于初学者来说，std::string 应该设计得尽可能透明，而不应该让他们面临许多语言内置得一些特性。当输出了编译错误信息后，在技术上讲，应该是可以查找到所有的 typedef 。我在 UnderC 项目中就试图这么做。Verity Stob 建议编写一个后置的处理器来翻译这些错误信息，我倒希望这是她这么做只是开个玩笑。如果不使用这么复杂的类型，这个问题就会容易处理的多。我在C++开发上的秘诀就是（我首次坦诚的公开这个秘密): 在稍微大一点的工程中使用一个兼容的string 类来替换std::string 的头文件. 有时我会重新build 这些标准的头文件，用来检测是否我的库还能正常使用，但让其他人为如何提高其性能而努力。

当然，在许多应用中我们都需要这种std::string提供的灵活性，例如，需要同时处理ASCII 和Unicode字符串，或者需要定制自己的allocator 等等。但这并不是普遍需求(通常程序员要么只处理ASCII，要么只处理Unicode ), 看起来对于程序员承担这种范型机制有些不公平。这种机制确实让标准库的设计者觉得很有意思，但增加了应用开发程序员使用的复杂度。这似乎颠倒了这个原则：良好的标准库设计应该隐藏其实现的复杂度，而让用户直接使用。但std::string 对其实现的复杂度隐藏得并不够，导致在用户使用过程中不断的遇到设计中的问题。我们不能要求标准库的用户都是专家。标准坚持要求这种特定的实现方式，和标准库的设计初衷相违背，其初衷是只提供公共的接口和包含一些特定功能的类库。自然，这种范型模板对于那些真正去要他们的人是一直有效的。

这些细节考虑同样应用于标准容器，例如list<>容器，list 有一些额外的默认模板参数，用于定义了默认的allocator。当然自己定义allocator 十分有用，但绝大多数人不需要自己去实现。这些泛化的版本完全可以作为单独的模板提供。我承认这样做会让标准库的设计在技术上变得没有以前有意思，但这些库在设计之初就应该考虑到最终用户。篡改一下C++的颂歌：用户不应该为他们不需要的东西买单。

当我们不需要模板的时候，我们不得不使用模板。除此之外，在C＋＋中用范型编程还会遇到另一个的问题。大多数人都同意，标准的algorithm 十分有用。如果你有一个整型的vector, 你可以直接使用下面的语句来排序：

sort(v.begin(),v.end());

因为int型数据的比较函数时内联的，而且这种范型算法比旧版本的qsort()函数速度还快，也更容易使用，特别是使用用户自定义类型的vector. copy()函数也可以在任何时候高效率地拷贝任何数据。

但有些应用理解起来十分晦涩：

copy_if(v.begin(),v.end(),ostream_iterator<int>(cout) bind2nd(greater<int>(),7));

如果要写得严格一点，每个名字都应该加上std::前缀，这里假定所有变量都是使用全局命名空间，或单独使用命令或用其他方法。用Stroustrup (C++的创始人)的例子更容易说明问题，这个例子把所有的整型数输出到终端：

vector<int>::iterator li;
for (li = v.begin(); li != v.end(); ++li)
if (*li > 7) cout << *li;

Stroustrup 告诉我们如果使用显示的循环是"麻烦而又容易产生错误", 但我看不出使用第一个版本有什么优势。显然，人们能习惯这种方式，人类的适应性很强，作为专业人士，我们也不得不学习这个新概念。但是，这样做并没有减少多少麻烦，而且我们可以证明这样做可读性更差，更不灵活。同时，它还会限制你的设计。例如，假设我们有一个Shape * 的指针list, 我们可以通过下面的调用方式来画出他们自己的形状：

for_each(ls.begin(),ls.end(),
bind2nd(mem_fun(&Shape::draw),canvas));

也可以选择这种方式：

ShapeList::iterator li;
for (li = ls.begin(); li != ls.end(); ++li)
(*li)->draw(canvas);

现在假设我需要修改我的设计，我只想画那些满足某种要求的图形（而且不希望把这些需求包在shape类里面), 那么我只需要在显式的循环中增加一条if条件语句。如果要使用范型概念，我唯一能想到的方式定义一个函数，然后使用for_each()算法。使用设计模式一书中的术语，第一个例子是一个内部迭代器(internal iterator)，第二个例子式一个外部跌倒器(external iterator). 作者认为C++ 并不擅长使用内部迭代器，我想我们还是应该考虑语言的局限性。其实问题在于在C++中过度应用范型概念--从而导致不必要的难度。C++ 完全不支持一般的匿名函数(anonymous functions)如LIST, SmallTalk, Ruby等。C++中的匿名函数或许看起来和下面一样，可能某天有人会实现它：

for_each(ls.begin(),ls.end(),
void lambda(Shape *p) { p->draw(canvas); }); 

C++ 是一种不可思议的编程语言，小到手机，大到跨国际网络，都有其应用。它非常灵活，能够支持多种编程风格，但这种灵活同样也是其问题所在。编程的艺术在于为特定的问题选择合适编程风格，就像老师总提醒写作文是要选择好的风格一样。我并不想诋毁 C++ 标准库，这里面包含了许多人的辛勤劳动，并为大家提供了一个公共平台。我对于这个标准的态度是，它和范型编程联系过于紧密，从而变成了在说明什么风格是好的编程风格(例如，算法中明显倾向于不要使用显式循环), 同时它也让程序员们不得不介入一些实现细节(如basic_string<>)，这样做让人们更加觉得C++ 是只是内核工程师们的编程语言。