【黑马程序员 C++教程从0到1入门编程】【笔记8】 泛型编程——模板

https://www.bilibili.com/video/BV1et411b73Z?p=167

C++泛型编程是一种编程范式，它的核心思想是编写通用的代码，使得代码可以适用于多种不同的数据类型。
而模板是C++中实现泛型编程的一种机制，它允许我们编写通用的代码模板，然后在需要使用时根据具体的数据类型进行实例化，生成具体的代码。
因此，可以说模板是C++中实现泛型编程的基础。通过使用模板，我们可以编写出具有高度通用性和可重用性的代码，从而提高代码的效率和可维护性。

1 模板

1.1 模板的概念

模板就是建立通用的模具，大大提高复用性

例如生活中的模板

一寸照片模板：

PPT模板：

模板的特点：

• 模板不可以直接使用，它只是一个框架
• 模板的通用并不是万能的

1.2 函数模板

• C++另一种编程思想称为 泛型编程 ，主要利用的技术就是模板

• C++提供两种模板机制:函数模板和类模板

1.2.1 函数模板语法

函数模板作用：

建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。

语法

template<typename T>
函数声明或定义

解释

template — 声明创建模板

typename — 表明其后面的符号是一种数据类型，可以用class代替（貌似用其他名字不行，只能用typename或者class）

T — 通用的数据类型，名称可以替换，通常为大写字母

注意

template <typename T>跟后面的代码void mySwap(T &a, T &b)要连着的，中间可以添加注释，但是不能添加无关的代码

template <typename T> void mySwap(T &a, T &b)

示例：自动类型推导、显式指定类型

（test.cpp）

#include <iostream>
#include <cstdlib>
#include <limits>
using namespace std;// 交换整型函数
void swapInt(int &a, int &b)
{int temp = a;a = b;b = temp;
}// 交换浮点型函数
void swapDouble(double &a, double &b)
{double temp = a;a = b;b = temp;
}// 利用模板提供通用的交换函数
template <typename T>
void mySwap(T &a, T &b)
{T temp = a;a = b;b = temp;
}void test01()
{int a = 10;int b = 20;// swapInt(a, b);// 利用模板实现交换// 1、自动类型推导mySwap(a, b);cout << "a = " << a << endl;cout << "b = " << b << endl;double c = 1.2;double d = 2.3;mySwap(c, d);cout << "c = " << c << endl;cout << "d = " << d << endl;// 3、显示指定类型int e=3;int f=4;mySwap<int>(e, f);cout << "e = " << e << endl;cout << "f = " << f << endl;
}int main()
{test01();// system("pause");// return 0;std::cout << "Press ENTER to continue...";std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键return EXIT_SUCCESS;
}

编译：

g++ test.cpp

运行结果：

总结：

• 函数模板利用关键字 template
• 使用函数模板有两种方式：自动类型推导、显式指定类型
• 模板的目的是为了提高复用性，将类型参数化

1.2.2 函数模板注意事项

注意事项：

• 自动类型推导，必须推导出一致的数据类型T,才可以使用

• 模板必须要确定出T的数据类型，才可以使用

示例：模板必须要确定出T的数据类型，才可以使用

#include <iostream>
#include <cstdlib>
#include <limits>
using namespace std;// 利用模板提供通用的交换函数
template <typename T>
void mySwap(T &a, T &b)
{T temp = a;a = b;b = temp;
}// 1、自动类型推导，必须推导出一致的数据类型T,才可以使用
void test01()
{int a = 10;int b = 20;char c = 'c';mySwap(a, b); // 正确，可以推导出一致的T// mySwap(a, c); // 错误，推导不出一致的T类型
}// 2、模板必须要确定出T的数据类型，才可以使用
template <class T>
void func()
{cout << "func 调用" << endl;
}void test02()
{// func(); //错误，模板不能独立使用，必须确定出T的类型func<int>(); // 利用显示指定类型的方式，给T一个类型，才可以使用该模板
}int main()
{test01();test02();// system("pause");// return 0;std::cout << "Press ENTER to continue...";std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键return EXIT_SUCCESS;
}

总结：

• 使用模板时必须确定出通用数据类型T，并且能够推导出一致的类型

示例：多类型参数模板

#include <iostream>
#include <cstdlib>
#include <limits>
using namespace std;// 利用模板提供通用的交换函数
template <typename T1, typename T2>
void mySwap(T1 &a, T2 &b)
{T1 temp = a;a = b;b = temp;
}// 1、自动类型推导，必须推导出一致的数据类型T,才可以使用
void test01()
{int a = 10;double b = 20.1;char c = 'c';mySwap(a, b); // 正确，可以推导出一致的T// mySwap(a, c); // 错误，推导不出一致的T类型
}int main()
{test01();std::cout << "Press ENTER to continue...";std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键return EXIT_SUCCESS;
}

