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

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

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

文章目录

- 1 模板
- - 1.1 模板的概念
  - 1.2 函数模板
  - - 1.2.1 函数模板语法
    - - 语法
      - 解释
      - 注意
      - 示例：自动类型推导、显式指定类型
    - 1.2.2 函数模板注意事项
    - - 示例：模板必须要确定出T的数据类型，才可以使用
      - 示例：多类型参数模板
    - 1.2.3 函数模板案例（不同数据类型数组排序）
    - 1.2.4 普通函数与函数模板的区别
    - - 示例：建议调用模板函数时，使用显式指定类型的方式，不容易出错
    - 1.2.5 普通函数与函数模板的调用规则
    - - 示例：当普通函数与模板有冲突时，如果函数模板可以产生更好的匹配，优先调用函数模板（考虑到普通函数存在隐式转换的情况）
    - 1.2.6 模板的局限性
    - - 特化（specialization）模板函数
      - 特化模板函数的作用
        特化模板函数、常规模板函数、普通函数的优先级（普通函数 > 特化的模板函数 > 模板函数）
        示例：特化的模板函数示例
        总结
  - 1.3 类模板
  - - 1.3.1 类模板语法
    - - 示例
      - 总结：类模板和函数模板语法相似，在声明模板template后面加类，此类称为类模板
    - 1.3.2 类模板与函数模板区别（类模板的实例化在编译时完成，函数模板的实例化在调用时完成）
    - - 关于“类模板的实例化在编译时完成”
      - 关于“类模板没有自动类型推导的使用方式”
      - 示例
    - 1.3.3 类模板中成员函数创建时机（普通类中的成员函数一开始就可以创建，类模板中的成员函数在调用时才创建）
    - - 示例
      - 类模板除了静态成员函数外，普通成员函数在模板实例化时会生成新的函数，即使这个函数使用时不依赖于模板参数类型
    - 1.3.4 类模板对象做函数参数（注意`类模板对象`这几个字，对象不是普通对象，而是`类模板对象`）
    - - 三种传参方式示例：指定传入的类型、参数模板化、整个类模板化（在下面代码中，Person就是一个`类模板对象`）
    - 1.3.5 类模板与继承（当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型；如果想灵活指定出父类中T的类型，子类也需变为类模板）
    - - 示例
    - 1.3.6 类模板成员函数类外实现（居然都需要把模板加上...）
    - - 示例
    - 1.3.7 类模板分文件编写（注意`类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到`问题）
    - - 问题产生原因
      - 解决方法
      - 示例
    - 1.3.8 类模板与友元（1. 友元全局函数类内实现 2. 友元全局函数类外实现）
    - - 示例
    - 1.3.9 类模板案例（用类模板构建一个泛型数组）
    - - 示例

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 普通函数与函数模板的调用规则

调用规则如下：

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

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

#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++ 中，函数模板、特化模板函数和普通函数的优先级如下：

普通函数（非模板函数）
特化模板函数
常规模板函数

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

#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 类模板与函数模板区别（类模板的实例化在编译时完成，函数模板的实例化在调用时完成）

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

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

类模板和函数模板都是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 类模板对象做函数参数（注意`类模板对象`这几个字，对象不是普通对象，而是`类模板对象`）

学习目标：

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

一共有三种传入方式：

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

三种传参方式示例：指定传入的类型、参数模板化、整个类模板化（在下面代码中，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_H

template<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_H

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