class_template 類模板和函數模板的定義和使用類似，我們已經進行了介紹。有時，有兩個或多個類，其功能是相同的，僅僅是數據類型不同。類模板用於實現類所需數據的類型參數化 template<class NameType, class AgeType> class Person { publi ...

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();
}

類模板做函數參數

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

類模板派生普通類

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

類模板類內實現和類外實現

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


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>這個一共聲明瞭三次是為什麼呢？

模板類聲明：在C++中，模板類的成員函數可以直接在類的定義中進行聲明和實現，但也可以在類定義之外單獨實現。在類定義之外實現時，必須再次使用 template<class NameType, class AgeType> 來指明這是一個模板類的成員函數。

在類定義中進行聲明的情況下，模板參數已經被識別，所以無需再次聲明。

類定義外的實現：如果你在模板類的定義之外實現成員函數，則需要重新指明該成員函數屬於特定的模板類。這是因為C++編譯器在進行模板解析時需要知道這些函數與哪個模板類相關聯。

類模板頭文件和源文件分離問題

類模板的頭文件和源文件分離是指將類模板的聲明和定義分別放置在不同的文件中的做法。通常，類模板的聲明（包括模板類的成員函數聲明）放在頭文件（通常是 .hpp 或 .h 文件），而類模板的實現（包括成員函數的定義）則放在源文件（通常是 .cpp 文件）中。

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

模塊化: 將類模板的聲明和定義分開可以更好地組織代碼，使得代碼結構更清晰，易於維護和理解。
編譯時間: 如果類模板的實現放在源文件中，在使用該類模板的地方只需要包含頭文件即可，這樣可以減少編譯時間，因為編譯器只需要編譯一次模板的實現，而不是每次包含頭文件時都重新編譯一次。
隱藏實現細節: 將類模板的實現放在源文件中可以隱藏模板的具體實現細節，只向用戶暴露介面，提高了代碼的封裝性和安全性。

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

以下是為什麼需要在類外部聲明友元模板函數的原因：

預聲明模板函數：當你在類內使用 friend 關鍵字聲明一個友元模板函數時，你實際上告訴編譯器這個函數會訪問類的私有成員。但是這並不等同於定義了這個模板函數。因此，你仍然需要在類外部定義並實現這個模板函數。如果沒有外部的聲明和實現，編譯器將無法找到這個函數模板，導致鏈接錯誤。

函數模板的明確聲明：在使用友元模板函數時，編譯器需要明確知道它是一個模板函數，並且知道它如何被實例化。如果你不在類外部聲明這個函數模板，編譯器可能不會正確處理其實例化，導致意外的編譯錯誤。

類內部聲明只是告訴編譯器：在類內部通過 friend 聲明友元模板函數只是告訴編譯器該模板函數能夠訪問類的私有成員，並沒有定義該函數的具體實現。因此，必須在類外部提供該函數模板的聲明和實現，以確保編譯器知道它的具體實現位置。

本文來自博客園，作者：ivanlee717，轉載請註明原文鏈接：https://www.cnblogs.com/ivanlee717/p/18158767

類模板的常見用法