1.2.3 函数模板案例（不同数据类型数组排序）

案例描述：

• 利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序
• 排序规则从大到小，排序算法为选择排序
• 分别利用char数组和int数组进行测试

示例：

#include <iostream>
#include <cstdlib>
#include <limits>
using namespace std;// 交换的函数模板
template <typename T>
void mySwap(T &a, T &b)
{T temp = a;a = b;b = temp;
}template <class T> // 也可以替换成typename
// 利用选择排序，进行对数组从大到小的排序
void mySort(T arr[], int len)
{for (int i = 0; i < len; i++){int max = i; // 最大数的下标for (int j = i + 1; j < len; j++){if (arr[max] < arr[j]){max = j;}}if (max != i) // 如果最大数的下标不是i，交换两者{mySwap(arr[max], arr[i]);}}
}template <typename T>
void printArray(T arr[], int len)
{for (int i = 0; i < len; i++){cout << arr[i] << " ";}cout << endl;
}void test01()
{// 测试char数组char charArr[] = "bdcfeagh";int num = sizeof(charArr) / sizeof(char);mySort(charArr, num);printArray(charArr, num);
}void test02()
{// 测试int数组int intArr[] = {7, 5, 8, 1, 3, 9, 2, 4, 6};int num = sizeof(intArr) / sizeof(int);mySort(intArr, num);printArray(intArr, num);
}int main()
{test01();test02();std::cout << "Press ENTER to continue...";std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键return EXIT_SUCCESS;
}

运行结果：

1.2.4 普通函数与函数模板的区别

普通函数与函数模板区别：

• 普通函数调用时可以发生自动类型转换（隐式类型转换）
• 函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
• 如果利用显示指定类型的方式，可以发生隐式类型转换

示例：建议调用模板函数时，使用显式指定类型的方式，不容易出错

#include <iostream>
#include <cstdlib>
#include <limits>
using namespace std;// 普通函数
int myAdd01(int a, int b)
{return a + b;
}// 函数模板
template <typename T> 
T myAdd02(T a, T b) //这个表示返回类型也自动推导为 T
{return a + b;
}// 使用函数模板时，如果用自动类型推导，不会发生自动类型转换,即隐式类型转换
void test01()
{int a = 10;int b = 20;char c = 'c';cout << "myAdd01(a, c): " << myAdd01(a, c) << endl; // 正确，将char类型的'c'隐式转换为int类型  'c' 对应 ASCII码 99// myAdd02(a, c); // 报错，使用自动类型推导时，不会发生隐式类型转换cout << "myAdd02<int>(a, c): " << myAdd02<int>(a, c) << endl; // 正确，如果用显式指定类型，可以发生隐式类型转换
}int main()
{test01();std::cout << "Press ENTER to continue...";std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键return EXIT_SUCCESS;
}

总结：建议使用显示指定类型的方式，调用函数模板，因为可以自己确定通用类型T

1.2.5 普通函数与函数模板的调用规则

调用规则如下：

1. 如果函数模板和普通函数都可以实现，优先调用普通函数
2. 可以通过空模板参数列表来强制调用函数模板
3. 函数模板也可以发生重载
4. 如果函数模板可以产生更好的匹配,优先调用函数模板（比如普通函数需要隐式转换的情况）

示例：当普通函数与模板有冲突时，如果函数模板可以产生更好的匹配，优先调用函数模板（考虑到普通函数存在隐式转换的情况）

#include <iostream>
#include <cstdlib>
#include <limits>
using namespace std;// 普通函数与函数模板调用规则
void myPrint(int a, int b)
{cout << "调用的普通函数" << endl;
}template <typename T>
void myPrint(T a, T b)
{cout << "调用的模板" << endl;
}template <typename T>
void myPrint(T a, T b, T c)
{cout << "调用重载的模板" << endl;
}void test01()
{// 1、如果函数模板和普通函数都可以实现，优先调用普通函数//  注意 如果告诉编译器  普通函数是有的，但只是声明没有实现，或者不在当前文件内实现，就会报错找不到int a = 10;int b = 20;myPrint(a, b); // 调用普通函数// 2、可以通过空模板参数列表来强制调用函数模板myPrint<>(a, b); // 调用函数模板// 3、函数模板也可以发生重载int c = 30;myPrint(a, b, c); // 调用重载的函数模板// 4、 如果函数模板可以产生更好的匹配,优先调用函数模板char c1 = 'a';char c2 = 'b';myPrint(c1, c2); // 调用函数模板
}int main()
{test01();std::cout << "Press ENTER to continue...";std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键return EXIT_SUCCESS;
}

总结：既然提供了函数模板，最好就不要提供普通函数，否则容易出现二义性

1.2.6 模板的局限性

局限性：

• 模板的通用性并不是万能的

例如：

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这样的自定义数据类型，也无法正常运行

因此C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板

特化（specialization）模板函数

template <>
bool myCompare(Person &p1, Person &p2){}

特化是指针对某些特定的类型，提供一种特殊的实现方式。在这个例子中，我们对模板函数myCompare进行了特化，针对Person类型的参数提供了一种特殊的实现方式。

在这个特化的模板函数中，我们使用了template <>语法来表示这是一个特化的模板函数。在尖括号中不需要指定模板参数，因为我们已经针对特定的类型进行了特化。在函数参数列表中，我们使用了Person &p1和Person &p2来表示这两个参数是Person类型的引用。在函数体中，我们可以根据Person类型的特性来实现具体的比较逻辑。

这个特化的模板函数里面是空的，是因为这个函数的实现方式是根据Person类型的特性来实现的，而不是根据模板参数来实现的。因此，在这个特化的模板函数中，我们不需要再次定义模板参数。

特化模板函数的作用

特化（specialization）模板函数的作用是针对某些特定的类型，提供一种特殊的实现方式。通常情况下，模板函数的实现方式是通用的，适用于多种类型。但是，有些类型可能需要特殊的处理方式，这时候就可以使用特化模板函数来提供特殊的实现方式。

特化模板函数的使用场景比较多，例如：

• 对于某些类型，通用的实现方式可能不够高效，需要针对特定类型进行优化。
• 对于某些类型，通用的实现方式可能不够准确，需要针对特定类型进行特殊处理。
• 对于某些类型，通用的实现方式可能不可用，需要针对特定类型提供特殊的实现方式。

例如，我们可以针对std::string类型提供一个特化的模板函数，来实现字符串的比较：

template <>
bool myCompare(std::string &s1, std::string &s2) {return s1.length() < s2.length();
}

在这个特化的模板函数中，我们使用了template <>语法来表示这是一个特化的模板函数。在尖括号中不需要指定模板参数，因为我们已经针对特定的类型进行了特化。在函数参数列表中，我们使用了std::string &s1和std::string &s2来表示这两个参数是std::string类型的引用。在函数体中，我们根据字符串长度来实现比较逻辑。

特化模板函数可以提高代码的效率和可读性，使得代码更加灵活和易于维护。

特化模板函数、常规模板函数、普通函数的优先级（普通函数 > 特化的模板函数 > 模板函数）

在 C++ 中，函数模板、特化模板函数和普通函数的优先级如下：

1. 普通函数（非模板函数）
2. 特化模板函数
3. 常规模板函数

当编译器在寻找匹配的函数时，它会首先查找普通函数，然后查找特化模板函数，最后查找常规模板函数。这种顺序可以确保在有多个候选函数时，选择最合适的函数。下面是一个例子：

#include <iostream>// 常规模板函数
template <typename T>
void foo(T t) {std::cout << "常规模板函数" << std::endl;
}// 特化模板函数
template <>
void foo<int>(int t) {std::cout << "特化模板函数" << std::endl;
}// 普通函数
void foo(int t) {std::cout << "普通函数" << std::endl;
}int main() {int a = 1;foo(a); // 输出：普通函数return 0;
}

在这个例子中，我们有一个常规模板函数、一个特化模板函数和一个普通函数。当我们调用 foo(a) 时，编译器首先查找普通函数，然后查找特化模板函数，最后查找常规模板函数。因此，输出结果是 “普通函数”。

测试，我们编译运行，然后注释掉普通函数，再编译运行，运行结果：

可以看出普通函数优先级最高，特化模板函数次之，常规模板函数最低

示例：特化的模板函数示例

#include <iostream>
#include <cstdlib>
#include <limits>
#include <string>
using namespace std;class Person
{
public:Person(string name, int age){this->m_Name = name;this->m_Age = age;}string m_Name;int m_Age;
};// 普通函数模板
template <class T>
bool myCompare(T &a, T &b)
{cout << "普通函数模板" << endl;if (a == b){return true;}else{return false;}
}// 具体化，显示具体化的原型和定意思以template<>开头，并通过名称来指出类型
// 具体化优先于常规模板
template <>
bool myCompare(Person &p1, Person &p2)
{cout << "特化函数模板" << endl;if (p1.m_Name == p2.m_Name && p1.m_Age == p2.m_Age){return true;}else{return false;}
}void test01()
{int a = 10;int b = 20;// 内置数据类型可以直接使用通用的函数模板bool ret = myCompare(a, b);if (ret){cout << "a == b " << endl;}else{cout << "a != b " << endl;}
}void test02()
{Person p1("Tom", 10);Person p2("Tom", 10);// 自定义数据类型，不会调用普通的函数模板// 可以创建具体化的Person数据类型的模板，用于特殊处理这个类型bool ret = myCompare(p1, p2);if (ret){cout << "p1 == p2 " << endl;}else{cout << "p1 != p2 " << endl;}
}int main()
{test01();test02();std::cout << "Press ENTER to continue...";std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键return EXIT_SUCCESS;
}

总结

• 利用具体化的模板，可以解决自定义类型的通用化
• 学习模板并不是为了写模板，而是在STL能够运用系统提供的模板

1.3 类模板

1.3.1 类模板语法

类模板作用：

• 建立一个通用类，类中的成员 数据类型可以不具体制定，用一个虚拟的类型来代表。

C++类模板是一种通用的编程工具，它可以让我们编写一种通用的类，可以用来处理多种不同类型的数据。类模板可以让我们编写一次代码，然后可以用来创建多个不同类型的类，这样可以大大减少代码的重复性，提高代码的可重用性和可维护性。
类模板可以用来实现容器类，如vector、list、map等，这些容器类可以存储不同类型的数据，而且可以动态地增加或删除元素。类模板还可以用来实现算法类，如排序、查找等，这些算法可以用来处理不同类型的数据。
总之，C++类模板是一种非常强大的编程工具，可以让我们编写通用的代码，提高代码的可重用性和可维护性，同时也可以让我们更加高效地编写程序。

语法：

template <typename T>
类

或者：

template <class T>
类

解释：

• template — 声明创建模板

• typename — 表面其后面的符号是一种数据类型，可以用class代替

• T — 通用的数据类型，名称可以替换，通常为大写字母（这个在类模板中体现，就是构造类的参数）

示例

#include <iostream>
#include <cstdlib>
#include <limits>
#include <string>
using namespace std;// 类模板
template <typename NameType, typename 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 test01()
{// 指定NameType 为string类型，AgeType 为 int类型Person<string, int> P1("孙悟空", 999);P1.showPerson();// 指定NameType 为string类型，AgeType 为 int类型Person<int, string> P2(5000, "999");P2.showPerson();
}int main()
{test01();std::cout << "Press ENTER to continue...";std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键return EXIT_SUCCESS;
}

总结：类模板和函数模板语法相似，在声明模板template后面加类，此类称为类模板

1.3.2 类模板与函数模板区别（类模板的实例化在编译时完成，函数模板的实例化在调用时完成）

类模板与函数模板区别主要有两点：

1. 类模板没有自动类型推导的使用方式
2. 类模板在模板参数列表中可以有默认参数

类模板和函数模板都是C++中的模板，但它们的作用和使用方式有所不同：
类模板是用来生成类的模板，它可以定义一个通用的类，可以用来处理多种不同类型的数据。类模板中可以包含成员函数、成员变量、静态成员等，可以像普通类一样使用。类模板的实例化是在编译时完成的，即在使用时根据模板参数生成具体的类。
函数模板是用来生成函数的模板，它可以定义一个通用的函数，可以用来处理多种不同类型的数据。函数模板中可以包含函数参数、返回值、局部变量等，可以像普通函数一样使用。函数模板的实例化是在调用时完成的，即在使用时根据模板参数生成具体的函数。
因此，类模板和函数模板的区别在于，类模板用来生成类，函数模板用来生成函数。类模板的实例化是在编译时完成的，函数模板的实例化是在调用时完成的。

关于“类模板的实例化在编译时完成”

类模板是一种通用的类，它可以用来处理多种不同类型的数据。在使用类模板时，需要提供具体的类型参数，然后编译器会根据这些类型参数生成具体的类。这个过程就叫做类模板的实例化。

类模板的实例化是在编译时完成的，也就是说，在编译器编译源代码时，会根据模板参数生成具体的类代码，然后将其编译成可执行文件。这样，在程序运行时，就可以直接使用这些已经生成的具体类，而不需要再进行实例化。

例如，我们定义了一个通用的类模板：

template<typename T>
class MyVector {// ...
};

当我们使用这个类模板时，需要提供具体的类型参数，例如：

MyVector<int> v1;
MyVector<double> v2;

在编译时，编译器会根据这些类型参数生成具体的类代码，例如：

class MyVector_int {// ...
};class MyVector_double {// ...
};

然后将其编译成可执行文件。这样，在程序运行时，就可以直接使用这些已经生成的具体类，而不需要再进行实例化。

关于“类模板没有自动类型推导的使用方式”

C++11引入了自动类型推导的功能，可以让编译器根据变量的初始化表达式自动推导出变量的类型。但是，类模板不支持自动类型推导的使用方式。

类模板的类型参数必须在编译时确定，而自动类型推导是在运行时确定的。因此，类模板不支持自动类型推导的使用方式。

例如，下面的代码是错误的：

template<typename T>
class MyVector {// ...
};auto v = MyVector{1, 2, 3}; // 错误：类模板不支持自动类型推导的使用方式
MyVector v{1, 2, 3}; 		// 错误：类模板不支持自动类型推导的使用方式

在这个例子中，我们使用了自动类型推导的方式来定义变量v，但是由于MyVector是一个类模板，编译器无法根据初始化表达式推导出MyVector的类型参数，因此会报错。

如果要使用类模板，必须显式地指定类型参数，例如：

MyVector<int> v{1, 2, 3}; 						// 正确：显式指定了类型参数
MyVector< int > v = MyVector< int >{1, 2, 3};	// 正确：显式指定了类型参数

在这个例子中，我们显式地指定了MyVector的类型参数为int，因此可以正确地使用类模板。

示例

#include <iostream>
#include <cstdlib>
#include <limits>
#include <string>
using namespace std;// 类模板
template <class NameType, class AgeType = int>
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;
};// 1、类模板没有自动类型推导的使用方式
void test01()
{// Person p("孙悟空", 1000); // 错误 类模板使用时候，不可以用自动类型推导Person<string, int> p("孙悟空", 1000); // 必须使用显示指定类型的方式，使用类模板p.showPerson();
}// 2、类模板在模板参数列表中可以有默认参数
void test02()
{Person<string> p("猪八戒", 999); // 类模板中的模板参数列表 可以指定默认参数p.showPerson();
}int main()
{test01();test02();std::cout << "Press ENTER to continue...";std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键return EXIT_SUCCESS;
}

