C++ 模版與特化的詳解

時(shí)間：2018-11-29 09:16:01

關(guān)鍵字： c++ 模版特化

手機(jī)看文章

掃描二維碼
隨時(shí)隨地手機(jī)看文章

[導(dǎo)讀]模版與特化的概念函數(shù)模版與類模版C++中模板分為函數(shù)模板和類模板函數(shù)模板：是一種抽象函數(shù)定義，它代表一類同構(gòu)函數(shù)。類模板：是一種更高層次的抽象的類定義。特化的概念所謂特化，就是將泛型的東東搞得具體化一

模版與特化的概念

函數(shù)模版與類模版

C++中模板分為函數(shù)模板和類模板

函數(shù)模板：是一種抽象函數(shù)定義，它代表一類同構(gòu)函數(shù)。

類模板：是一種更高層次的抽象的類定義。

特化的概念

所謂特化，就是將泛型的東東搞得具體化一些，從字面上來解釋，就是為已有的模板參數(shù)進(jìn)行一些使其特殊化的指定，使得以前不受任何約束的模板參數(shù)，或受到特定的修飾（例如const或者搖身一變成為了指針之類的東東，甚至是經(jīng)過別的模板類包裝之后的模板類型）或完全被指定了下來。

模板特化的分類

針對(duì)特化的對(duì)象不同，分為兩類：函數(shù)模板的特化和類模板的特化

函數(shù)模板的特化

當(dāng)函數(shù)模板需要對(duì)某些類型進(jìn)行特化處理，稱為函數(shù)模板的特化。

類模板的特化

當(dāng)類模板內(nèi)需要對(duì)某些類型進(jìn)行特別處理時(shí)，使用類模板的特化。

特化整體上分為全特化和偏特化?
* 全特化

就是模板中模板參數(shù)全被指定為確定的類型。

全特化也就是定義了一個(gè)全新的類型，全特化的類中的函數(shù)可以與模板類不一樣。

1234

偏特化

就是模板中的模板參數(shù)沒有被全部確定，需要編譯器在編譯時(shí)進(jìn)行確定。

全特化的標(biāo)志就是產(chǎn)生出完全確定的東西，而不是還需要在編譯期間去搜尋適合的特化實(shí)現(xiàn)，貌似在我的這種理解下，全特化的東西不論是類還是函數(shù)都有這樣的特點(diǎn)，

模板函數(shù)只能全特化，沒有偏特化（以后可能有）。

模板類是可以全特化和偏特化的。

template <>然后是完全和模板類型沒有一點(diǎn)關(guān)系的類實(shí)現(xiàn)或者函數(shù)定義，如果你要說，都完全確定下來了，那還搞什么模板呀，直接定義不就完事了？
但是很多時(shí)候，我們既需要一個(gè)模板能應(yīng)對(duì)各種情形，又需要它對(duì)于某個(gè)特定的類型（比如bool）有著特別的處理，這種情形下特化就是需要的了。

全特化的標(biāo)志：template <>然后是完全和模板類型沒有一點(diǎn)關(guān)系的類實(shí)現(xiàn)或者函數(shù)定義偏特化的標(biāo)志：template函數(shù)模版特化

目前的標(biāo)準(zhǔn)中，模板函數(shù)只能全特化，沒有偏特化

至于為什么函數(shù)不能偏特化，似乎不是因?yàn)檎Z言實(shí)現(xiàn)不了，而是因?yàn)槠鼗墓δ芸梢酝ㄟ^函數(shù)的重載完成。

函數(shù)模版的特化技巧

函數(shù)模板的特化：當(dāng)函數(shù)模板需要對(duì)某些類型進(jìn)行特別處理，稱為函數(shù)模板的特化。

例如，我們編寫了一個(gè)泛化的比較程序

templateint?compare(const?T?&left,?const?T&right)
{
????std::cout?<<"in?template..."?<<std::endl;
????return?(left?-?right);
}

123456

這個(gè)函數(shù)滿足我們的需求了么，顯然不，它支持常見int, float等類型的數(shù)據(jù)的比較，但是不支持char*(string)類型。

所以我們必須對(duì)其進(jìn)行特化，以讓它支持兩個(gè)字符串的比較,因此我們實(shí)現(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–比較兩個(gè)數(shù)據(jù)

#include#include///??模版特化

templateint?compare(const?T?left,?const?T?right)
{
????std::cout?<<"in?template..."?<<std::endl;
????return?(left?-?right);
}


//??這個(gè)是一個(gè)特化的函數(shù)模版
template?<?>int?compare(const?char*?left,?const?char*?right)
{
????std::cout?<<"in?special?template<?>..."?<<std::endl;

????return?strcmp(left,?right);
}
//??特化的函數(shù)模版,?兩個(gè)特化的模版本質(zhì)相同,?因此編譯器會(huì)報(bào)錯(cuò)
//?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);
//}


//??這個(gè)其實(shí)本質(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ù)模版的特化，當(dāng)函數(shù)調(diào)用發(fā)現(xiàn)有特化后的匹配函數(shù)時(shí)，會(huì)優(yōu)先調(diào)用特化的函數(shù)，而不再通過函數(shù)模版來進(jìn)行實(shí)例化。

示例程序二-判斷兩個(gè)數(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ù)模板類似，當(dāng)類模板內(nèi)需要對(duì)某些類型進(jìn)行特別處理時(shí)，使用類模板的特化。例如：

這里歸納了針對(duì)一個(gè)模板參數(shù)的類模板特化的幾種類型

一是特化為絕對(duì)類型；

二是特化為引用，指針類型；

三是特化為另外一個(gè)類模板。

這里用一個(gè)簡(jiǎn)單的例子來說明這三種情況：

特化為絕對(duì)類型

也就是說直接為某個(gè)特定類型做特化，這是我們最常見的一種特化方式，如特化為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

當(dāng)然，除了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

這種特化其實(shí)是就不是一種絕對(duì)的特化，它只是對(duì)類型做了某些限定，但仍然保留了其一定的模板性，這種特化給我們提供了極大的方便，如這里，我們就不需要對(duì)int*, float*, double*等等類型分別做特化了。

這其實(shí)是第二種方式的擴(kuò)展，其實(shí)也是對(duì)類型做了某種限定，而不是絕對(duì)化為某個(gè)具體類型，如下：

//?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)心，因?yàn)閷?duì)于這兩種類型，我們的處理方式是一樣的，我們可以把這種方式稱為“半特化”。

當(dāng)然，我們可以將其“半特化”為任何我們自定義的模板類類型：

//?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

這就是三種類型的模板特化，我們可以這么使用這個(gè)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);