泛型編程
如果讓你編寫一個函數(shù)，用于兩個數(shù)的交換。在C語言中，我們會用如下方法：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
// 交換兩個整型void Swapi(int* p1, int* p2){ int tmp = *p1; *p1 = *p2; *p2 = tmp;}// 交換兩個雙精度浮點型void Swapd(double* p1, double* p2){ double tmp = *p1; *p1 = *p2; *p2 = tmp;} |
因為C語言不支持函數(shù)重載，所以用于交換不同類型變量的函數(shù)的函數(shù)名是不能相同的，并且傳參形式必須是址傳遞，不能是值傳遞。
而在學習了C++的函數(shù)重載和引用后，我們又會用如下方法實現(xiàn)兩個數(shù)的交換：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
// 交換兩個整型void Swap(int& x, int& y){ int tmp = x; x = y; y = tmp;}// 交換兩個雙精度浮點型void Swap(double& x, double& y){ double tmp = x; x = y; y = tmp;} |
C++的函數(shù)重載使得用于交換不同類型變量的函數(shù)可以擁有相同的函數(shù)名，并且傳參使用引用傳參，使得代碼看起來不那么晦澀難懂。
但是，這種代碼仍然存在它的不足之處：
1、重載的多個函數(shù)僅僅只是類型不同，代碼的復用率比較低，只要出現(xiàn)新的類型需要交換，就需要新增對應(yīng)的重載函數(shù)。
2、代碼的可維護性比較低，其中一個重載函數(shù)出現(xiàn)錯誤可能意味著所有的重載函數(shù)都出現(xiàn)了錯誤。
那我們能否告訴編譯器一個模子，讓編譯器根據(jù)不同的類型利用該模子來生成相應(yīng)的代碼呢？
就像做月餅的模子一樣，我們放入不同顏色的材料，就能得到形狀相同但顏色不同的月餅。
如果在C++中，也能夠存在這樣一個模具，通過給這個模具填充不同顏色的材料(類型)，從而得到形狀相同但顏色不同的月餅(生成具體類型的代碼)，那將會大大減少代碼的冗余。巧的是前人早已將樹栽好，我們只需在此乘涼。
泛型編程：編寫與類型無關(guān)的通用代碼，是代碼復用的一種手段。模板是泛型編程的基礎(chǔ)。
函數(shù)模板
函數(shù)模板的概念
函數(shù)模板代表了一個函數(shù)家族，該函數(shù)模板與類型無關(guān)，在使用時被參數(shù)化，根據(jù)實參類型產(chǎn)生函數(shù)的特定類型版本。
函數(shù)模板的格式
template<typename T1,typename T2,…,typename Tn>
返回類型 函數(shù)名(參數(shù)列表)
{
//函數(shù)體
}
例如：
|
1
2
3
4
5
6
7
|
template<typename T>void Swap(T& x, T& y){ T tmp = x; x = y; y = tmp;} |
注意：typename是用來定義模板參數(shù)的關(guān)鍵字，也可以用class代替，但是不能用struct代替。
函數(shù)模板的原理
那么函數(shù)模板的底層原理是什么呢？大家都知道，瓦特改良蒸汽機，人類開始了工業(yè)革命，解放了生產(chǎn)力。機器生產(chǎn)淘汰掉了很多手工產(chǎn)品。其本質(zhì)就是將重復的工作交給了機器去完成。有人給出了論調(diào)：懶人創(chuàng)造世界！
馬云：世界是懶人創(chuàng)造的
懶不是傻懶，如果你想少干，就要想出懶的方法。要懶出風格，懶出境界。
函數(shù)模板是一個藍圖，它本身并不是函數(shù)。是編譯器產(chǎn)生特定具體類型函數(shù)的模具。所以其實模板就是將本來應(yīng)該我們做的重復的事情交給了編譯器。
在編譯器編譯階段，對于函數(shù)模板的使用，編譯器需要根據(jù)傳入的實參類型來推演生成對應(yīng)類型的函數(shù)以供調(diào)用。比如，當用int類型使用函數(shù)模板時，編譯器通過對實參類型的推演，將T確定為int類型，然后產(chǎn)生一份專門處理int類型的代碼，對于double類型也是如此。
函數(shù)模板的實例化
用不同類型的參數(shù)使用模板時，稱為模板的實例化。模板實例化分為隱式實例化和顯示實例化。
一、隱式實例化：讓編譯器根據(jù)實參推演模板參數(shù)的實際類型
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
#include <iostream>using namespace std;template<typename T>T Add(const T& x, const T& y){ return x + y;}int main(){ int a = 10, b = 20; int c = Add(a, b); //編譯器根據(jù)實參a和b推演出模板參數(shù)為int類型 return 0;} |
特別注意：使用模板時，編譯器一般不會進行類型轉(zhuǎn)換操作。所以，以下代碼將不能通過編譯：
|
1
2
3
|
int a = 10;double b = 1.1;int c = Add(a, b); |
因為在編譯期間，編譯器根據(jù)實參推演模板參數(shù)的實際類型時，根據(jù)實參a將T推演為int，根據(jù)實參b將T推演為double，但是模板參數(shù)列表中只有一個T，編譯器無法確定此處應(yīng)該將T確定為int還是double。
此時，我們有兩種處理方式，第一種就是我們在傳參時將b強制轉(zhuǎn)換為int類型，第二種就是使用下面說到的顯示實例化。
二、顯示實例化：在函數(shù)名后的<>中指定模板參數(shù)的實際類型
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
#include <iostream>using namespace std;template<typename T>T Add(const T& x, const T& y){ return x + y;}int main(){ int a = 10; double b = 1.1; int c = Add<int>(a, b); //指定模板參數(shù)的實際類型為int return 0;} |
注意：使用顯示實例化時，如果傳入的參數(shù)類型與模板參數(shù)類型不匹配，編譯器會嘗試進行隱式類型轉(zhuǎn)換，如果無法轉(zhuǎn)換成功，則編譯器將會報錯。
函數(shù)模板的匹配原則
一、一個非模板函數(shù)可以和一個同名的函數(shù)模板同時存在，而且該函數(shù)模板還可以被實例化為這個非模板函數(shù)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
#include <iostream>using namespace std;//專門用于int類型加法的非模板函數(shù)int Add(const int& x, const int& y){ return x + y;}//通用類型加法的函數(shù)模板template<typename T>T Add(const T& x, const T& y){ return x + y;}int main(){ int a = 10, b = 20; int c = Add(a, b); //調(diào)用非模板函數(shù)，編譯器不需要實例化 int d = Add<int>(a, b); //調(diào)用編譯器實例化的Add函數(shù) return 0;} |
二、對于非模板函數(shù)和同名的函數(shù)模板，如果其他條件都相同，在調(diào)用時會優(yōu)先調(diào)用非模板函數(shù)，而不會從該模板產(chǎn)生出一個實例。如果模板可以產(chǎn)生一個具有更好匹配的函數(shù)，那么選擇模板
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
#include <iostream>using namespace std;//專門用于int類型加法的非模板函數(shù)int Add(const int& x, const int& y){ return x + y;}//通用類型加法的函數(shù)模板template<typename T>T Add(const T& x, const T& y){ return x + y;}int main(){ int a = Add(10, 20); //與非模板函數(shù)完全匹配，不需要函數(shù)模板實例化 int b = Add(2, 2.2); //函數(shù)模板可以生成更加匹配的版本，編譯器會根據(jù)實參生成更加匹配的Add函數(shù) return 0;} |
三、模板函數(shù)不允許自動類型轉(zhuǎn)換，但普通函數(shù)可以進行自動類型轉(zhuǎn)換
|
1
2
3
4
5
6
7
8
9
10
11
12
|
#include <iostream>using namespace std;template<typename T>T Add(const T& x, const T& y){ return x + y;}int main(){ int a = Add(2, 2.2); //模板函數(shù)不允許自動類型轉(zhuǎn)換，不能通過編譯 return 0;} |
因為模板函數(shù)不允許自動類型轉(zhuǎn)換，所以不會將2自動轉(zhuǎn)換為2.0，或是將2.2自動轉(zhuǎn)換為2。
類模板
類模板的定義格式
template<class T1,class T2,…,class Tn>
class 類模板名
{
//類內(nèi)成員聲明
};
例如：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
template<class T>class Score{public: void Print() { cout << "數(shù)學:" << _Math << endl; cout << "語文:" << _Chinese << endl; cout << "英語:" << _English << endl; }private: T _Math; T _Chinese; T _English;}; |
注意：類模板中的成員函數(shù)若是放在類外定義時，需要加模板參數(shù)列表。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
template<class T>class Score{public: void Print();private: T _Math; T _Chinese; T _English;};//類模板中的成員函數(shù)在類外定義，需要加模板參數(shù)列表template<class T>void Score<T>::Print(){ cout << "數(shù)學:" << _Math << endl; cout << "語文:" << _Chinese << endl; cout << "英語:" << _English << endl;} |
除此之外，類模板不支持分離編譯，即聲明在xxx.h文件中，而定義卻在xxx.cpp文件中。
類模板的實例化
類模板實例化與函數(shù)模板實例化不同，類模板實例化需要在類模板名字后面根<>，然后將實例化的類型放在<>中即可。
|
1
2
3
|
//Score不是真正的類，Score<int>和Score<double>才是真正的類Score<int> s1;Score<double> s2; |
注意：類模板名字不是真正的類，而實例化的結(jié)果才是真正的類。
總結(jié)
到此這篇關(guān)于C++模板基礎(chǔ)之函數(shù)模板與類模板的文章就介紹到這了,更多相關(guān)C++函數(shù)模板與類模板內(nèi)容請搜索服務(wù)器之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持服務(wù)器之家！
原文鏈接：https://blog.csdn.net/chenlong_cxy/article/details/117629686