运行结果：

总结：

• 类模板使用只能用显示指定类型方式
• 类模板中的模板参数列表可以有默认参数

1.3.3 类模板中成员函数创建时机（普通类中的成员函数一开始就可以创建，类模板中的成员函数在调用时才创建）

类模板中成员函数和普通类中成员函数创建时机是有区别的：

• 普通类中的成员函数一开始就可以创建
• 类模板中的成员函数在调用时才创建

示例

#include <iostream>
#include <cstdlib>
#include <limits>
#include <string>
using namespace std;class Person1
{
public:void showPerson1(){cout << "Person1 show" << endl;}
};class Person2
{
public:void showPerson2(){cout << "Person2 show" << endl;}
};template <class T>
class MyClass
{
public:T obj;// 类模板中的成员函数，并不是一开始就创建的，而是在模板调用时再生成void fun1() { obj.showPerson1(); }void fun2() { obj.showPerson2(); }
};void test01()
{MyClass<Person1> m;m.fun1();// m.fun2();//编译会出错，说明函数调用才会去创建成员函数
}int main()
{test01();std::cout << "Press ENTER to continue...";std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键return EXIT_SUCCESS;
}

运行结果：

类模板除了静态成员函数外，普通成员函数在模板实例化时会生成新的函数，即使这个函数使用时不依赖于模板参数类型

