詳解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