模版與特化的概念
函數(shù)模版與類模版
C++中模板分為函數(shù)模板和類模板
函數(shù)模板：是一種抽象函數(shù)定義，它代表一類同構(gòu)函數(shù)。
類模板：是一種更高層次的抽象的類定義。
特化的概念
所謂特化，就是將泛型的東東搞得具體化一些，從字面上來解釋，就是為已有的模板參數(shù)進行一些使其特殊化的指定，使得以前不受任何約束的模板參數(shù)，或受到特定的修飾（例如const或者搖身一變成為了指針之類的東東，甚至是經(jīng)過別的模板類包裝之后的模板類型）或完全被指定了下來。
模板特化的分類
針對特化的對象不同，分為兩類：函數(shù)模板的特化和類模板的特化
函數(shù)模板的特化
當函數(shù)模板需要對某些類型進行特化處理，稱為函數(shù)模板的特化。
類模板的特化
當類模板內(nèi)需要對某些類型進行特別處理時，使用類模板的特化。
特化整體上分為全特化和偏特化?
* 全特化
就是模板中模板參數(shù)全被指定為確定的類型。 全特化也就是定義了一個全新的類型，全特化的類中的函數(shù)可以與模板類不一樣。
1234
偏特化
就是模板中的模板參數(shù)沒有被全部確定，需要編譯器在編譯時進行確定。
全特化的標志就是產(chǎn)生出完全確定的東西，而不是還需要在編譯期間去搜尋適合的特化實現(xiàn)，貌似在我的這種理解下，全特化的 東西不論是類還是函數(shù)都有這樣的特點，
模板函數(shù)只能全特化，沒有偏特化（以后可能有）。
模板類是可以全特化和偏特化的。
template <>然后是完全和模板類型沒有一點關(guān)系的類實現(xiàn)或者函數(shù)定義，如果你要說，都完全確定下來了，那還搞什么模板呀，直接定義不就完事了？
但是很多時候，我們既需要一個模板能應(yīng)對各種情形，又需要它對于某個特定的類型（比如bool）有著特別的處理，這種情形下特化就是需要的了。
全特化的標志：template <>然后是完全和模板類型沒有一點關(guān)系的類實現(xiàn)或者函數(shù)定義偏特化的標志：template函數(shù)模版特化
目前的標準中，模板函數(shù)只能全特化，沒有偏特化
至于為什么函數(shù)不能偏特化，似乎不是因為語言實現(xiàn)不了，而是因為偏特化的功能可以通過函數(shù)的重載完成。
函數(shù)模版的特化技巧
函數(shù)模板的特化：當函數(shù)模板需要對某些類型進行特別處理，稱為函數(shù)模板的特化。
例如，我們編寫了一個泛化的比較程序
templateint?compare(const?T?&left,?const?T&right)
{
????std::cout?<<"in?template..."?<<std::endl;
????return?(left?-?right);
}123456
這個函數(shù)滿足我們的需求了么，顯然不，它支持常見int, float等類型的數(shù)據(jù)的比較，但是不支持char*(string)類型。
所以我們必須對其進行特化，以讓它支持兩個字符串的比較,因此我們實現(xiàn)了如下的特化函數(shù)。
template?<?>
int?compare(const?char*?left,?const?char*?right)
{
????std::cout?<<"in?special?template<?>..."?<<std::endl;
????return?strcmp(left,?right);
}1234567
也可以
template?<?>
int?compare(const?char*?left,?const?char*?right)
{
????std::cout?<<"in?special?template<?>..."?<<std::endl;
????return?strcmp(left,?right);
}1234567示例程序1–比較兩個數(shù)據(jù)
#include#include///??模版特化
templateint?compare(const?T?left,?const?T?right)
{
????std::cout?<<"in?template..."?<<std::endl;
????return?(left?-?right);
}
//??這個是一個特化的函數(shù)模版
template?<?>int?compare(const?char*?left,?const?char*?right)
{
????std::cout?<<"in?special?template<?>..."?<<std::endl;
????return?strcmp(left,?right);
}
//??特化的函數(shù)模版,?兩個特化的模版本質(zhì)相同,?因此編譯器會報錯
//?error:?redefinition?of?'int?compare(T,?T)?[with?T?=?const?char*]'|
//template?<?>//int?compare(const?char*?left,?const?char*?right)
//{
//????std::cout?<<"in?special?template<?>..."?<<std::endl;
//
//????return?strcmp(left,?right);
//}
//??這個其實本質(zhì)是函數(shù)重載
int?compare(char*?left,?char*?right)
{
????std::cout?<<"in?overload?function..."?<<std::endl;
????return?strcmp(left,?right);
}
int?main(?)
{
????compare(1,?4);
????const?char?*left?=?"gatieme";
????const?char?*right?=?"jeancheng";
????compare(left,?right);
????return?0;
}123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051
函數(shù)模版的特化，當函數(shù)調(diào)用發(fā)現(xiàn)有特化后的匹配函數(shù)時，會優(yōu)先調(diào)用特化的函數(shù)，而不再通過函數(shù)模版來進行實例化。
示例程序二-判斷兩個數(shù)據(jù)是否相等
#include#includeusing?namespace?std;
//函數(shù)模板
templatebool?IsEqual(T?t1,T?t2){
????return?t1==t2;
}
template<>?//函數(shù)模板特化
bool?IsEqual(char?*t1,char?*t2){
????return?strcmp(t1,t2)==0;
}
int?main(int?argc,?char*?argv[])
{
????char?str1[]="abc";
????char?str2[]="abc";
????cout<<"函數(shù)模板和函數(shù)模板特化"<<endl;
????cout<<IsEqual(1,1)<<endl;
????cout<<IsEqual(str1,str2)<<endl;
????return?0;
}1234567891011121314151617181920212223242526類模版特化
類模板的特化：與函數(shù)模板類似，當類模板內(nèi)需要對某些類型進行特別處理時，使用類模板的特化。例如：
這里歸納了針對一個模板參數(shù)的類模板特化的幾種類型
一是特化為絕對類型；
二是特化為引用，指針類型；
三是特化為另外一個類模板。
這里用一個簡單的例子來說明這三種情況：
特化為絕對類型
也就是說直接為某個特定類型做特化，這是我們最常見的一種特化方式， 如特化為float, double等
#include#include#include//?general?version
templateclass?Compare
{
public:
????static?bool?IsEqual(const?T&?lh,?const?T&?rh)
????{
????????std::cout?<<"in?the?general?class..."?<<std::endl;
????????return?lh?==?rh;
????}
};
//?specialize?for?float
template<>class?Compare{
public:
????static?bool?IsEqual(const?float&?lh,?const?float&?rh)
????{
????????std::cout?<<"in?the?float?special?class..."?<<std::endl;
????????return?std::abs(lh?-?rh)?<?10e-3;
????}
};
//?specialize?for?double
template<>class?Compare{
public:
????static?bool?IsEqual(const?double&?lh,?const?double&?rh)
????{
????????std::cout?<<"in?the?double?special?class..."?<<std::endl;
????????return?std::abs(lh?-?rh)?<?10e-6;
????}
};
int?main(void)
{
????Comparecomp1;
????std::cout?<<comp1.IsEqual(3,?4)?<<std::endl;
????std::cout?<<comp1.IsEqual(3,?3)?<<std::endl;
????Comparecomp2;
????std::cout?<<comp2.IsEqual(3.14,?4.14)?<<std::endl;
????std::cout?<<comp2.IsEqual(3,?3)?<<std::endl;
????Comparecomp3;
????std::cout?<<comp3.IsEqual(3.14159,?4.14159)?<<std::endl;
????std::cout?<<comp3.IsEqual(3.14159,?3.14159)?<<std::endl;
????return?0;
}1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859
如果期望使用偏特化，那么
templateclass?A
{
}
templateclass?A{
}123456789特化為引用，指針類型
templatestruct?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*
templatestruct?iterator_traits{
??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*
templatestruct?iterator_traits{
??typedef?random_access_iterator_tag?iterator_category;
??typedef?_Tp?????????????????????????value_type;
??typedef?ptrdiff_t???????????????????difference_type;
??typedef?const?_Tp*??????????????????pointer;
??typedef?const?_Tp&??????????????????reference;
};12345678910111213141516171819202122232425262728
當然，除了T*, 我們也可以將T特化為 const T*, T&, const T&等，以下還是以T*為例：
//?specialize?for?T*
templateclass?Compare{
public:
????static?bool?IsEqual(const?T*?lh,?const?T*?rh)
????{
????????return?Compare::IsEqual(*lh,?*rh);
????}
};12345678910
這種特化其實是就不是一種絕對的特化， 它只是對類型做了某些限定，但仍然保留了其一定的模板性，這種特化給我們提供了極大的方便， 如這里， 我們就不需要對int*, float*, double*等等類型分別做特化了。
這其實是第二種方式的擴展，其實也是對類型做了某種限定，而不是絕對化為某個具體類型，如下：
//?specialize?for?vectortemplateclass?Compare<vector>
{
public:
????static?bool?IsEqual(const?vector&?lh,?const?vector&?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;
????}
};123456789101112131415161718
這就把IsEqual的參數(shù)限定為一種vector類型， 但具體是vector還是vector， 我們可以不關(guān)心， 因為對于這兩種類型，我們的處理方式是一樣的，我們可以把這種方式稱為“半特化”。
當然， 我們可以將其“半特化”為任何我們自定義的模板類類型：
//?specialize?for?any?template?class?type
templatestruct?SpecializedType
{
????T1?x1;
????T1?x2;
};
templateclass?Compare<SpecializedType>
{
public:
????static?bool?IsEqual(const?SpecializedType&?lh,?const?SpecializedType&?rh)
????{
????????return?Compare::IsEqual(lh.x1?+?lh.x2,?rh.x1?+?rh.x2);
????}
};12345678910111213141516
這就是三種類型的模板特化， 我們可以這么使用這個Compare類：
???//?int
????int?i1?=?10;
????int?i2?=?10;
????bool?r1?=?Compare::IsEqual(i1,?i2);
????//?float
????float?f1?=?10;
????float?f2?=?10;
????bool?r2?=?Compare::IsEqual(f1,?f2);
????//?double
????double?d1?=?10;
????double?d2?=?10;
????bool?r3?=?Compare::IsEqual(d1,?d2);
????//?pointer
????int*?p1?=?&i1;
????int*?p2?=?&i2;
????bool?r4?=?Compare::IsEqual(p1,?p2);
????//?vectorvectorv1;
????v1.push_back(1);
????v1.push_back(2);
????vectorv2;
????v2.push_back(1);
????v2.push_back(2);
????bool?r5?=?Compare<vector>::IsEqual(v1,?v2);
????//?custom?template?class?
????SpecializedTypes1?=?{10.1f,10.2f};
????SpecializedTypes2?=?{10.3f,10.0f};
????bool?r6?=?Compare<SpecializedType>::IsEqual(s1,?s2);
下載文檔
