详解c++中的trait与policy模板技术

//accum1.hpp：累加算法模板：实现为函数模板，引入了trait。用数组首部指针及尾部后面的一个指针作参数  
#ifndef ACCUM_HPP  
#define ACCUM_HPP  
#include "accumtraits.hpp"  
#include <iostream>  
template<typename T>  
inline typename AccumulationTraits<T>::AccT accum(T const* beg,T const* end){  
    //返回值类型是要操作的元素类型T的trait  
    typedef typename AccumulationTraits<T>::AccT AccT;  
    AccT total=AccumulationTraits<T>::zero(); //返回具体类型的缺省值  
    while(beg!=end){  //作累加运算  
        total+=*beg;  
        ++beg;  
    }  
    return total; //返回累加的值  
}  
#endif  

//accumtraits.hpp：累加算法模板的trait  
#ifndef ACCUMTRAITS_HPP  
#define ACCUMTRAITS_HPP  
template<typename T>  
class AccumulationTraits; //只有声明  
//各个特化的定义  
template<>  
class AccumulationTraits<char>{ //把具体类型char映射到int，累加后就返回int  
public:  
    typedef int AccT;  //统一的类型别名，表示返回类型  
    static AccT zero(){ //关联一个缺省值，是累加时的初始缺省值  
        return 0;  
    }  
};  
template<>  
class AccumulationTraits<short>{ //把具体类型short映射到累加后的返回类型int  
public:  
    typedef int AccT;  
    static AccT zero(){ //没有直接在类内部定义static变量并提供缺省值，而是使用了函数  
                        //因为类内部只能对整型和枚举类型的static变量进行初始化  
                        //其他类型的必须类内部声明，在外部进行初始化  
        return 0;  
    }  
};  
template<>  
class AccumulationTraits<int>{  
public:  
    typedef long AccT;  
    static AccT zero(){  
        return 0;  
    }  
};  
template<>  
class AccumulationTraits<unsigned int>{  
public:  
    typedef unsigned long AccT;  
    static AccT zero(){  
        return 0;  
    }  
};  
template<>  
class AccumulationTraits<float>{  
public:  
    typedef double AccT;  
    static AccT zero(){  
        return 0;  
    }  
};  
//...  
#endif  

//accum1test.cpp：使用累加算法的客户端代码  
#include "accum1.hpp"  
#include <iostream>  
int main(){  
    int num[]={1,2,3,4,5}; //整型数组  
    std::cout<<"the average value of the integer values is "  
        <<accum(&num[0],&num[5])/5<<'/n';  //输出平均值  
    char name[]="templates"; //创建字符值数组  
    int length=sizeof(name)-1;  
    //输出平均的字符值，返回的是int型，不会越界  
    std::cout<<"the average value of the characters in /""  
        <<name<<"/" is "<<accum(&name[0],&name[length])/length<<'/n';   
    return 0;  
}  

//accum2.hpp:累加算法模板：实现为类模板，用模板参数来传递trait  
//可用一个内联函数模板作为包装器来包装这个类模板实现  
#ifndef ACCUM_HPP  
#define ACCUM_HPP  
#include "accumtraits.hpp"  
template<typename T,typename AT=AccumulationTraits<T> >  
class Accum{ //实现为类模板，模板参数AT代表要使用的trait，并有一个缺省实参  
public:  
    static typename AT::AccT accum(T const* beg,T const* end){  
        typename AT::AccT total=AT::zero(); //获取缺省值  
        while(beg != end){ //进行累加  
            total+=*beg;  
            ++beg;  
        }  
        return total; //返回累加的值  
    }  
};  
//用内联的函数模板来包装，对默认的trait，使用一个独立的重载版本  
template<typename T>  
inline typename AccumulationTraits<T>::AccT accum(T const* beg,T const* end){  
    return Accum<T>::accum(beg,end);  
}  
template<typename T,typename Traits>  
inline   
typename Traits::AccT accum(T const* beg,T const* end){  
    return Accum<T,Traits>::accum(beg,end);  
}  
#endif  

//policies1.hpp：累加元素模板的不同policy实现：实现为含有成员函数模板的普通类  
#ifndef POLICIES_HPP  
#define POLICIES_HPP  
class SumPolicy{ //累加的policy  
public:  
    template<typename T1,typename T2>  
    static void accumulate(T1& total,T2 const& value){  
        total+=value; //作累加  
    }  
};  
class MultPolicy{ //累乘的policy  
public:  
    template<typename T1,typename T2>  
    static void accumulate(T1& total,T2 const& value){  
        total*=value;  
    }  
};  
//其他各种policy  
//......  
#endif  

//accum3.hpp：累加算法模板，引入了作为普通类的policy，默认是采用SumPolicy  
#ifndef ACCUM_HPP  
#define ACCUM_HPP  
#include "accumtraits.hpp"  
#include "policies1.hpp"  
template<typename T,typename Policy=SumPolicy,typename Traits=AccumulationTraits<T> >  
class Accum{ //累加算法实现为类模板，默认采用SumPolicy  
public:  
    typedef typename Traits::AccT AccT;  
    static AccT accum(T const* beg,T const* end){  
        AccT total=Traits::zero();  //获取缺省值  
        while(beg !=end){ //作累积运算  
            Policy::accumulate(total,*beg); //使用给定的算法策略来进行累积  
            ++beg;  
        }  
        return total; //返回累积起来的值  
    }  
};  
#endif  

//policies2.hpp:把各个policy实现为类模板  
#ifndef POLICIES_HPP  
#define POLICIES_HPP  
template<typename T1,typename T2>  
class SumPolicy{  
public:  
    static void accumulate(T1& total,T2 const& value){  
        total+=value;  
    }  
};  
//...  
#endif  

//accum4.hpp：累加算法模板，引入了作为类模板的policy，默认是采用SumPolicy  
#ifndef ACCUM_HPP  
#define ACCUM_HPP  
#include "accumtraits.hpp"  
#include "policies2.hpp"  
template<typename T,  
    template<typename,typename> class Policy=SumPolicy,  
    typename Traits=AccumulationTraits<T> >  
class Accum{ //累加算法实现为类模板，默认采用模板SumPolicy  
public:  
    typedef typename Traits::AccT AccT; //获取返回类型，它是T的trait  
    static AccT accum(T const* beg,T const* end){  
        AccT total=Traits::zero();  //获取缺省值  
        while(beg !=end){ //作累积运算  
            Policy<AccT,T>::accumulate(total,*beg); //使用给定的算法策略来进行累积  
            ++beg;  
        }  
        return total; //返回累积起来的值  
    }  
};  
#endif