概述

我們知道，類有屬性（即數(shù)據(jù)）和操作兩個方面。同樣模板也有自己的屬性（特別是模板參數(shù)類型的一些具體特征，即trait）和算法策略（policy，即模板內(nèi)部的操作邏輯）。模板是對有共性的各種類型進行參數(shù)化后的一種通用代碼，但不同的具體類型又可能會有一些差異，比如不同的類型可能會有自己的不同特征和算法實現(xiàn)策略。

trait模板技術(shù)

當在模板代碼中需要知道類型參數(shù)T的某些特征(比如需要知道T是哪個具體類型，是否有默認構(gòu)造函數(shù)，希望該類型有合理的缺省值，如int型缺省值為0），我們可以聲明一個描述T的特征的trait<T>模板，然后對每種具體類型（如int,char,用戶定義的類）特化trait<T>，在各特化版本中用typedef為該具體類型（或者想映射成的其他類型）定義統(tǒng)一的別名（比如AliT)，根據(jù)需要還可指定合理的缺省值等。這樣在原來模板文件中#include這個trait<T>模板的文件，就可以在模板代碼中使用trait<T>::AliT來獲得T的具體特征。

比如我們要計算數(shù)組各個元素的累加和，由于數(shù)組元素可以是各種類型，我們使用模板來實現(xiàn)它，這時有一個類型參數(shù)T。但在算法代碼中，某些情況下又必須知道T的具體類型特征，才能作出特殊的處理。例如對char型的數(shù)組元素累加如果最終返回的也是char型的話，很可能越界，因為char只占8位，范圍很小。我們可以為T的trait創(chuàng)建一個模板AccumulationTraits。具體代碼如下：

//accum1.hpp：累加算法模板：實現(xiàn)為函數(shù)模板，引入了trait。用數(shù)組首部指針及尾部后面的一個指針作參數(shù)  
#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;  //統(tǒng)一的類型別名，表示返回類型  
    static AccT zero(){ //關(guān)聯(lián)一個缺省值，是累加時的初始缺省值  
        return 0;  
    }  
};  
template<>  
class AccumulationTraits<short>{ //把具體類型short映射到累加后的返回類型int  
public:  
    typedef int AccT;  
    static AccT zero(){ //沒有直接在類內(nèi)部定義static變量并提供缺省值，而是使用了函數(shù)  
                        //因為類內(nèi)部只能對整型和枚舉類型的static變量進行初始化  
                        //其他類型的必須類內(nèi)部聲明，在外部進行初始化  
        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}; //整型數(shù)組  
    std::cout<<"the average value of the integer values is "  
        <<accum(&num[0],&num[5])/5<<'/n';  //輸出平均值  
    char name[]="templates"; //創(chuàng)建字符值數(shù)組  
    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;  
}  

注意trait模板本身只是一個聲明，并不提供定義，因為它并不知道參數(shù)T具體是什么類型。trait的定義由針對各個具體類型的特化來提供。trait依賴于原來模板的主參數(shù)T，因為它表示的是T的特征信息。這里使用函數(shù)zero()為每個具體類型還關(guān)聯(lián)了一個缺省值，用來作為累加的初始值。為什么不直接關(guān)聯(lián)為靜態(tài)變量呢？比如static AccT const zero=0。這主要是因為在類內(nèi)部只能對整型和枚舉類型的static變量進行初始化，其他類型的必須在類內(nèi)部聲明，在外部進行初始化。這里對char型數(shù)組元素進行累加時，返回int型，這樣就避免了會產(chǎn)生越界的情況。

總結(jié)出trait模板技術(shù)的核心思想：把模板參數(shù)T的具體特征信息抽象成一個獨立的模板，通過特化為具體的類型并為該類型關(guān)聯(lián)統(tǒng)一的別名，我們就可以在模板中引用這個別名，以獲得T的具體特征信息。注意一個模板參數(shù)可能有多種特征，每一個trait都可以抽象成一個trait模板?？梢娺@里特化是獲得具體差異行為的關(guān)鍵。由于在模板中類型T是抽象的，不能獲得它的具體特征，我們通過對T的特征進行抽離，并特化為具體的類型，才能獲得類型的具體特征。從這可以看出我們還有一種實現(xiàn)方案，那就是直接特化模板accum，即針對char型進行一個特化來進行累加。但這樣特化版本中又要重寫基本模板中那些相同的代碼邏輯（比如進行累加的while循環(huán)），而實際上我們需要特化的只是類型的特征信息。

在設(shè)計層面上，特化與模板的意圖正好相反。模板是泛型代碼，代表各個類型之間的共性，而特化則表示各個類型之間的差異。我們可以結(jié)合多態(tài)來深刻地把握這些設(shè)計思想。從一般意義上講，polymorphism是指具有多種形態(tài)或行為，它能夠根據(jù)單一的標記來關(guān)聯(lián)不同的特定行為?？梢姉l件語句if/else也可以看作是一種多態(tài)，它根據(jù)標記的不同狀態(tài)值來選擇執(zhí)行不同的分支代碼（代表不同的行為）。多態(tài)在不同的程序設(shè)計范型有不同的表現(xiàn)。

