泛型編程

 如果讓你編寫一個函數(shù)，用于兩個數(shù)的交換。在C語言中，我們會用如下方法：

// 交換兩個整型
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ù)的交換：

// 交換兩個整型
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)新的類型需要交換，就需要新增對應的重載函數(shù)。
 2、代碼的可維護性比較低，其中一個重載函數(shù)出現(xiàn)錯誤可能意味著所有的重載函數(shù)都出現(xiàn)了錯誤。

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

 就像做月餅的模子一樣，我們放入不同顏色的材料，就能得到形狀相同但顏色不同的月餅。

 如果在C++中，也能夠存在這樣一個模具，通過給這個模具填充不同顏色的材料(類型)，從而得到形狀相同但顏色不同的月餅(生成具體類型的代碼)，那將會大大減少代碼的冗余。巧的是前人早已將樹栽好，我們只需在此乘涼。

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

函數(shù)模板

函數(shù)模板的概念

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

函數(shù)模板的格式

template<typename T1,typename T2,…,typename Tn>
返回類型 函數(shù)名(參數(shù)列表)
{
  //函數(shù)體
}

例如：

template<typename T>
void Swap(T& x, T& y)
{
	T tmp = x;
	x = y;
	y = tmp;
}

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

函數(shù)模板的原理

 那么函數(shù)模板的底層原理是什么呢？大家都知道，瓦特改良蒸汽機，人類開始了工業(yè)革命，解放了生產(chǎn)力。機器生產(chǎn)淘汰掉了很多手工產(chǎn)品。其本質就是將重復的工作交給了機器去完成。有人給出了論調：懶人創(chuàng)造世界！

馬云：世界是懶人創(chuàng)造的

懶不是傻懶，如果你想少干，就要想出懶的方法。要懶出風格，懶出境界。

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

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

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

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

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

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

特別注意：使用模板時，編譯器一般不會進行類型轉換操作。所以，以下代碼將不能通過編譯：

	int a = 10;
	double b = 1.1;
	int c = Add(a, b);

 因為在編譯期間，編譯器根據(jù)實參推演模板參數(shù)的實際類型時，根據(jù)實參a將T推演為int，根據(jù)實參b將T推演為double，但是模板參數(shù)列表中只有一個T，編譯器無法確定此處應該將T確定為int還是double。

 此時，我們有兩種處理方式，第一種就是我們在傳參時將b強制轉換為int類型，第二種就是使用下面說到的顯示實例化。

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

#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ù)類型不匹配，編譯器會嘗試進行隱式類型轉換，如果無法轉換成功，則編譯器將會報錯。

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

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

#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); //調用非模板函數(shù)，編譯器不需要實例化
	int d = Add<int>(a, b); //調用編譯器實例化的Add函數(shù)
	return 0;
}

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

#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ù)不允許自動類型轉換，但普通函數(shù)可以進行自動類型轉換

#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ù)不允許自動類型轉換，不能通過編譯
	return 0;
}

 因為模板函數(shù)不允許自動類型轉換，所以不會將2自動轉換為2.0，或是將2.2自動轉換為2。

類模板

類模板的定義格式

template<class T1,class T2,…,class Tn>
class 類模板名
{
  //類內成員聲明
};

例如：

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ù)列表。

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ù)模板實例化不同，類模板實例化需要在類模板名字后面根<>，然后將實例化的類型放在<>中即可。

    //Score不是真正的類，Score<int>和Score<double>才是真正的類
	Score<int> s1;
	Score<double> s2;

注意：類模板名字不是真正的類，而實例化的結果才是真正的類。

總結

到此這篇關于C++模板基礎之函數(shù)模板與類模板的文章就介紹到這了,更多相關C++函數(shù)模板與類模板內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論