如果类模板中的成员函数是一个普通成员函数，那么它在模板实例化时会生成新的函数。

例如：

template<typename T>
class MyClass {
public:void print() {std::cout << "Hello, world!" << std::endl;}
};

在这个例子中，print函数不再依赖于模板参数类型，但它是一个普通成员函数，因此在模板实例化时会生成新的函数。无论我们使用MyClass<int>还是MyClass<double>，都会生成不同的函数。

MyClass<int> myInt;
myInt.print();    // 生成一个函数 void MyClass<int>::print()MyClass<double> myDouble;
myDouble.print(); // 生成一个函数 void MyClass<double>::print()

因此，如果类模板中的成员函数是一个普通成员函数，那么它在模板实例化时会生成新的函数。

1.3.4 类模板对象做函数参数（注意类模板对象这几个字，对象不是普通对象，而是类模板对象）

学习目标：

• 类模板实例化出的对象，向函数传参的方式

一共有三种传入方式：

1. 指定传入的类型 — 直接显示对象的数据类型
2. 参数模板化 — 将对象中的参数变为模板进行传递
3. 整个类模板化 — 将这个对象类型 模板化进行传递

三种传参方式示例：指定传入的类型、参数模板化、整个类模板化（在下面代码中，Person就是一个类模板对象）

