各位CSDN的uu們你們好呀，今天，小雅蘭的內容是C++中的模板初階的內容，下面，讓我們進入C++模板的世界吧！！！

---

1. 泛型編程

2. 函數(shù)模板

3. 類模板

---

泛型編程

如何實現(xiàn)一個通用的交換函數(shù)呢？

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;
}......

這些函數(shù)只有類型不一樣，其余的都是一樣的！！

使用函數(shù)重載雖然可以實現(xiàn)，但是有一下幾個不好的地方：

• 重載的函數(shù)僅僅是類型不同，代碼復用率比較低，只要有新類型出現(xiàn)時，就需要用戶自己增加對應的函數(shù)
• 代碼的可維護性比較低，一個出錯可能所有的重載均出錯

那能否告訴編譯器一個模子，讓編譯器根據(jù)不同的類型利用該模子來生成代碼呢？

如果在C++中，也能夠存在這樣一個模具，通過給這個模具中填充不同材料(類型)，來獲得不同材料的鑄件(即生成具體類型的代碼），那將會節(jié)省許多頭發(fā)。巧的是前人早已將樹栽好，我們只需在此乘涼。

泛型編程：編寫與類型無關的通用代碼，是代碼復用的一種手段。模板是泛型編程的基礎。 ?

---

函數(shù)模板

函數(shù)模板概念

函數(shù)模板代表了一個函數(shù)家族，該函數(shù)模板與類型無關，在使用時被參數(shù)化，根據(jù)實參類型產生函數(shù)的特定類型版本。

函數(shù)模板格式

template<typename T1,typename T2,......,typename Tn>

返回值類型 函數(shù)名(參數(shù)列表){}

template<typename T>void Swap( T& left, T& right)
{T temp = left;left = right;right = temp;
}

注意：typename是用來定義模板參數(shù)關鍵字，也可以使用class(切記：不能使用struct代替class)

template<typename T>
void Swap(T& left, T& right)
{T temp = left;left = right;right = temp;
}
int main()
{int a = 0;int b = 1;double c = 1.1;double d = 2.2;//調用的不是同一個函數(shù)Swap(a, b);Swap(c, d);return 0;
}

可是我們只寫了一個函數(shù)模板呀，并沒有寫函數(shù)，那這究竟是怎么回事呢？

下面，我們來看看函數(shù)模板的原理！?

函數(shù)模板的原理

那么如何解決上面的問題呢？大家都知道，瓦特改良蒸汽機，人類開始了工業(yè)革命，解放了生產力。機器生 產淘汰掉了很多手工產品。本質是什么，重復的工作交給了機器去完成。有人給出了論調：懶人創(chuàng)造世界。

函數(shù)模板是一個藍圖，它本身并不是函數(shù)，是編譯器用使用方式產生特定具體類型函數(shù)的模具。所以其實模 板就是將本來應該我們做的重復的事情交給了編譯器。

模板的實例化！！！?

在編譯器編譯階段，對于模板函數(shù)的使用，編譯器需要根據(jù)傳入的實參類型來推演生成對應類型的函數(shù)以供調用。比如：當用double類型使用函數(shù)模板時，編譯器通過對實參類型的推演，將T確定為double類型，然 后產生一份專門處理double類型的代碼，對于字符類型也是如此。 ?

也可以這么寫：把typename換成class?

函數(shù)模板的實例化

用不同類型的參數(shù)使用函數(shù)模板時，稱為函數(shù)模板的實例化。模板參數(shù)實例化分為：隱式實例化和顯式實例化。

隱式實例化：讓編譯器根據(jù)實參推演模板參數(shù)的實際類型

template<class T>
T Add(const T& left, const T& right)
{
?? ?return left + right;
}

int main()
{
?? ?int a1 = 10, a2 = 20;
?? ?double d1 = 10.0, d2 = 20.0;
?? ?Add(a1, a2);
?? ?Add(d1, d2);
?? ?/*
?? ?該語句不能通過編譯，因為在編譯期間，當編譯器看到該實例化時，需要推演其實參類型
?? ?通過實參a1將T推演為int，通過實參d1將T推演為double類型，但模板參數(shù)列表中只有一個T，
?? ?編譯器無法確定此處到底該將T確定為int 或者 double類型而報錯
?? ?注意：在模板中，編譯器一般不會進行類型轉換操作，因為一旦轉化出問題，編譯器就需要背黑鍋
?? ?Add(a1, d1);
?? ?*/
?? ?// 此時有兩種處理方式：1. 用戶自己來強制轉化 2. 使用顯式實例化
?? ?//Add(a, (int)d);
?? ?return 0;
}

模板參數(shù)語法 很類似函數(shù)參數(shù)

函數(shù)參數(shù)定義的是形參對象

模板參數(shù)定義的是類型

template<class X,class Y>
void func(const X& x, const Y& y)
{cout << x << endl;cout << y << endl;
}
int main()
{func(1, 2);func(1.1, 2.2);func(1.1, 2);return 0;
}

顯式實例化：在函數(shù)名后的<>中指定模板參數(shù)的實際類型

int main(void)

{

????????int a = 10;

????????double b = 20.0;

????????// 顯式實例化

????????Addint>(a, b);

????????return 0;

}

如果類型不匹配，編譯器會嘗試進行隱式類型轉換，如果無法轉換成功編譯器將會報錯。

模板參數(shù)的匹配原則

// 通用加法函數(shù)
template<class T>
T Add(T left, T right)
{
?? ?return left + right;
}

template<class T>
T* f(int n)
{
?? ?T* p = new T[n];
?? ?return p;
}

int main()
{
?? ?// 推演實例化
?? ?// 函數(shù)參數(shù)傳遞，推出模板參數(shù)的類型，生成對應的函數(shù)
?? ?//func(1, 2);
?? ?//func(1.1, 2.2);
?? ?//func(1.1, 2);

?? ?cout << Add(1, (int)2.2) << endl;

?? ?// 顯式實例化
?? ?cout << Add<int>(1, 2.2) << endl;
?? ?cout << Add<double> (1, 2.2) << endl;

?? ?// 只能顯示實例化調用
?? ?double* p = f<double>(10);

?? ?return 0;
}

?

一個非模板函數(shù)可以和一個同名的函數(shù)模板同時存在，而且該函數(shù)模板還可以被實例化為這個非模板函數(shù)。

// 專門處理int的加法函數(shù)
int Add(int left, int right)
{return left + right;
}// 通用加法函數(shù)
template<class T>
T Add(T left, T right)
{return left + right;
}void Test()
{Add(1, 2); // 與非模板函數(shù)匹配，編譯器不需要特化Add<int>(1, 2); // 調用編譯器特化的Add版本
}

對于非模板函數(shù)和同名函數(shù)模板，如果其他條件都相同，在調動時會優(yōu)先調用非模板函數(shù)而不會從該模板產生出一個實例。如果模板可以產生一個具有更好匹配的函數(shù)， 那么將選擇模板。

// 專門處理int的加法函數(shù)
int Add(int left, int right)
{return left + right;
}
// 通用加法函數(shù)
template<class T1, class T2>
T1 Add(T1 left, T2 right)
{return left + right;
}void Test()
{Add(1, 2); // 與非函數(shù)模板類型完全匹配，不需要函數(shù)模板實例化Add(1, 2.0); // 模板函數(shù)可以生成更加匹配的版本，編譯器根據(jù)實參生成更加匹配的Add函數(shù)
}

模板函數(shù)不允許自動類型轉換，但普通函數(shù)可以進行自動類型轉換。

---

類模板

類模板的定義格式

template<class T1, class T2, ..., class Tn>

class 類模板名

{

????????// 類內成員定義

};

// 類模板
template<class T>
class Stack
{
public:Stack(int capacity = 4){cout << "Stack(int capacity = 4)" << endl;_a = new T[capacity];_top = 0;_capacity = capacity;}~Stack(){cout << "~Stack()" << endl;delete[] _a;_a = nullptr;_top = 0;_capacity = 0;}
private:T* _a;int  _top;int  _capacity;
};int main()
{// 顯示實例化Stack<int> st1;  // intStack<double> st2;  // double//vector<int> v1;//vector<int> v2;//list<int> lt;//stack<double> st;return 0;
}

// 動態(tài)順序表
// 注意：Vector不是具體的類，是編譯器根據(jù)被實例化的類型生成具體類的模具
template<class T>
class Vector
{
public:Vector(size_t capacity = 10): _pData(new T[capacity]), _size(0), _capacity(capacity){}// 使用析構函數(shù)演示：在類中聲明，在類外定義。~Vector();void PushBack(const T& data)；void PopBack();size_t Size() { return _size;}T& operator[](size_t pos){assert(pos < _size);return _pData[pos];}
private:T* _pData;size_t _size;size_t _capacity;
};
// 注意：類模板中函數(shù)放在類外進行定義時，需要加模板參數(shù)列表
template <class T>
Vector<T>::~Vector()
{if (_pData)delete[] _pData;_size = _capacity = 0;
}

類模板的實例化

類模板實例化與函數(shù)模板實例化不同，類模板實例化需要在類模板名字后跟<>，然后將實例化的類型放在<>中即可，類模板名字不是真正的類，而實例化的結果才是真正的類。

// Vector類名，Vector才是類型

Vector< int> s1;

Vector<double> s2;

---