我的C++实践(7)：模板元编程实战

    （1）计算整数的幂。

//pow.hpp：计算N的M次幂 #ifndef POW_HPP #define POW_HPP template<int N,int M> class Pow{ //计算N的M次方的基本模板 public: enum{ result=N*Pow<N,M-1>::result }; }; template<int N> class Pow<N,0>{ //用于结束递归的局部特化 public: enum{ result=1 }; }; #endif

    Pow<N,M>用来计算N的M次幂。实例化层次是Pow<N,M>，Pow<N,M-1>，...，Pow<N,0>，共M+1层。我们始终要记住编译器对模板元编程中的实例化层次是有限制的（否则会层次太深的话会耗尽编译器的可用资源），我测试出gcc 4.2.4最多只允许31层的实例化，因此这里如果使用Pow<2,31>，Pow<5,40>等，则编译不会通过。
    （2）求整数的平方根（向上取整）。可以用二分查找算法来查找，也可以用普通的从0开始迭代的查找算法。

//sqrt1.hpp：求整数的平方根（向上取整），用二分查找算法 #ifndef SQRT_HPP #define SQRT_HPP #include "ifthenelse.hpp" template<int N,int LO=0,int Hi=N> class Sqrt{ public: enum{ mid=(LO+HI+1)/2 }; //计算中点 //执行二分查找：用递归模板，找到结果的类型，然后返回结果 //enum{ result=(N<mid*mid)? Sqrt<N,LO,mid-1>::result : Sqrt<N,mid,HI>::result }; typedef typename IfThenElse<(N<mid*mid), Sqrt<N,LO,mid-1>, Sqrt<N,mid,HI> >::ResultT SubT; enum{ result=SubT::result }; //返回最终结果 }; template<int N,int M> class Sqrt<N,M,M>{ //终止递归的局部特化：适用于LO等于HI public: enum{ result=M }; }; #endif

//sqrt2.hpp：求整数的平方根（向上取整），用迭代查找算法 #ifndef SQRT_HPP #define SQRT_HPP #include "ifthenelse.hpp" template<int N> class Value{ //包装常量N的模板，使N变成一个类型Value<N> public: enum{ result=N }; //定义其要返回的结果reuslt }; template<int N,int I=0> class Sqrt{ //基本模板，从0开始迭代，以找到N的平方根（向上取整） public: //执行迭代来找到最终结果的类型：用递归模板 typedef typename IfThenElse<(I*I<N), Sqrt<N,N+1>, Value<I> >::ResultT SubT; enum{ result=SubT::result; } //返回最终找到的结果 }; #endif

    在模板元编程中，我们要尽量少用条件运算符?:来执行路径选择，因为这会导致两个分支中的递归模板都会被实例化，产生数量庞大的实例化体。例如使用sqrt1.hpp中注释掉的那句，当实例化Sqrt<N,LO,HI>时，会导致Sqrt<N，LO，mid-1>和Sqrt<N,mid,HI>的完全实例，这样最终的实例化个数大约是N的2倍。我们应该用模板特化来执行路径选择，例如我们使用前面类型萃取技术中介绍的IfThenElse<bool,T1,T2>模板。在它的特化中ResultT只返回其中一个类型(如T1)，注意把T1类型typedef成ResultT并不会导致被实例化。当最终查找结果ResultT::resut时，就会实例化ResultT，可见这只实例化了一个IfThenElse中的一个分支。最终的实例化个数趋向于lg(N)。另外，在二分查找的实现中，返回是其中的一个分支类型，最后返回时应该是mid=HI时的Sqrt<N,mid,HI>，因此必须提供一个mid=HI的特化来结束Sqrt模板的递归，否则还会再去实例化Sqrt<N,mid,HI>。而在迭代查找的实现中，当I*I>=N时模板递归结束，这时返回Value<I>分支，用Value<I>::result直接返回计算出的结果，递归结束。因此不需要提供Sqrt的特化来结束递归。

    （3）计算向量的点乘。

//dotproduct.hpp：向量的点乘 #ifndef DOTPRODUCT_HPP #define DOTPRODUCT_HPP template<int DIM,typename T> class DotProduct{ //基本模板 public: static T result(T* a,T* b){ //第1个元素的乘积加到剩下的新向量的点乘 return *a * *b+DotProduct<DIM-1,T>::result(a+1,b+1); } }; template<typename T> class DotProduct<1,T>{ //作为结束条件的局部特化 public: static T result(T* a,T* b){ return *a * *b; //最后只有一个元素相乘 } }; //包装函数：为了使用方便 template<int DIM,typename T> inline T dot_product(T* a,T* b){ return DotProduct<DIM,T>::result(a,b); } #endif

//dotproducttest.cpp：向量点乘的测试 #include <iostream> #include "dotproduct.hpp" int main(){ int a[3]={1,2,3}; int b[3]={5,6,7}; std::cout<<"dot_product<3>(a,b) = "<<dot_product<3>(a,b)<<'/n'; std::cout<<"dot_product<3>(a,a) = "<<dot_product<3>(a,a)<<'/n'; return 0; }

    （4）判断一个数是否是素数。

//isprime.hpp：判断一个数是否是素数 #ifndef IS_PRIME_HPP #define IS_PRIME_HPP template<int p,int i> class is_prime{ //基本模板：判断p是否是素数 public: enum{ prim=(p==2)||(p%i) && is_prime<(i>2?p:0),i-1>::prim }; }; template<> class is_prime<0,0>{ //用于结束模板递归的全局特化 public: enum{ prim=1 }; }; template<> class is_prime<0,1>{ //用于结束模板递归的全局特化 public: enum{ prim=1 }; }; #endif

    （5）打印连续的素数。

//primeprinter.hpp：打印连续的素数 #ifndef PRIME_PRINTER_HPP #define PRIME_PRINTER_HPP #include <iostream> #include "isprime.hpp" template<int i> class PrimePrinter{ //打印i以下的连续素数 public: enum{ prim=is_prime<i,i-1>::prim }; static void print(){ if(prim) std::cout<<i<<std::endl; PrimePrinter<i-1>::print(); } }; template<> class PrimePrinter<1>{ //用于结束模板递归的全局特化 public: enum{ prim=0 }; static void print(){ return; } }; #endif

    总结出模板元编程的计算完整性：
    1）状态变量：也就是模板参数
    2）迭代构造（相当于循环语句）：通过递归模板
    3）路径选择（相当于条件语句）：通过使用特化或条件表达式?:
    4）整型对象（相当于变量）：用enum定义的枚举值