#include <iostream>
#include <cstdlib>
#include <limits>
#include <string>
using namespace std;// 类模板
template <class NameType, class AgeType = int>
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;
};// 1、指定传入的类型
void printPerson1(Person<string, int> &p)
{p.showPerson();
}
void test01()
{Person<string, int> p("孙悟空", 100);printPerson1(p);
}// 2、参数模板化
template <class T1, class T2>
void printPerson2(Person<T1, T2> &p)
{p.showPerson();cout << "T1的类型为： " << typeid(T1).name() << endl;cout << "T2的类型为： " << typeid(T2).name() << endl;
}
void test02()
{Person<string, int> p("猪八戒", 90);printPerson2(p);
}// 3、整个类模板化
template <class T>
void printPerson3(T &p)
{cout << "T的类型为： " << typeid(T).name() << endl;p.showPerson();
}
void test03()
{Person<string, int> p("唐僧", 30);printPerson3(p);
}int main()
{test01();test02();test03();std::cout << "Press ENTER to continue...";std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键return EXIT_SUCCESS;
}

运行结果：

1.3.5 类模板与继承（当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型；如果想灵活指定出父类中T的类型，子类也需变为类模板）

当类模板碰到继承时，需要注意一下几点：

• 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型，如果不指定，编译器无法给子类分配内存
• 如果想灵活指定出父类中T的类型，子类也需变为类模板