（1）面向過程的程序設(shè)計：多態(tài)通過條件語句if/else來實現(xiàn)。這樣多態(tài)其實成了最基本的程序邏輯結(jié)構(gòu)。我們知道順序語句和條件語句是最基本的邏輯結(jié)構(gòu)，switch語句本身就是if/else的變體，循環(huán)語句相當于有一個goto語句的if/else。這種多態(tài)可以稱為OP多態(tài)，它最大優(yōu)點就是效率高，只有一個跳轉(zhuǎn)語句，不需要額外的開銷。最大缺點就難以擴展，很難應(yīng)對變化。當有新的行為時，就要修改原來的代碼，在if/else中再增加一個分支，然后重新編譯代碼。它只是一種低層次的多態(tài)，需要程序員人工增加代碼，判斷標記的值。

（2）面向?qū)ο蟪绦蛟O(shè)計：多態(tài)通過虛函數(shù)機制，用繼承的方式來實現(xiàn)。這里的設(shè)計思想就是抽離類型之間的共性，把它們放在基類中，而具體的差異性則放到子類中。我們使用基類指針或引用作為單一的標記，它會自動的綁定到子類對象上，以獲得不同的行為。函數(shù)重載也可以看作是一種多態(tài)，函數(shù)名作為單一的標記，我們通過不同的參數(shù)類型來調(diào)用不同的重載版本，從而獲得不同的多態(tài)行為。這種多態(tài)稱為OO多態(tài)，它的優(yōu)點就是自動化，易擴展，提高了復用程度。它不需要程序員人工干預，因為動態(tài)綁定是自動進行的。當需要新的行為時，從基類繼承一個新的子類即可，不需要修改原來的代碼，系統(tǒng)易維護，也易擴展。缺點就是降低了效率，當縱向的繼承體系比較深時，要創(chuàng)建大量的對象，虛函數(shù)一般也很少能夠被內(nèi)聯(lián)，這會使內(nèi)存使用量大幅增加。OO多態(tài)是一種高層次的多態(tài)，耦合性比OP多態(tài)低，但縱向的繼承體系仍然有一定的耦合性。

（3）泛型程序設(shè)計：多態(tài)通過模板來實現(xiàn)。這里的設(shè)計思想就是不需要抽離類型之間的共性，而是直接對類型進行參數(shù)化，把它設(shè)計成模板，以表示共性。類型之間的差異通過特化來實現(xiàn)。編譯器會根據(jù)類型參數(shù)（相當于單一的標記）自動決定是從模板產(chǎn)生實例，還是調(diào)用特化的實例。這種多態(tài)稱為GP多態(tài)，它是橫向的，代表共性的模板與代表差異性的特化在同一層次上，它們之間是相互獨立的，因此它的耦合性更低，性能也更好。由于GP本身也支持繼承和重載，因此可以看出它是一種更高層次的多態(tài)，而用模板來做設(shè)計甚至比面向?qū)ο笤O(shè)計還強大，因為模板本身也支持面向?qū)ο蟮睦^承機制，它在面向?qū)ο髮哟紊线€作了一層更高的抽象（對類進行抽象）。GP多態(tài)還具有更好的健壯性，因為它在編譯期就進行檢查。當然，GP代碼比較難調(diào)試，這主要由于 編譯器支持得不好。

用模板參數(shù)來傳遞多種trait

前面我們在accum中通過組合的方式使用它的trait模板。我們也可直接給accum模板增加一個模板參數(shù)用來傳遞trait類型，并指定一個缺省實參為AccumulationTraits<T>，這樣可以適應(yīng)有多種trait的情況。由于函數(shù)模板并不能指定缺省模板實參（其實現(xiàn)在許多編譯器都支持這個非標準特性），我們把accum實現(xiàn)為一個類模板。算法作為一個函數(shù)來使用時應(yīng)該會更自然一點，因此可以再用一個函數(shù)模板來包裝這個類模板，使之變成一個函數(shù)模板。如下：

//accum2.hpp:累加算法模板：實現(xiàn)為類模板，用模板參數(shù)來傳遞trait  
//可用一個內(nèi)聯(lián)函數(shù)模板作為包裝器來包裝這個類模板實現(xiàn)  
#ifndef ACCUM_HPP  
#define ACCUM_HPP  
#include "accumtraits.hpp"  
template<typename T,typename AT=AccumulationTraits<T> >  
class Accum{ //實現(xiàn)為類模板，模板參數(shù)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; //返回累加的值  
    }  
};  
//用內(nèi)聯(lián)的函數(shù)模板來包裝，對默認的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  

