類别範本的常見用法

ivanlee717發表於2024-04-25

class_template

類别範本和函式模板的定義和使用類似，我們已經進行了介紹。有時，有兩個或多個類，其功能是相同的，僅僅是資料型別不同。類别範本用於實現類所需資料的型別引數化

template<class NameType, class AgeType>
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->mName = name;
		this->mAge = age;
	}
	void showPerson()
	{
		cout << "name: " << this->mName << " age: " << this->mAge << endl;
	}
public:
	NameType mName;
	AgeType mAge;
};
void test1() {
	Person<string, int>p1("regina", 23);
	p1.showPerson();
	Person<char, float>p2('i', 23.1);
	p2.showPerson();
}

image-20240421223604510

類别範本做函式引數

void param(Person<string, int>& p) {
	p.mAge += 10;
	p.mName += "regina";
	p.showPerson();
}
int main() {
	Person<string, int> p("love", 20);
	param(p);
	return 0;
}

image-20240425171013806

類别範本派生普通類

template<class NameType, class AgeType>
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->mName = name;
		this->mAge = age;
	}
	void showPerson()
	{
		cout << "name: " << this->mName << " age: " << this->mAge << endl;
	}
public:
	NameType mName;
	AgeType mAge;
};
class Subclass : public Person<string, int> {
public:
	Subclass(string name, int age):Person<string, int>(name,age) {
		this->mName = name;
		this->mAge = age;
	}
};

int main() {
	Subclass p("regina", 17);
	p.showPerson();
	return 0;
}

Subclass(string name, int age):Person<string, int>(name,age)這句話首先宣告帶引數的建構函式里面的型別。這個型別要和後面使用類别範本的父類的建構函式引數型別一樣。但是當你在定義一個類時，如果該類是模板類的例項化，你可以直接使用類名而不需要指定模板引數，因為編譯器可以根據建構函式引數的型別來推斷模板引數的型別。

類别範本派生類别範本

派生類不僅繼承了基類的成員和行為，還繼承了基類的模板引數，並可以在派生類中新增額外的模板引數或覆蓋基類别範本引數。這樣可以使得派生類在使用時更加靈活，並且可以根據需要進行定製化。

template<class MoneyType>
class Subclass : public Person<string, int> {
public:
	Subclass(string name, int age, MoneyType have_money):Person<string, int>(name,age), havemoney(have_money) { /*這裡的繼承就是多一個對於自己的模板的預設建構函式的宣告*/
		this->mName = name;
		this->mAge = age;
	}
	void showPerson() {
		Person<string,int>::showPerson();
		cout << "have_money: " << （havemoney ? "true" : "false"） << endl;
	}
private:
	MoneyType havemoney;
};
int main() {
	Subclass<bool> p("regina", 17,true);
    /*在 main 函式中只傳遞了一個 bool 型別的引數，因為 Subclass 類别範本只接受一個模板引數 MoneyType*/
	p.showPerson();
	return 0;
}

image-20240425175021765

類别範本類內實現和類外實現

類别範本類內實現指的是在類别範本的定義中直接實現成員函式的方法。與普通類相似，類别範本也可以在類內部實現成員函式，這意味著成員函式的定義可以直接放在類别範本的宣告中，而不需要在類外部再單獨定義。這種方式使得程式碼更加簡潔，並且可以避免在類外部定義時重複書寫模板的引數列表。


template<class NameType, class AgeType>
class Person
{
public:
	Person(NameType name, AgeType age);
	void showPerson();
public:
	NameType mName;
	AgeType mAge;
};
template<class NameType, class AgeType>
Person<NameType, AgeType>::Person(NameType name, AgeType age) {
	this->mName = name;
	this->mAge = age;
}
template<class NameType, class AgeType>
void Person<NameType, AgeType>::showPerson() {
	cout << "Name:" << this->mName << " Age:" << this->mAge << endl;
}

template<class NameType, class AgeType>這個一共宣告瞭三次是為什麼呢？

  1. 模板類宣告： 在C++中，模板類的成員函式可以直接在類的定義中進行宣告和實現，但也可以在類定義之外單獨實現。在類定義之外實現時，必須再次使用 template<class NameType, class AgeType> 來指明這是一個模板類的成員函式。
    • 在類定義中進行宣告的情況下，模板引數已經被識別，所以無需再次宣告。
  2. 類定義外的實現： 如果你在模板類的定義之外實現成員函式，則需要重新指明該成員函式屬於特定的模板類。這是因為C++編譯器在進行模板解析時需要知道這些函式與哪個模板類相關聯。