示例

#include <iostream>
#include <cstdlib>
#include <limits>
#include <string>
using namespace std;template <class T>
class Base
{T m;
};// class Son:public Base  //错误，c++编译需要给子类分配内存，必须知道父类中T的类型才可以向下继承
class Son : public Base<int> // 必须指定一个类型
{
};
void test01()
{Son c;
}// 类模板继承类模板 ,可以用T2指定父类中的T类型
template <class T1, class T2>
class Son2 : public Base<T2>
{
public:Son2(){cout << typeid(T1).name() << endl;cout << typeid(T2).name() << endl;}
};void test02()
{Son2<int, char> child1;
}int main()
{test01();test02();std::cout << "Press ENTER to continue...";std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键return EXIT_SUCCESS;
}

运行结果：

1.3.6 类模板成员函数类外实现（居然都需要把模板加上…）

学习目标：能够掌握类模板中的成员函数类外实现

示例

#include <iostream>
#include <cstdlib>
#include <limits>
#include <string>
using namespace std;// 类模板中成员函数类外实现
template <class T1, class T2>
class Person
{
public:// 成员函数类内声明Person(T1 name, T2 age);void showPerson();public:T1 m_Name;T2 m_Age;
};// 构造函数 类外实现
template <class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{this->m_Name = name;this->m_Age = age;
}// 成员函数 类外实现
template <class T1, class T2>
void Person<T1, T2>::showPerson()
{cout << "姓名: " << this->m_Name << " 年龄:" << this->m_Age << endl;
}void test01()
{Person<string, int> p("Tom", 20);p.showPerson();
}int main()
{test01();std::cout << "Press ENTER to continue...";std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键return EXIT_SUCCESS;
}

运行结果：

1.3.7 类模板分文件编写（注意类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到问题）

学习目标：

• 掌握类模板成员函数分文件编写产生的问题以及解决方式

问题产生原因

问题：

• 类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到

这个问题是因为C++的类模板中的成员函数的创建时机是在调用阶段，而不是在编译阶段。这意味着，如果你在一个源文件中定义了一个类模板，但是在另一个源文件中使用了这个类模板的成员函数，那么编译器在编译第二个源文件时会找不到这些成员函数的定义，从而导致链接错误。
为了解决这个问题，你需要将类模板的定义和实现都放在头文件中，然后在需要使用这个类模板的源文件中包含这个头文件。这样，编译器在编译每个源文件时都能够看到类模板的定义和实现，从而避免了链接错误。

示例（参考cg3.5）：

假设我们有一个类模板 MyVector，用于表示一个动态数组。它的定义和实现分别在 MyVector.h 和 MyVector.cpp 中：

MyVector.h：

#ifndef MYVECTOR_H
#define MYVECTOR_Htemplate<typename T>
class MyVector {
public:MyVector();void push_back(const T& value);
private:T* data;int size;int capacity;
};#endif

MyVector.cpp：

#include "MyVector.h"template<typename T>
MyVector<T>::MyVector() {data = nullptr;size = 0;capacity = 0;
}template<typename T>
void MyVector<T>::push_back(const T& value) {// ...
}

现在我们在另一个源文件 main.cpp 中使用了 MyVector 的成员函数：

#include "MyVector.h"int main() {MyVector<int> vec;vec.push_back(1);return 0;
}

当我们编译 main.cpp 时，编译器会找不到 MyVector<T>::MyVector() 和 MyVector<T>::push_back() 的定义，从而导致链接错误。

为了解决这个问题，我们需要将 MyVector.h 中的类模板定义和实现都放在头文件中：

MyVector.h：

