函数模板、类模板
文章目录
- 函数模板、类模板
- 前言
- 1.模板
- 1.1 模板的概念
- 1.2 模板的特点
- 2. 函数模板
- 2.1 函数模板语法
- 2.2 函数模板注意事项
- 2.3 普通函数与函数模板的区别
- 2.4 普通函数与函数模板的调用规则
- 2.5 模板的局限性
- 2.6 函数模板案例
- 3. 类模板
- 3.1 类模板语法
- 3.2 类模板与函数模板区别
- 3.3 类模板中成员函数创建时机
- 3.4 类模板对象做函数参数
- 3.5 类模板与继承
- 3.6 类模板成员函数类外实现
- 3.7 类模板分文件编写
- 3.8 类模板与友元
- 总结
前言
本文包含模板的概念、模板的特点、函数模板语法、函数模板注意事项、普通函数与函数模板的区别、普通函数与函数模板的调用规则、模板的局限性、类模板语法、类模板与函数模板区别、类模板中成员函数创建时机、类模板对象做函数参数、类模板与继承、类模板成员函数类外实现、类模板分文件编写、类模板与友元。
1.模板
1.1 模板的概念
（1）、模板就是建立通用的模具，大大提高复用性
（2）、生活中的模板
一寸照片模板：
PPT模板：
1.2 模板的特点
（1）、模板不可以直接使用，它只是一个框架；
（2）、模板的通用并不是万能的。
2. 函数模板
（1）、C++另一种编程思想称为泛型编程 ，主要利用的技术就是模板
（2）、C++提供两种模板机制：函数模板和类模板
2.1 函数模板语法
函数模板作用：
建立一个通用函数，其函数返回值类型和形参类型可以不具体指定，用一个虚拟的类型来代表。
语法：
template<typename T>
函数声明或定义
解释：
template — 声明创建模板
typename — 表面其后面的符号是一种数据类型，可以用class代替
T — 通用的数据类型，名称可以替换，通常为大写字母
// 函数模板语法
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
// 交换整型函数
void Int_Swap(int& a, int& b) { // 使用引用的方式传递，将本体交换，修改实参；不使用引用，则为赋值，形参不修改实参，会创建一个临时变量
int temp = a; // 创建一个临时变量存放元素
a = b;
b = temp;
}
// 交换双精度浮点型函数
void Double_Swap(double& a, double& b) {
double temp = a;
a = b;
b = temp;
}
// 利用模板提供通用的交换函数
template<typename T> // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
void Fun_Swap(T& a, T& b) { // 使用模板时再指定类型
T temp = a;
a = b;
b = temp;
}
void test() {
int a = 10;
int b = 20;
double c = 5.55;
double d = 10.11;
cout << "交换前：" << endl;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
cout << "d = " << d << endl;
Int_Swap(a, b);
cout << "使用Int_Swap()函数交换后：" << endl;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
Double_Swap(c, d);
cout << "使用Double_Swap()函数交换后：" << endl;
cout << "c = " << c << endl;
cout << "d = " << d << endl;
// 1、自动类型推导
Fun_Swap(a, b); // 编译器运行时，将变量传入函数形参中，根据变量类型int自动推导出T类型为int
cout << "使用Fun_Swap()函数模板交换后：" << endl;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
// 2、显示指定类型
Fun_Swap<double>(c, d); // <double>指定模板参数类型
cout << "使用Fun_Swap()函数模板交换后：" << endl;
cout << "c = " << c << endl;
cout << "d = " << d << endl;
}
int main() {
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
2.2 函数模板注意事项
（1）、自动类型推导，必须推导出一致的数据类型T，才可以使用；
// 函数模板注意事项
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
// 利用模板提供通用的交换函数
template<typename T> // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
void Fun_Swap(T& a, T& b) { // 使用模板时再指定类型
T temp = a;
a = b;
b = temp;
}
void test() {
int a = 10;
int b = 20;
double c = 5.55;
// 1、自动类型推导，必须推导出一致的数据类型T，才可以使用
Fun_Swap(a, b); // 正确，可以推导出一致的T
//Fun_Swap(a, c); // 错误，推导不出一致的T类型
}
int main() {
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
（2）、模板必须要确定出T的数据类型，才可以使用。
// 函数模板注意事项
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
template<typename T> // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
void Fun() {
cout << "调用Fun()函数" << endl;
}
void test() {
// 2、模板必须要确定出T的数据类型，才可以使用
//Fun(); // 错误，模板不能独立使用，必须确定出T的类型
Fun<int>(); // 利用显示指定类型的方式，给T一个类型，才可以使用该模板
}
int main() {
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
2.3 普通函数与函数模板的区别
（1）、普通函数调用时可以发生自动类型转换（隐式类型转换）；
// 普通函数与函数模板区别
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
// 普通函数
int Fun_Add01(int a, int b) {
return a + b;
}
void test() {
int a = 10;
char c = 'A'; // A - 65
// 1、普通函数调用时可以发生自动类型转换（隐式类型转换）
cout << "a + c = " << Fun_Add01(a, c) << endl; // 正确，将char类型的'A'隐式转换为int类型 'A' 对应 ASCII码 65
}
int main() {
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
（2）、函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换；
// 普通函数与函数模板区别
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
// 利用模板提供通用的相加函数
template<typename T> // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
int Fun_Add02(T a, T b) {
return a + b;
}
void test() {
int a = 10;
char c = 'A'; // A - 65
// 2、函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
//cout << "a + c = " << Fun_Add02(a, c) << endl; // 报错，使用自动类型推导时，不会发生隐式类型转换
}
int main() {
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
（3）、如果利用显示指定类型的方式，可以发生隐式类型转换。
// 普通函数与函数模板区别
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
// 利用模板提供通用的相加函数
template<typename T> // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
// 此处不可使用&，引用的本质在c++内部实现是一个指针常量；指针常量是指针指向不可改，指向a地址后，不可再指向b地址
// 使用赋值，会创建一个临时变量，不改变实参
int Fun_Add02(T a, T b) {
return a + b;
}
void test() {
int a = 10;
char c = 'A'; // A - 65
// 3、如果利用显示指定类型的方式，可以发生隐式类型转换
cout << "a + c = " << Fun_Add02<int>(a, c) << endl; // 正确，如果用显示指定类型，可以发生隐式类型转换
}
int main() {
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
2.4 普通函数与函数模板的调用规则
（1）、如果函数模板和普通函数都可以实现，优先调用普通函数；
// 普通函数与函数模板调用规则
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
// 普通函数
void Fun_Print(int a, int b) {
cout << "调用普通函数！" << endl;
}
// 函数模板
template<typename T> // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
void Fun_Print(T a, T b) {
cout << "调用函数模板！" << endl;
}
void test() {
int a = 10;
int b = 20;
// 1、如果函数模板和普通函数都可以实现，优先调用普通函数
// 注意 如果告诉编译器 普通函数是有的，但只是声明没有实现，或者不在当前文件内实现，就会报错找不到
Fun_Print(a, b);
}
int main() {
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
（2）、可以通过空模板参数列表来强制调用函数模板；
// 普通函数与函数模板调用规则
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
// 普通函数
void Fun_Print(int a, int b) {
cout << "调用普通函数！" << endl;
}
// 函数模板
template<typename T> // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
void Fun_Print(T a, T b) {
cout << "调用函数模板！" << endl;
}
void test() {
int a = 10;
int b = 20;
// 2、可以通过空模板参数列表来强制调用函数模板
Fun_Print<>(a, b);
}
int main() {
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
（3）、函数模板也可以发生重载；
// 普通函数与函数模板调用规则
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
// 普通函数
void Fun_Print(int a, int b) {
cout << "调用普通函数！" << endl;
}
// 函数模板
template<typename T> // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
void Fun_Print(T a, T b) {
cout << "调用函数模板！" << endl;
}
// 重载函数模板
template<typename T> // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
void Fun_Print(T a, T b, T c) {
cout << "调用重载函数模板！" << endl;
}
void test() {
int a = 10;
int b = 20;
// 3、函数模板也可以发生重载
int c = 30;
Fun_Print<>(a, b, c);
}
int main() {
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
（4）、如果函数模板可以产生更好的匹配，优先调用函数模板。
// 普通函数与函数模板调用规则
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
// 普通函数
void Fun_Print(int a, int b) {
cout << "调用普通函数！" << endl;
}
// 函数模板
template<typename T> // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
void Fun_Print(T a, T b) {
cout << "调用函数模板！" << endl;
}
void test() {
int a = 10;
int b = 20;
// 4、如果函数模板可以产生更好的匹配,优先调用函数模板
char d = 'a';
char e = 'b';
Fun_Print(d, e); // 调用函数模板；如果调用普通函数，需要将char转为int，程序为了避免麻烦，调函数模板，可以产生更好的匹配
}
int main() {
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
2.5 模板的局限性
（1）、模板的通用性并不是万能的
template<class T>
void f(T a, T b)
{
a = b;
}
在上述代码中提供的赋值操作，如果传入的a和b是一个数组，就无法实现了
template<class T>
void f(T a, T b)
{
if(a > b) { ... }
}
在上述代码中，如果T的数据类型传入的是像Person这样的自定义数据类型，也无法正常运行
（2）、因此C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板
// 函数模板的局限性
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
// 创建一个Person类
class Person {
public:
Person(string name, int age) { // 有参构造，赋值
this->m_Name = name;
this->m_Age = age;
}
string m_Name;
int m_Age;
};
// 普通的通用函数模板；判断两个数是否相等
template<typename T> // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
bool Fun_Compare(T& a, T& b) {
// 相等返回true，否则返回false
if (a == b) {
return true;
}
else {
return false;
}
}
// 解决方法：1、运算符重载（麻烦，如果是<,>等都需要重载一遍）
// 具体化，显示具体化的原型和定义以template<>开头，并通过名称来指出类型
// 解决方法：2、具体化优先于常规模板
template<> bool Fun_Compare(Person& p1, Person& p2) { // template<>告诉编译器为模板的重载
if (p1.m_Name == p2.m_Name && p1.m_Age == p2.m_Age) { // 判断实例p1和p2的姓名、年龄是否都相等
return true;
}
else {
return false;
}
}
void test01() {
int a = 10;
int b = 10;
// 内置数据类型可以直接使用通用的函数模板
bool con = Fun_Compare(a, b);
if (con) {
cout << "a == b" << endl;
}
else {
cout << "a != b" << endl;
}
}
void test02() {
Person p1("张三", 18);
Person p2("张三", 18);
// 自定义数据类型，不会调用普通的通用函数模板
// 可以创建具体化的Person数据类型的模板，用于特殊处理这个类型
bool con = Fun_Compare(p1, p2);
if (con) {
cout << "p1 == p2" << endl;
}
else {
cout << "p1 != p2" << endl;
}
}
int main() {
test01();
test02();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
2.6 函数模板案例
（1）、利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序
（2）、排序规则从大到小，排序算法为选择排序
（3）、分别利用char数组和int数组进行测试
// 函数模板案例
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
// 利用模板提供通用的交换函数
template<typename T> // 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
void Fun_Swap(T& a, T& b) {
T temp = a; // 创建一个临时变量存放元素
a = b;
b = temp;
}
// 利用选择排序，进行对数组从大到小的排序，提供通用排序模板
template<typename T>
void Fun_Sort(T arr[], int len) {
for (int i = 0; i < len; i++) { // 获取每一个元素，与它之后的元素进行对比
int max = i; // 最大数的下标；假设认定第一个下标为最大值
for (int j = i + 1; j < len; j++) { // 获取第i个元素之后的所有元素
if (arr[max] < arr[j]) { // 认定的最大值比遍历出的数组要小，说明j下标的元素才是真正的最大值
max = j; // 将j赋值给max
}
}
if (max != i) { // 如果最大数的下标不是i，交换两者
Fun_Swap(arr[max], arr[i]); // 将最大下标的元素，与第i个元素进行交换
}
}
}
// 打印数组通用模板
template<typename T>
void Fun_Print(T arr[], int len) {
for (int i = 0; i < len; i++) {
cout << arr[i] << " "; // 每个数组元素之间使用空格分开
}
cout << endl; // 换行
}
// 测试int数组
void test01() {
int int_Arr[] = { 7,2,6,9,1,0,5,3 };
int len = sizeof(int_Arr) / sizeof(int); // sizeof()：求对象或者类型的大小
cout << "int型数组排序前：" << endl;
Fun_Print(int_Arr, len);
Fun_Sort(int_Arr, len);
cout << "int型数组排序后：" << endl;
Fun_Print(int_Arr, len);
}
// 测试char数组
void test02() {
char char_Arr[] = "ksiudxtenz";
int len = sizeof(char_Arr) / sizeof(char);
cout << "char型数组排序前：" << endl;
Fun_Print(char_Arr, len);
Fun_Sort(char_Arr, len);
cout << "char型数组排序后：" << endl;
Fun_Print(char_Arr, len);
}
int main() {
test01();
test02();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
3. 类模板
3.1 类模板语法
类模板作用：
建立一个通用类，类中的成员、数据类型可以不具体制定，用一个虚拟的类型来代表。
语法：
template<class T>
类
解释：
template — 声明创建模板
class — 表面其后面的符号是一种数据类型，可以用typename代替
T — 通用的数据类型，名称可以替换，通常为大写字母
// 类模板语法
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
// 创建一个Person类模板
template<class nameType, class ageType> // nameType、ageType为虚拟类型
class Person {
public:
Person(nameType name, ageType age) { // 有参构造，赋值
this->m_Name = name;
this->m_Age = age;
}
void Fun_Print() { // 打印成员属性
cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl;
}
nameType m_Name; // 姓名
ageType m_Age; // 年龄
};
void test() {
// 指定nameType为string类型，ageType为int类型
Person<string, int> p("张三", 18); // <string, int>类型参数化；<>模板的参数列表
p.Fun_Print(); // 调用成员函数Fun_Print()
}
int main() {
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
3.2 类模板与函数模板区别
（1）、类模板没有自动类型推导的使用方式；
// 类模板与函数模板区别
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
// 创建一个Person类模板
template<class nameType, class ageType> // nameType、ageType为虚拟类型
class Person {
public:
Person(nameType name, ageType age) { // 有参构造，赋值
this->m_Name = name;
this->m_Age = age;
}
void Fun_Print() { // 打印成员属性
cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl;
}
nameType m_Name; // 姓名
ageType m_Age; // 年龄
};
void test() {
// 1、类模板没有自动类型推导的使用方式
//Person p("张三", 18); // 错误 类模板使用时候，不可以用自动类型推导
// 必须使用显示指定类型的方式，使用类模板
Person<string, int> p("张三", 18);
p.Fun_Print(); // 调用成员函数Fun_Print()
}
int main() {
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
（2）、类模板在模板参数列表中可以有默认参数
// 类模板与函数模板区别
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
// 创建一个Person类模板
template<class nameType, class ageType = int> // 类模板在模板参数列表中可以有默认参数
class Person {
public:
Person(nameType name, ageType age) { // 有参构造，赋值
this->m_Name = name;
this->m_Age = age;
}
void Fun_Print() { // 打印成员属性
cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl;
}
nameType m_Name; // 姓名
ageType m_Age; // 年龄
};
void test() {
// 2、类模板在模板参数列表中可以有默认参数
Person<string> p("李四", 40); // 类模板中的模板参数列表，可以指定默认参数
p.Fun_Print(); // 调用成员函数Fun_Print()
}
int main() {
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
3.3 类模板中成员函数创建时机
类模板中成员函数和普通类中成员函数创建时机是有区别的：
（1）、普通类中的成员函数一开始就可以创建；
（2）、类模板中的成员函数在调用时才创建。
// 类模板中成员函数创建时机
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
// 创建Aoo类
class Aoo {
public:
void Fun_Print1() {
cout << "调用Fun_Print1()函数！" << endl;
}
};
// 创建Boo类
class Boo {
public:
void Fun_Print2() {
cout << "调用Fun_Print2()函数！" << endl;
}
};
// 创建Coo类模板
template<class T> // 类模板在模板参数列表中可以有默认参数
class Coo {
public:
T t;
// 类模板中的成员函数，并不是一开始就创建的，而是在模板调用时再生成
void Fun1() { // 没有调用时，不会创建；无法确定obj是何类型
t.Fun_Print1();
}
void Fun2() {
t.Fun_Print2();
}
};
void test() {
Coo<Aoo> c; // T为Aoo的数据类型
c.Fun1(); // 相当于Aoo.Fun_Print1()
// 编译会出错，说明函数调用才会去创建成员函数
//c.Fun2(); // 编译会出错：Fun_Print2不是Aoo的成员；Aoo.Fun_Print2()，Aoo类中并没有Fun_Print2()函数
}
int main() {
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
3.4 类模板对象做函数参数
（1）、类模板实例化出的对象，向函数传参的方式；
（2）、一共有三种传入方式：
1）、指定传入的类型 — 直接显示对象的数据类型；
// 类模板对象做函数参数：指定传入的类型
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
// 创建一个Person类模板
template<class nameType, class ageType = int> // 类模板在模板参数列表中可以有默认参数
class Person {
public:
Person(nameType name, ageType age) { // 有参构造，赋值
this->m_Name = name;
this->m_Age = age;
}
void Fun_Print() { // 打印成员属性
cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl;
}
public:
nameType m_Name; // 姓名
ageType m_Age; // 年龄
};
// 1、指定传入的类型
void Print_Person(Person<string>& p) { // Person<string>类模板的对象p做函数Print_Person中的一个参数
p.Fun_Print();
}
void test() {
Person<string> p("张三", 18); // <string>：类模板参数类型；p("张三", 18)：有参构造
Print_Person(p); // 调用Print_Person()函数，传入p
}
int main() {
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
2）参数模板化 — 将对象中的参数变为模板进行传递；
// 类模板对象做函数参数：参数模板化
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
// 创建一个Person类模板
template<class nameType, class ageType = int> // 类模板在模板参数列表中可以有默认参数
class Person {
public:
Person(nameType name, ageType age) { // 有参构造，赋值
this->m_Name = name;
this->m_Age = age;
}
void Fun_Print() { // 打印成员属性
cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl;
}
public:
nameType m_Name; // 姓名
ageType m_Age; // 年龄
};
// 2、参数模板化
template<class T1, class T2> // 告诉函数T1, T2是模板中的两个参数类型
void Print_Person(Person<T1, T2>& p) { // 将string, int模板化，变成T1, T2
p.Fun_Print();
// typeid()查看类型，name()将类型以字符串形式显示出来
cout << "T1的类型为： " << typeid(T1).name() << endl;
cout << "T2的类型为： " << typeid(T2).name() << endl;
}
void test() {
Person<string, int> p("李四", 40); // <string, int>：类模板参数类型；p("李四", 40)：有参构造
Print_Person(p); // 调用Print_Person()函数，传入p
}
int main() {
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
3）、整个类模板化 — 将这个对象类型模板化进行传递。
// 类模板对象做函数参数：整个类模板化
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
// 创建一个Person类模板
template<class nameType, class ageType = int> // 类模板在模板参数列表中可以有默认参数
class Person {
public:
Person(nameType name, ageType age) { // 有参构造，赋值
this->m_Name = name;
this->m_Age = age;
}
void Fun_Print() { // 打印成员属性
cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl;
}
public:
nameType m_Name; // 姓名
ageType m_Age; // 年龄
};
// 3、整个类模板化
template<class T>
void Print_Person(T& p) { // 编译器自动推导出T为Person类型
p.Fun_Print();
// typeid()查看类型，name()将类型以字符串形式显示出来
cout << "T的类型为： " << typeid(T).name() << endl;
}
void test() {
Person<string, int> p("王五", 51);
Print_Person(p); // 调用Print_Person()函数，传入p
}
int main() {
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
3.5 类模板与继承
当类模板碰到继承时，需要注意一下几点：
（1）、当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型；
（2）、如果不指定，编译器无法给子类分配内存；
// 类模板继承
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
// 创建一个父类模板
template<class T>
class Aoo {
T m;
};
//class Boo :public Aoo {}; // 错误，c++编译需要给子类分配内存，必须知道父类中T的类型才可以向下继承
class Boo :public Aoo<int> { // 必须指定一个类型；此时类型写死，必须是int
};
void test() {
Boo b;
}
int main() {
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
（3）、如果想灵活指定出父类中T的类型，子类也需变为类模板。
// 类模板继承
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
// 创建一个父类模板
template<class T>
class Aoo {
T m;
};
// 如果想灵活指定父类中T类型，子类也需要变类模板
template<class T1, class T2>
class Boo :public Aoo<T2> { // 类模板继承类模板 ,可以用T2指定父类中的T类型
public:
Boo() {
// typeid()查看类型，name()将类型以字符串形式显示出来
cout << "T1的类型为： " << typeid(T1).name() << endl;
cout << "T2的类型为： " << typeid(T2).name() << endl;
}
T1 t;
};
void test() {
Boo<int, char> b; // int传给T1，T1为子类Boo中t的类型；char传给T2，T2为父类Aoo中m的类型
}
int main() {
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
3.6 类模板成员函数类外实现
// 类模板中成员函数类外实现
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
// 创建一个类模板，只声明
template<class T1, class T2>
class Person {
public:
// 成员函数类内声明
Person(T1 name, T2 age);
void Fun_Print();
public:
T1 m_Name; // 姓名
T2 m_Age; // 年龄
};
// 构造函数 类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age) { // <T1, T2>类模板的类外实现；Person::Person(T1 name, T2 age)普通函数的类外实现；Person::作用域
this->m_Name = name;
this->m_Age = age;
}
// 成员函数 类外实现
template<class T1, class T2>
void Person<T1, T2>::Fun_Print() { // Person类::作用域下的Fun_Print()函数，<T1, T2>体现为模板参数列表，template<class T1, class T2>告诉服务器<T1, T2>为类模板中的成员函数参数类型
cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl;
}
void test() {
Person<string, int> p("张三", 18);
p.Fun_Print();
}
int main() {
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
3.7 类模板分文件编写
类模板成员函数分文件编写产生的问题：
类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到
解决方式：
（1）、解决方式1：直接包含.cpp源文件（将包含头文件person.h改为person.cpp）；
Person.h中代码：
#pragma once // 防止头文件重复包含
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
// 创建一个类模板，只声明
template<class T1, class T2>
class Person {
public:
// 成员函数类内声明
Person(T1 name, T2 age);
void Fun_Print();
public:
T1 m_Name; // 姓名
T2 m_Age; // 年龄
};
Person.cpp中代码：
# include "Person.h" // 包含Person.h头文件
// 构造函数 类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age) { // <T1, T2>类模板的类外实现；Person::Person(T1 name, T2 age)普通函数的类外实现；Person::作用域
this->m_Name = name;
this->m_Age = age;
}
// 成员函数 类外实现
template<class T1, class T2>
void Person<T1, T2>::Fun_Print() { // Person类::作用域下的Fun_Print()函数，<T1, T2>体现为模板参数列表，template<class T1, class T2>告诉服务器<T1, T2>为类模板中的成员函数参数类型
cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl;
}
main.cpp中代码：
//#include "person.h" // 模板函数，调用时生成，包含person.h头文件，头文件中的模板函数Person、showPerson并不会生成产生这两个函数，看不到也不会去找cpp中的函数
#include "Person.cpp" // 解决方式1：直接包含Person.cpp源文件
void test() {
Person<string, int> p("LZQ", 25);
p.Fun_Print(); // 调用p对象的Fun_Print()函数
}
int main() {
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
（2）、解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制。
Person.hpp中代码：
#pragma once // 防止头文件重复包含
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
// 创建一个类模板，只声明
template<class T1, class T2>
class Person {
public:
// 成员函数类内声明
Person(T1 name, T2 age);
void Fun_Print();
public:
T1 m_Name; // 姓名
T2 m_Age; // 年龄
};
// 构造函数 类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age) { // <T1, T2>类模板的类外实现；Person::Person(T1 name, T2 age)普通函数的类外实现；Person::作用域
this->m_Name = name;
this->m_Age = age;
}
// 成员函数 类外实现
template<class T1, class T2>
void Person<T1, T2>::Fun_Print() { // Person类::作用域下的Fun_Print()函数，<T1, T2>体现为模板参数列表，template<class T1, class T2>告诉服务器<T1, T2>为类模板中的成员函数参数类型
cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl;
}
main.cpp中代码：
// 解决方式2：将声明和实现写到一起，文件后缀名改为.hpp（hpp一般看见，就知道是类模板，约定俗成）
#include "person.hpp"
void test() {
Person<string, int> p("LZQ", 25);
p.Fun_Print(); // 调用p对象的Fun_Print()函数
}
int main() {
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
3.8 类模板与友元
类模板配合友元函数的类内和类外实现
（1）、全局函数类内实现 ----- 直接在类内声明友元即可；
// 类模板中成员函数类内实现
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
// 创建一个类模板Person
template<class T1, class T2>
class Person {
// 1、全局函数配合友元 类内实现 （直接在类内写全局有元函数的函数定义和函数实现）
friend void Fun_Print(Person<T1, T2>& p) { // Person类型，有两个属性<T1, T2>，参数模板化
cout << "姓名：" << p.m_Name << " 年龄：" << p.m_Age << endl;
}
public:
Person(T1 name, T2 age) { // 构造函数需写在public公共下，否则无法初始化对象
this->m_Name = name;
this->m_Age = age;
}
private: // 私人属性
T1 m_Name; // 姓名
T2 m_Age; // 年龄
};
void test() {
// 1、全局函数在类内实现
Person <string, int> p("张三", 18); // 创建Person对象p("张三", 18);
Fun_Print(p); // 调用全局函数
}
int main() {
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
（2）、全局函数类外实现 ----- 需要提前让编译器知道全局函数的存在。
// 类模板中成员函数类外实现
#include <iostream> // 包含标准输入输出流头文件
using namespace std; // 使用标准命名空间
// 2、全局函数配合友元 类外实现 - 先做函数模板声明，下方在做函数模板定义，在做友元
// 提前让编译器知道Person类的存在
template<class T1, class T2> class Person;
// 如果声明了函数模板，可以将实现写到后面，否则需要将实现体写到类的前面让编译器提前看到
//template<class T1, class T2> void Fun_Print(Person<T1, T2> & p);
template<class T1, class T2>
// 函数模板的实现；先让编译器看到这有一个类外实现的模板函数定义；函数中有个Person类型，需让编译器知道有个Person存在，并告诉编译器这是一个模板，加上模板template<class T1, class T2>
void Fun_Print(Person<T1, T2>& p) { // 全局函数，不需要加作用域
cout << "类外实现 ---- 姓名：" << p.m_Name << " 年龄：" << p.m_Age << endl;
}
// 创建一个类模板Person
template<class T1, class T2>
class Person {
// 2、全局函数配合友元 类外实现
// 加一个空模板参数列表<>；代表函数模板的函数声明
// 如果全局函数是类外实现，需要让编译器提前知道这个函数的存在；本质发生变化，这是一个函数模板
// 如果不加<>，实际是一个普通函数的声明；和类外的函数模板实现不是一套东西
friend void Fun_Print<>(Person<T1, T2>& p);
public:
Person(T1 name, T2 age) { // 构造函数需写在public公共下，否则无法初始化对象
this->m_Name = name;
this->m_Age = age;
}
private: // 私人属性
T1 m_Name; // 姓名
T2 m_Age; // 年龄
};
void test() {
// 2、全局函数在类外实现
Person <string, int> p("张三丰", 999); // 创建Person对象p("张三丰", 999);
Fun_Print(p); // 调用全局函数
}
int main() {
test();
system("pause"); // 相当于在本地 Windows 调试器中的：请按任意键继续...；暂停，方便看清楚输出结果
return 0; // 程序正常退出
}
经典案例：类模板案例
总结
（1）、函数模板利用关键字 template；
（2）、使用函数模板有两种方式：自动类型推导、显示指定类型；
（3）、模板的目的是为了提高复用性，将类型参数化；
（4）、使用模板时必须确定出通用数据类型T，并且能够推导出一致的类型；
（5）、建议使用显示指定类型的方式，调用函数模板，因为可以自己确定通用类型T；
（6）、既然提供了函数模板，最好就不要提供普通函数，否则容易出现二义性；
（7）、利用具体化的模板，可以解决自定义类型的通用化；
（8）、学习模板并不是为了写模板，而是在STL能够运用系统提供的模板；
（9）、类模板和函数模板语法相似，在声明模板template后面加类，此类称为类模板；
（10）、类模板使用只能用显示指定类型方式；
（11）、类模板中的模板参数列表可以有默认参数；
（12）、类模板中的成员函数并不是一开始就创建的，在调用时才去创建；
（13）、通过类模板创建的对象，可以有三种方式向函数中进行传参；
（14）、使用比较广泛是第一种：指定传入的类型；
（15）、如果父类是类模板，子类需要指定出父类中T的数据类型；
（16）、类模板中成员函数类外实现时，需要加上模板参数列表；
（17）、类模板分文件编写主流的解决方式是第二种，将类模板成员函数写到一起，并将后缀名改为.hpp
（18）、建议全局函数做类内实现，用法简单，而且编译器可以直接识别；
（19）、模板可以提高代码复用，需要熟练掌握。