使模板參數(shù)來傳遞trait的一個最大好處是當有多種trait時，我們可以為第2個模板參數(shù)指定需要的各種trait。這里還使用了所謂的內(nèi)聯(lián)包裝函數(shù)技術(shù)。當我們實現(xiàn)了一個函數(shù)（模板），但接口比較難用時，比如這里是類模板，用戶即使是使用默認的AccumumationTrait<T>，也要顯式指定第一個實參T，不好用。我們可以用一個包裝函數(shù)來包裝它，使其接口變得對用戶非常簡單友好，為了避免包裝帶來的性能損失，要把包裝函數(shù)（模板）聲明為內(nèi)聯(lián)，編譯器通常會直接調(diào)用位于內(nèi)聯(lián)函數(shù)里面的那個函數(shù)。這樣，使用默認trait時客戶端代碼accum1test.cpp不需要做任何修改。

policy模板技術(shù)

與trait模板技術(shù)的思想類似，只不過是對模板代碼中的算法策略進行抽離。因為模板代碼中對不同的具體類型可能某一部分代碼邏輯（即算法策略）會不一樣（比如對int是累加，對char則是連接）。policy模板就代表了這些算法策略。它不需要使用特化，policy只需重新實現(xiàn)這個與原模板中的代碼不同的具體算法策略即可。

上面是對類型的不同trait產(chǎn)生的差異。實際上對不同的trait，其算法策略(policy)也可能有不同的差異。比如我們對char型元素的數(shù)組，不用累加策略，而是用連接的策略。我們還可以把accum看作是一般的數(shù)組元素累積性函數(shù)，既可以累加，也可以累乘、連接等。一種方法是我們可以直接對accum函數(shù)模板的不同具體類型提供特化，重寫各自的代碼邏輯。但實際上，這時我們需要變化的只有total+=*beg那一條語句，因此我們可以使用policy模板技術(shù)，為模板的不同policy創(chuàng)建獨立的模板。這里我們把policy實現(xiàn)為具有一個成員函數(shù)模板的普通類（當然policy也可以直接實現(xiàn)為模板）。對累加策略為SumPolicy，對累乘策略為MultPolicy等。代碼如下：

//policies1.hpp：累加元素模板的不同policy實現(xiàn)：實現(xiàn)為含有成員函數(shù)模板的普通類  
#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  

引入了policy后，把累加算法實現(xiàn)為類模板，如下：

//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{ //累加算法實現(xiàn)為類模板，默認采用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  

當policy為普通類時，這里用一個類型模板參數(shù)來傳遞不同的policy，缺省的policy為SumPolicy?？蛻舳耸褂肁ccum<int>::accum(&num[0],&num[5])這樣的形式來對int型數(shù)組元素進行累加。注意當trait使用默認的AccummulationTrait<T>時，累乘策略MultPolicy實際上就不能用在這里了。因為初始值為0，那累乘的結(jié)果最終總是0，可見policy與trait是有聯(lián)系的。當然我們也可以換一種方法來實現(xiàn)，即直接讓accum函數(shù)增加一個形參T val，用val來指定運算的初始值。實際上，C++標準庫函數(shù)accumulate()就是把這個初值作為第3個實參。

模板化的policy

上面的policy實現(xiàn)為具有一個成員函數(shù)模板的普通類，這可以看出，其實policy可以直接實現(xiàn)為一個模板。這時在accum算法中就要用模板模板參數(shù)來傳遞policy了。代碼如下：

//policies2.hpp:把各個policy實現(xiàn)為類模板  
#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{ //累加算法實現(xiàn)為類模板，默認采用模板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  

trait模板與policy模板技術(shù)的比較

（1）trait注重于類型，policy更注重于行為。

（2）trait可以不通過模板參數(shù)來傳遞，它表示的類型通常具有自然的缺省值（如int型為0），它依賴于一個或多個主參數(shù)，它 一般用模板來實現(xiàn)。

（3）policy可以用普通類來實現(xiàn)，也可以用類模板來實現(xiàn)，一般通過模板參數(shù)來傳遞。它并不需要類型有缺省值，缺省值通常是在policy中的成員函數(shù)中用一個獨立的參數(shù)來傳遞。它通常并不直接依賴于模板參數(shù)。

一般在模板中指定兩個模板參數(shù)來傳遞trait和policy。而policy的種類更多，使用更頻繁，因此通常代表policy的模板參數(shù)在代表trait的模板參數(shù)前面。

標準庫中的std::iterator_traits<T>是一個trait，可通過iterator_traits<T>::value_ type來引用T表示的具體類型。其實現(xiàn)也是用特化來獲取各個具體的類型，有全局特化也有局部物化，如指針類型，引用類型等就只能通過局部特化為T*,T&來實現(xiàn)。

以上就是詳解c++中的trait與policy模板技術(shù)的詳細內(nèi)容，更多關(guān)于c++中的trait與policy模板技術(shù)的資料請關(guān)注腳本之家其它相關(guān)文章！

最新評論