#ifndef MYVECTOR_H
#define MYVECTOR_Htemplate<typename T>
class MyVector {
public:MyVector() {data = nullptr;size = 0;capacity = 0;}void push_back(const T& value) {// ...}
private:T* data;int size;int capacity;
};#endif

这样，在 main.cpp 中包含 MyVector.h 就可以了：

#include "MyVector.h"int main() {MyVector<int> vec;vec.push_back(1);return 0;
}

编译运行：

解决方法

解决：

• 解决方式1：直接包含.cpp源文件
• 解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制（主流的解决方法）

示例

person.hpp中代码：

#pragma once
#include <iostream>
using namespace std;
#include <string>template<class T1, class T2>
class Person {
public:Person(T1 name, T2 age);void showPerson();
public:T1 m_Name;T2 m_Age;
};//构造函数 类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age) {this->m_Name = name;this->m_Age = age;
}//成员函数 类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson() {cout << "姓名: " << this->m_Name << " 年龄:" << this->m_Age << endl;
}

类模板分文件编写classTemplateSubFile.cpp中代码：

#include<iostream>
using namespace std;//#include "person.h"
#include "person.cpp" //解决方式1，包含cpp源文件//解决方式2，将声明和实现写到一起，文件后缀名改为.hpp
#include "person.hpp"
void test01()
{Person<string, int> p("Tom", 10);p.showPerson();
}int main() {test01();system("pause");return 0;
}

编译运行：

1.3.8 类模板与友元（1. 友元全局函数类内实现 2. 友元全局函数类外实现）

关于友元，不懂的可以参考之前的笔记：【黑马程序员 C++教程从0到1入门编程】【笔记4】C++核心编程（类和对象——封装、权限、对象的初始化和清理、构造函数、析构函数、深拷贝、浅拷贝、初始化列表、友元friend、运算符重载）

学习目标：

• 掌握类模板配合友元函数的类内和类外实现

全局函数类内实现 - 直接在类内声明友元即可

全局函数类外实现 - 需要提前让编译器知道全局函数的存在

示例

#include <iostream>
#include <cstdlib>
#include <limits>
#include <string>
using namespace std;// 2、全局函数配合友元  类外实现 - 先做函数模板声明，下方在做函数模板定义，在做友元
template <class T1, class T2>
class Person;// 如果声明了函数模板，可以将实现写到后面，否则需要将实现体写到类的前面让编译器提前看到
// template<class T1, class T2> void printPerson2(Person<T1, T2> & p);template <class T1, class T2>
void printPerson2(Person<T1, T2> &p)
{cout << "类外实现 ---- 姓名： " << p.m_Name << " 年龄：" << p.m_Age << endl;
}template <class T1, class T2>
class Person
{// 1、全局函数配合友元   类内实现friend void printPerson(Person<T1, T2> &p){cout << "类内实现 ---- 姓名： " << p.m_Name << " 年龄：" << p.m_Age << endl;}// 全局函数配合友元  类外实现friend void printPerson2<>(Person<T1, T2> &p);public:Person(T1 name, T2 age){this->m_Name = name;this->m_Age = age;}private:T1 m_Name;T2 m_Age;
};// 1、全局函数在类内实现
void test01()
{Person<string, int> p("Tom", 20);printPerson(p);
}// 2、全局函数在类外实现
void test02()
{Person<string, int> p("Jerry", 30);printPerson2(p);
}int main()
{test01();test02();std::cout << "Press ENTER to continue...";std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键return EXIT_SUCCESS;
}

运行结果：

1.3.9 类模板案例（用类模板构建一个泛型数组）

案例描述: 实现一个通用的数组类，要求如下：

• 可以对内置数据类型以及自定义数据类型的数据进行存储
• 将数组中的数据存储到堆区
• 构造函数中可以传入数组的容量
• 提供对应的拷贝构造函数以及operator=防止浅拷贝问题
• 提供尾插法和尾删法对数组中的数据进行增加和删除
• 可以通过下标的方式访问数组中的元素
• 可以获取数组中当前元素个数和数组的容量

示例

myArray.hpp

