C++：模闆初階（泛型程式設計、函數模闆、類模闆）

文章目錄

• 1 泛型程式設計
• 2 函數模闆
• • 2.1 函數模闆概念
  • 2.2 函數模闆格式
  • 2.3 函數模闆的原理
  • 2.4 函數模闆的執行個體化
  • 2.5 模闆參數的比對原則
• 3 類模闆
• • 3.1 類模闆的定義格式
  • 3.2 類模闆的執行個體化

1 泛型程式設計

所謂泛型，也就是通用型的意思。

在以往編寫代碼時，我們常常會需要實作兩個數的交換（Swap函數），在C語言中，由于沒有函數重載的概念，如果想實作不同類型資料的交換，就需要編寫不同名但本質功能相同的函數；在C++中，則可以通過函數重載，編寫同名的資料交換函數，雖然相比之下，函數重載避免了要取不同函數名的麻煩，但對于不同類型資料的交換仍需要單獨編寫函數，而重載的函數僅僅是類型不同，功能都是相似的，這樣代碼的複用率比較低，隻要有新類型操作的需要，就得由使用者自己增加對應的函數，且代碼的可維護性比較低，一個出錯，可能所有的重載均出錯。

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

在實際生産生活中，對于造型相同的産品，通常會使用模具等來進行生産。那是否也能提供給編譯器一個模具，讓編譯器根據不同的類型利用該模具來生成代碼呢？

基于此，C++中提出了泛型程式設計的概念：編寫與類型無關的通用代碼，是代碼複用的一種手段。模闆是泛型程式設計的基礎。

其中，模闆可以分為：

• 函數模闆
• 類模闆

2 函數模闆

2.1 函數模闆概念

函數模闆代表了一個函數家族，該函數模闆與類型無關，在使用時被參數化，根據實參類型産生函數的特定類型版本。

2.2 函數模闆格式

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

或

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

傳回值類型 函數名(參數清單){}

注意：typename 是用來定義模闆參數的關鍵字，也可以使用 class（但不能使用 struct 代替 class）

示例代碼：

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

2.3 函數模闆的原理

函數模闆是一個藍圖，它本身并不是函數，是編譯器根據使用方式産生特定具體類型函數的模具，是以其實模闆就是将本來應該我們做的重複的事情交給了編譯器。

說明：在編譯器編譯階段，對于模闆函數的使用，編譯器需要根據傳入的實參類型來推演生成對應類型的函數以供調用。比如：當以 double 類型使用函數模闆時，編譯器通過對實參類型的推演，将 T 确定為 double 類型，然後産生一份專門處理 double 類型的代碼，對于其它類型也是如此。

2.4 函數模闆的執行個體化

用不同類型的參數使用函數模闆時，稱為函數模闆的執行個體化。模闆參數執行個體化分為：

隐式執行個體化

和

顯示執行個體化

。

• 隐式執行個體化：讓編譯器根據實參推演模闆函數的執行個體類型

  示例代碼：

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類型，但模闆參數清單中隻有一個T，
	編譯器無法确定此處到底該将T确定為 int 或者 double 類型而報錯
	注意：在模闆中，編譯器一般不會進行類型轉換操作，因為一旦轉化出問題，編譯器就需要背黑鍋
	Add(a1, d1);
	*/

	// 此時有兩種處理方式：1. 使用者自己來強制轉化 2. 使用顯式執行個體化
	Add(a1, (int)d1);
	return 0;
}
           

• 顯式執行個體化：在函數名後的

  <>

  中指定模闆參數的實際類型；如果類型不比對，編譯器會嘗試進行隐式類型轉換，如果無法轉換成功，編譯器将會報錯。

  示例代碼：

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

int main(void){

	int a = 10;
	double b = 20.0;

	// 顯式執行個體化
	Add<int>(a, b);
	return 0;
}
           

2.5 模闆參數的比對原則

• 一個非模闆函數可以和一個同名的函數模闆同時存在，而且該函數模闆還可以被執行個體化為這個非模闆函數

// 專門處理int的加法函數
int Add(int left, int right){
	return left + right;
}

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

void Test(){
	Add(1, 2); // 與非模闆函數比對，編譯器不需要特化
	Add<int>(1, 2); // 調用編譯器特化的Add版本
}
           

• 對于非模闆函數和同名函數模闆，如果其它條件都相同，在調用時會優先調用非模闆函數而不會從該模闆産生出一個執行個體。如果模闆可以産生一個具有更好比對的函數，那麼将選擇模闆

// 專門處理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函數
}
           

• 模闆函數不允許自動類型轉換，但普通函數可以進行自動類型轉換

3 類模闆

3.1 類模闆的定義格式

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

class 類模闆名

{

    // 類内成員定義

};

示例代碼：

// 動态順序表
// 注意：Vector不是具體的類，是編譯器根據被執行個體化的類型生成具體類的模具
template<class T>
class Vector{
public:
	Vector(size_t capacity = 10)
		: _pData(new T[capacity])
		, _size(0)
		, _capacity(capacity)
	{}

	// 使用析構函數示範：在類中聲明，在類外定義。
	~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;
};

// 注意：類模闆中函數放在類外進行定義時，需要加模闆參數清單
template <class T>
Vector<T>::~Vector(){
	if (_pData)
		delete[] _pData;
	_size = _capacity = 0;
}
           

3.2 類模闆的執行個體化

類模闆執行個體化與函數模闆執行個體化不同，類模闆執行個體化需要在類模闆名字後跟

<>

，然後将執行個體化的類型放在 <> 中即可，類模闆名字不是真正的類，而執行個體化的結果才是真正的類。

// Vector類名，Vector<int>才是類型
Vector<int> s1;
Vector<double> s2;
           

以上是我對C++中模闆初階相關知識的一些學習記錄總結，如有錯誤，希望大家幫忙指正，也歡迎大家給予建議和讨論，謝謝！