模版與特化的概念
函數模版與類模版
C++中模板分為函數模板和類模板
函數模板：是一種抽象函數定義，它代表一類同構函數。
類模板：是一種更高層次的抽象的類定義。
特化的概念
所謂特化，就是將泛型的東東搞得具體化一些，從字面上來解釋，就是為已有的模板參數進行一些使其特殊化的指定，使得以前不受任何約束的模板參數，或受到特定的修飾（例如const或者搖身一變成為了指針之類的東東，甚至是經過別的模板類包裝之后的模板類型）或完全被指定了下來。
模板特化的分類
針對特化的對象不同，分為兩類：函數模板的特化和類模板的特化
函數模板的特化
當函數模板需要對某些類型進行特化處理，稱為函數模板的特化。
類模板的特化
當類模板內需要對某些類型進行特別處理時，使用類模板的特化。
特化整體上分為全特化和偏特化?
* 全特化
就是模板中模板參數全被指定為確定的類型。 全特化也就是定義了一個全新的類型，全特化的類中的函數可以與模板類不一樣。
1234
偏特化
就是模板中的模板參數沒有被全部確定，需要編譯器在編譯時進行確定。
全特化的標志就是產生出完全確定的東西，而不是還需要在編譯期間去搜尋適合的特化實現，貌似在我的這種理解下，全特化的 東西不論是類還是函數都有這樣的特點，
模板函數只能全特化，沒有偏特化（以后可能有）。
模板類是可以全特化和偏特化的。
template <>然后是完全和模板類型沒有一點關系的類實現或者函數定義，如果你要說，都完全確定下來了，那還搞什么模板呀，直接定義不就完事了？
但是很多時候，我們既需要一個模板能應對各種情形，又需要它對于某個特定的類型（比如bool）有著特別的處理，這種情形下特化就是需要的了。
全特化的標志：template <>然后是完全和模板類型沒有一點關系的類實現或者函數定義偏特化的標志：template函數模版特化
目前的標準中，模板函數只能全特化，沒有偏特化
至于為什么函數不能偏特化，似乎不是因為語言實現不了，而是因為偏特化的功能可以通過函數的重載完成。
函數模版的特化技巧
函數模板的特化：當函數模板需要對某些類型進行特別處理，稱為函數模板的特化。
例如，我們編寫了一個泛化的比較程序
templateint?compare(const?T?&left,?const?T&right)
{
????std::cout?<<"in?template..."?<<std::endl;
????return?(left?-?right);
}123456
這個函數滿足我們的需求了么，顯然不，它支持常見int, float等類型的數據的比較，但是不支持char*(string)類型。
所以我們必須對其進行特化，以讓它支持兩個字符串的比較,因此我們實現了如下的特化函數。
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–比較兩個數據
#include#include///??模版特化
templateint?compare(const?T?left,?const?T?right)
{
????std::cout?<<"in?template..."?<<std::endl;
????return?(left?-?right);
}
//??這個是一個特化的函數模版
template?<?>int?compare(const?char*?left,?const?char*?right)
{
????std::cout?<<"in?special?template<?>..."?<<std::endl;
????return?strcmp(left,?right);
}
//??特化的函數模版,?兩個特化的模版本質相同,?因此編譯器會報錯
//?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);
//}
//??這個其實本質是函數重載
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
函數模版的特化，當函數調用發(fā)現有特化后的匹配函數時，會優(yōu)先調用特化的函數，而不再通過函數模版來進行實例化。
示例程序二-判斷兩個數據是否相等
#include#includeusing?namespace?std;
//函數模板
templatebool?IsEqual(T?t1,T?t2){
????return?t1==t2;
}
template<>?//函數模板特化
bool?IsEqual(char?*t1,char?*t2){
????return?strcmp(t1,t2)==0;
}
int?main(int?argc,?char*?argv[])
{
????char?str1[]="abc";
????char?str2[]="abc";
????cout<<"函數模板和函數模板特化"<<endl;
????cout<<IsEqual(1,1)<<endl;
????cout<<IsEqual(str1,str2)<<endl;
????return?0;
}1234567891011121314151617181920212223242526類模版特化
類模板的特化：與函數模板類似，當類模板內需要對某些類型進行特別處理時，使用類模板的特化。例如：
這里歸納了針對一個模板參數的類模板特化的幾種類型
一是特化為絕對類型；
二是特化為引用，指針類型；
三是特化為另外一個類模板。
這里用一個簡單的例子來說明這三種情況：
特化為絕對類型
也就是說直接為某個特定類型做特化，這是我們最常見的一種特化方式， 如特化為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的參數限定為一種vector類型， 但具體是vector還是vector， 我們可以不關心， 因為對于這兩種類型，我們的處理方式是一樣的，我們可以把這種方式稱為“半特化”。
當然， 我們可以將其“半特化”為任何我們自定義的模板類類型：
//?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);
下載文檔