#pragma once
#include <iostream>
using namespace std;template <class T>
class MyArray
{
public:// 构造函数MyArray(int capacity){this->m_Capacity = capacity;this->m_Size = 0;pAddress = new T[this->m_Capacity]; // pAddress = new T[this->m_Capacity]; 是在堆内存中分配了一块大小为 m_Capacity * sizeof(T) 的连续内存空间，并将其首地址赋值给指针 pAddress。这里使用了 new 运算符来动态分配内存，T 是模板参数，可以是任意类型。}// 拷贝构造MyArray(const MyArray &arr){this->m_Capacity = arr.m_Capacity;this->m_Size = arr.m_Size;this->pAddress = new T[this->m_Capacity];for (int i = 0; i < this->m_Size; i++){// 如果T为对象，而且还包含指针，必须需要重载 = 操作符，因为这个等号不是 构造 而是赋值，//  普通类型可以直接= 但是指针类型需要深拷贝this->pAddress[i] = arr.pAddress[i];}}// 重载= 操作符  防止浅拷贝问题MyArray &operator=(const MyArray &myarray){if (this->pAddress != NULL){delete[] this->pAddress;	// 在 C++ 中，使用 new 运算符动态分配数组内存空间时，编译器会在分配内存空间时，额外存储一个整数，用于记录数组的大小。这个整数通常被称为“数组长度”，它存储在数组内存空间的前面，占用 4 个字节（32 位系统）或 8 个字节（64 位系统）的空间。当我们使用 delete[] 运算符释放动态分配的数组内存空间时，编译器会自动读取数组长度，并根据数组长度计算出整个数组所占用的内存空间的大小，然后释放该内存空间。因此，我们不需要手动计算数组的大小，也不需要手动释放数组内存空间，编译器会自动完成这些工作。// 这里的 delete[] this->pAddress; 是用来释放 this->pAddress 所指向的动态数组内存空间的语句。delete[] 是 C++ 中用来释放动态分配的数组内存空间的运算符，它会调用数组元素的析构函数，并释放数组所占用的内存空间。在这个代码中，this->pAddress 指向的是一个动态分配的数组，通过 delete[] this->pAddress; 释放该数组所占用的内存空间，避免了内存泄漏的问题。this->m_Capacity = 0;this->m_Size = 0;}this->m_Capacity = myarray.m_Capacity;this->m_Size = myarray.m_Size;this->pAddress = new T[this->m_Capacity];for (int i = 0; i < this->m_Size; i++){this->pAddress[i] = myarray[i];}return *this;}// 重载[] 操作符  arr[0]T &operator[](int index){return this->pAddress[index]; // 不考虑越界，用户自己去处理}// 尾插法void Push_back(const T &val){if (this->m_Capacity == this->m_Size){return;}this->pAddress[this->m_Size] = val;this->m_Size++;}// 尾删法void Pop_back(){if (this->m_Size == 0){return;}this->m_Size--;}// 获取数组容量int getCapacity(){return this->m_Capacity;}// 获取数组大小int getSize(){return this->m_Size;}// 析构~MyArray(){if (this->pAddress != NULL){delete[] this->pAddress;this->pAddress = NULL;this->m_Capacity = 0;this->m_Size = 0;}}private:T *pAddress;	// 指向一个堆空间，这个空间存储真正的数据int m_Capacity; // 容量int m_Size;		// 大小
};

arrayClassEncapsulation.cpp

#include "myArray.hpp"
#include <string>
#include <limits>void printIntArray(MyArray<int> &arr)
{for (int i = 0; i < arr.getSize(); i++){cout << arr[i] << " ";}cout << endl;
}// 测试内置数据类型
void test01()
{MyArray<int> array1(10);for (int i = 0; i < 10; i++){array1.Push_back(i);}cout << "array1打印输出：" << endl;printIntArray(array1);cout << "array1的大小：" << array1.getSize() << endl;cout << "array1的容量：" << array1.getCapacity() << endl;cout << "--------------------------" << endl;MyArray<int> array2(array1);array2.Pop_back();cout << "array2打印输出：" << endl;printIntArray(array2);cout << "array2的大小：" << array2.getSize() << endl;cout << "array2的容量：" << array2.getCapacity() << endl;cout << "--------------------------" << endl;
}// 测试自定义数据类型
class Person
{
public:Person() {}Person(string name, int age){this->m_Name = name;this->m_Age = age;}public:string m_Name;int m_Age;
};void printPersonArray(MyArray<Person> &personArr)
{for (int i = 0; i < personArr.getSize(); i++){cout << "姓名：" << personArr[i].m_Name << " 年龄： " << personArr[i].m_Age << endl;}
}void test02()
{// 创建数组MyArray<Person> pArray(10);Person p1("孙悟空", 30);Person p2("韩信", 20);Person p3("妲己", 18);Person p4("王昭君", 15);Person p5("赵云", 24);// 插入数据pArray.Push_back(p1);pArray.Push_back(p2);pArray.Push_back(p3);pArray.Push_back(p4);pArray.Push_back(p5);printPersonArray(pArray);cout << "pArray的大小：" << pArray.getSize() << endl;cout << "pArray的容量：" << pArray.getCapacity() << endl;cout << "--------------------------" << endl;
}int main()
{test01();test02();std::cout << "Press ENTER to continue...";std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // 读取内容直到用户输入enter键return EXIT_SUCCESS;
}

运行结果：