類别範本標頭檔案和原始檔分離問題

類别範本的標頭檔案和原始檔分離是指將類别範本的宣告和定義分別放置在不同的檔案中的做法。通常，類别範本的宣告（包括模板類的成員函式宣告）放在標頭檔案（通常是 .hpp 或 .h 檔案），而類别範本的實現（包括成員函式的定義）則放在原始檔（通常是 .cpp 檔案）中。

這種分離的做法有幾個好處：

  1. 模組化: 將類别範本的宣告和定義分開可以更好地組織程式碼，使得程式碼結構更清晰，易於維護和理解。
  2. 編譯時間: 如果類别範本的實現放在原始檔中，在使用該類别範本的地方只需要包含標頭檔案即可，這樣可以減少編譯時間，因為編譯器只需要編譯一次模板的實現，而不是每次包含標頭檔案時都重新編譯一次。
  3. 隱藏實現細節: 將類别範本的實現放在原始檔中可以隱藏模板的具體實現細節，只向使用者暴露介面，提高了程式碼的封裝性和安全性。
#pragma once
/*是一種前處理器指令，用於確保在編譯過程中標頭檔案只被包含一次，以避免多重包含問題。

當編譯器遇到 #pragma once 時，它會在編譯過程中記住這個標頭檔案的路徑和檔名，
並在後續的 #include 指令中檢查是否已經包含了相同的檔案。如果已經包含過了，
那麼該標頭檔案將被忽略，不會再次包含。這樣可以防止由於多重包含而導致的編譯錯誤
或者重複定義的問題。

使用 #pragma once 可以簡化標頭檔案的管理，使得標頭檔案的包含更加簡潔和高效。*/

template<class T1, class T2>
class Person {
public:
	Person(T1 name, T2 age);
	void ShowPerson();
public:
	T1 mName;
	T2 mAge;
};

template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age) {
	this->mName = name;
	this->mAge = age;
}

template<class T1, class T2>
void Person<T1, T2>::ShowPerson() {
	cout << "Name:" << this->mName << " Age:" << this->mAge << endl;
}

模板類碰到友元函式

template<class T1, class T2> class Person;
template<class T1, class T2> void PrintPerson2(Person<T1, T2>& p);

template<class T1, class T2>
class Person {
	//1. 友元函式在類內實現
	friend void PrintPerson(Person<T1, T2>& p) {
		cout << "Name:" << p.mName << " Age:" << p.mAge << endl;
	}
	//2.友元函式類外實現
	//告訴編譯器這個函式模板是存在
	friend void PrintPerson2<>(Person<T1, T2>& p);//<> 是用來指示編譯器，PrintPerson2 是一個函式模板的宣告

	//3. 類别範本碰到友元函式模板
	template<class U1, class U2>
	friend void PrintPerson(Person<U1, U2>& p);
public:
	Person(T1 name, T2 age) {
		this->mName = name;
		this->mAge = age;
	}
	void showPerson() {
		cout << "Name:" << this->mName << " Age:" << this->mAge << endl;
	}
private:
	T1 mName;
	T2 mAge;

};
template<class T1, class T2>
void PrintPerson2(Person<T1, T2>& p)
{
	cout << "Name2:" << p.mName << " Age2:" << p.mAge << endl;
}
void test1() {
	Person<string, int> p("regina", 25);
	PrintPerson(p);
	PrintPerson2(p);
}

以下是為什麼需要在類外部宣告友元模板函式的原因：

  1. 預宣告模板函式：當你在類內使用 friend 關鍵字宣告一個友元模板函式時，你實際上告訴編譯器這個函式會訪問類的私有成員。但是這並不等同於定義了這個模板函式。因此，你仍然需要在類外部定義並實現這個模板函式。如果沒有外部的宣告和實現，編譯器將無法找到這個函式模板，導致連結錯誤。
  2. 函式模板的明確宣告：在使用友元模板函式時，編譯器需要明確知道它是一個模板函式，並且知道它如何被例項化。如果你不在類外部宣告這個函式模板，編譯器可能不會正確處理其例項化，導致意外的編譯錯誤。
  3. 類內部宣告只是告訴編譯器：在類內部透過 friend 宣告友元模板函式只是告訴編譯器該模板函式能夠訪問類的私有成員，並沒有定義該函式的具體實現。因此，必須在類外部提供該函式模板的宣告和實現，以確保編譯器知道它的具體實現位置。

相關文章