泛型編程
泛型編程，泛型即是指具有在多種數據類型上皆可操作的含義，其實就是能夠幫助開發者編寫完全一般化並可重複使用的算法，同樣的工作不需要做多次，同樣的算法針對不同的類型也不應該寫多次，所以需要通過某種途徑，來使一個容器或者算法，能夠兼容所有的類型，這就是泛型編程。
void Swap(int& left, int& right) {
int temp = left;
left = right;
right = temp;
}
void Swap(double& left, double& right) {
double temp = left;
left = right;
right = temp;
}
void Swap(char& left, char& right) {
char temp = left;
left = right;
right = temp;
}
就比如非常常用的swap函數，雖然c++支持重載，但是如果對於這種函數我們每一個都要自己去實現，是一件很麻煩並且多餘的工作，因爲我們將重複邏輯的東西多次實現。
class Stack
{
private:
int capacity;
int size;
int* arr;
};
又比如一個數據結構，如果我們實現了一個棧，如果他此時要存儲其他的數據類型，那我們就必須還要重新修改一個，這無疑是多餘的。
所以,c++基於重載這一項機制，實現了模板編程，模板作爲類或者函數的藍圖，可以針對不同類型，來實現對應操作。
函數模板
函數模板
函數模板其實代表的是一個函數家族，，該函數模板與類型無關，在使用時被參數化，根據實參類型產生函數的特定
類型版本。
而模板函數則時通過函數模板來實例化的具體函數
用法
template<typename T1, typename T2,......,typename Tn>
//typename即類型名，也可以用class替代，這裏的class指的是類型，不能用struct替換
只需要在對應的函數前面加上這一句即可，然後將所有需要替換類型的參數改爲上面的T1,T2即可
template<class T>
void Swap(T& left, T& right) {
T temp = left;
left = right;
right = temp;
}
int main()
{
int i = 3, j = 4;
double a = 3.4, b = 5.6;
char x = 'x', y = 'y';
Swap(i, j);
Swap(a, b);
Swap(x, y);
cout << i << ' ' << j << endl;
cout << a << ' ' << b << endl;
cout << x << ' ' << y << endl;
}
可以看到，這樣就可以適用於多重類型。
函數模板的原理
下面來討論一下，當我們調用這個模板函數的時候，是通過這個模板函數來實現對應的功能？還是它可能會重載成其他函數，再調用其他的函數呢？
這是只需要看看彙編代碼就可以了
可以看到，它調用的是三個不同的函數，這時候就可以推論出來。
模板函數本身並不是一個函數，而是一個藍圖，通過識別我們傳入的參數，然後在底層生成一個該類型的模板函數，並調用該函數。
並且這個階段是在預處理的時候就進行了，因爲我們仔細思考一下，如果它是在編譯階段才進行函數的生成，那肯定是無法通過語法的檢查的，所以這一階段只能在預處理進行。
函數模板的實例化
模板的實例化有兩種方法，一種是顯式實例化，一種是隱式實例化
隱式實例化
template<class T> T Add(const T& left, const T& right)
{
return left + right;
}
int main()
{
int i = 3, j = 4;
double a = 3.4, b = 5.6;
Add(i, j);
Add(a, b);
/*
這時編譯器就會報錯，因爲需要通過參數推演出對應類型，但是此時就無法
推演出到底是將T推演成double還是將T推演成int
Add(i, a);
*/
// 此時有兩種處理方式：1. 用戶自己來強制轉化 2. 使用顯式實例化
Add(i, (int)a);
return 0;
}
顯式實例化
int main() {
int i = 3;
double x = 3.4;
// 顯式實例化
Add<int>(i, x);
return 0;
}
這種則是用尖括號來顯式的聲明，STL中的容器等就是採用這種顯式的實例化來明確參數的類型。
函數模板的匹配規則（引用）
- 一個非模板函數可以和一個同名的函數模板同時存在，而且該函數模板還可以被實例化爲這個非模板函數，這時如果使用隱式實例化，則會調用非模板函數，如果使用顯式實例化，則調用模板函數
//非模板函數
int Add(int left, int right)
{
return left + right;
}
template<class T>
T Add(T left, T right)
{
return left + right;
}
int main()
{
Add(1, 2); // 調用非模板函數
Add<int>(1, 2); // 調用模板函數
}
- 對於非模板函數和同名函數模板，如果其他條件都相同，在調動時會優先調用非模板函數而不會從該模板產生出一個實例。如果模板可以產生一個具有更好匹配的函數， 那麼將選擇模板
// 專門處理int的加法函數
int Add(int left, int right) {
return left + right;
}
// 通用加法函數
template<class T1, class T2>
T1 Add(T1 left, T2 right) {
return left + right;
}
void Test()
{
Add(1, 2); // 與非函數模板類型完全匹配，不需要函數模板實例化
Add(1, 2.0); // 模板函數可以生成更加匹配的版本，編譯器根據實參生成更加匹配的Add函 數
}
- 模板函數不允許自動類型轉換，但普通函數可以進行自動類型轉換
類模板
用法
類模板的用法和函數模板其實一樣
template<class T>
class Stack
{
private:
int capacity;
int size;
T* arr;
};
這裏的Stack不是一個具體的類，他是類模板，也就是一個藍圖，通過這個模板來識別參數的類型並生成對應的模板類。所以可以理解爲類模板是一個類家族，模板類是通過類模板實例化的具體類
如果類中的成員函數需要在類外定義的話，需要每一個函數前都要聲明一次類模板的參數列表
template<class T>
class Stack
{
public:
void push();
void pop();
private:
int capacity;
int size;
T* arr;
};
template<class T>
void Stack<T>::push()
{
}
template<class T>
void Stack<T>::pop()
{
}
還有一個需要注意的地方就是，類模板的所有成員函數都是模板函數
類模板的實例化
類模板只能夠通過顯式實例化
如STL中的幾個容器都是通過類模板實現的
stack<int> s1;
stack<double> s2;
stack<int>並不是類名，而是類型，stack纔是類名