小知识，大挑战！本文正在参与“程序员必备小知识”创作活动。

本文已参与「掘力星计划」，赢取创作大礼包，挑战创作激励金。

类模板

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

语法:

template<typename T>

类

解释:

template : 声明创建模板
typename : 表明其后面的符号是一种数据类型，可以使用 class 代替
T : 通用的数据类型，名称可以替换，通常为大写字母

【demo】：

#include <iostream>
using namespace std;

// 类模板
template <class NameType, class AgeType>
class Person
{
public:
    NameType mName;
    AgeType mAge;

public:
    Person(NameType name, AgeType age)
    {
        this->mName = name;
        this->mAge = age;
    }

    void showPerson()
    {
        cout << "姓名：" << this->mName << "，年龄：" << this->mAge << endl;
    }
};

void test01()
{
    // 指定NameType 为string 类型， AgeType为int 类型
    Person<string, int> p1("张三", 20);
    p1.showPerson();
}
int main()
{
    test01();
    return 0;
}

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

类模板与函数模板的区别

类模板没有自动类型推导的使用
类模板在模板参数列表中可以有默认参数 【demo】：

#include <iostream>

using namespace std;

template <class NameType, class AgeType>
class Person
{
public:
    NameType mName;
    AgeType mAge;

public:
    Person(NameType name, AgeType age)
    {
        this->mName = name;
        this->mAge = age;
    }

    void showPerson()
    {
        cout << "姓名:" << this->mName << ",年龄:" << this->mAge << endl;
    }
};

// 类模板没有自动类型推导机制，需要显示指定类型，否则报错
void test01()
{
    // Person p("张三", 20); // 错误，类模板使用的时候不进行类型自动推导
    Person<string, int> p("张三", 20); // 必须使用显示的指定类型 的方式
    p.showPerson();
}

// 类模板在模板参数列表中可以没有默认参数
void test02()
{
    // Person<string> p("李四", 21); // 类模板中的模板参数列表，可以指定默认参数
    // p.showPerson();
}

int main()
{
    test01();
    // test02();

    return 0;
}

类模板中成员函数创建时机

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

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

#include <iostream>

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 func1()
    {
        obj.showPerson1();
    }
    void func2()
    {
        obj.showPerson2();
    }
};

void test01()
{

    MyClass<Person1> m;
    m.func1();
    // m.func2(); // 编译会报错，说明函数调用才会去创建成员函数
    /*
        ./demo3.cpp:34:13: error: ‘class Person1’ has no member named ‘showPerson2’; did you mean ‘showPerson1’?
         34 |         obj.showPerson2();
            |         ~~~~^~~~~~~~~~~
            |         showPerson1
    */
    MyClass<Person2> m2;
    m2.func2();
}

int main()
{
    test01();
    return 0;
}

【小结】：类模板中的成员函数只有在调用的时候才会创建

类模板对象做函数参数

【目标】：类模板实例化的对象，向函数传参的方式

一共有三种传参方式：

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

【demo】：

#include <iostream>
#include <string>

using namespace std;

// 类模板
template <class NameType, class AgeType = int>
class Person
{
public:
    NameType mName;
    AgeType mAge;

public:
    Person(NameType name, AgeType age)
    {
        this->mName = name;
        this->mAge = age;
    }
    void showPerson()
    {
        cout << "姓名：" << this->mName << " , 年龄：" << this->mAge << endl;
    }
};
// 1、指定传入的类型
void printPerson1(Person<string, int> &p)
{
    p.showPerson();
}

void test01()
{
    Person<string, int> p = {"张三", 20};
    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 = {"李四", 20};
    printPerson2(p);
}

// 3、整个类模板化
template <class T>
void printPerson3(T &p)
{
    cout << "T的类型为：" << typeid(T).name() << endl;
    p.showPerson();
}
void test03()
{
    Person<string, int> p = {"王五", 20};
    printPerson3(p);
}

int main()
{
    test01();
    test02();
    test03();

    return 0;
}

【小结】

通过类模板创建的对象，可以有三种方式向函数进行传参
使用比较广泛是第一种：指定传入的类型

类模板与继承

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

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

#include <iostream>

using namespace std;

template <class T>
class Base
{
    T m;
};
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> child;
}

int main()
{
    test01();
    test02();
    // test03();

    return 0;
}

【小结】：如果父类是类模板，子类需要指出父类中T的数据类型

类模板成员函数类外实现

【demo】：

#include <iostream>

using namespace std;

// 类模板中成员函数在类外实现

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 << "姓名：" << this->mName << "，年龄：" << this->mAge << endl;
}

void test01()
{
    Person<string, int> p = {"张三", 20};
    p.showPerson();
}

int main()
{
    test01();

    return 0;
}

【注】：类模板中成员函数类外实现时，需要加上模板参数列表

类模板分文件编写

【问题】：

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

【解决】：

直接包含.cpp文件
将声明和实现写到同一个文件中，并更改后缀名为.hpp ，hpp是约定的名称，并不是强制（person.hpp） 【法2、demo】：

//person.hpp
#include <iostream>
#include <string>

using namespace std;

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 << "姓名：" << this->mName << ",年龄：" << this->mAge << endl;
}

//demo.cpp
#include "person.hpp"
void test01()
{
    Person<string, int> p = {"张三", 20};
    p.showPerson();
}

int main()
{
    test01();
    return 0;
}

【主流】：第2种方式（将声明和实现写在同一个文件中，之后改后缀名为.hpp）

类模板与友元

全局函数类内实现：直接在类内声明友元
全局函数类外实现：需要提前让编译器知道全局函数的存在 【demo】：

#include <iostream>

using namespace std;

// 2、全局函数配合友元 类外实现 - 先做函数模板声明，下方在做函数模板定义，在做友元
template <class T1, class T2>
class Person;
//若声明了函数模板，可以将实现写到后面，否则需要将实现体写到类的前面让编译器提前看到
template <class T1, class T2>
void printPerson2(Person<T1, T2> &p)
{
    cout << "友元函数， 类外实现 "
         << "姓名：" << p.mName << "，年龄：" << p.mAge << endl;
}

template <class T1, class T2>
class Person
{

    // 全局函数配合友元  类内实现
    friend void printPerson(Person<T1, T2> &p)
    {
        cout << "友元函数，类内实现 "
             << "姓名：" << p.mName << "，年龄：" << p.mAge << endl;
    }
    // 全局函数配合友元  类外实现
    friend void printPerson2<>(Person<T1, T2> &p);

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

private:
    T1 mName;
    T2 mAge;
};

// 1、全局函数在类内实现
void test01()
{
    Person<string, int> p = {"张三", 20};
    printPerson(p);
}

// 2、全局函数 在类外实现
void test02()
{
    Person<string, int> p("李四", 21);
    printPerson2(p);
}

int main()
{
    test01();
    test02();
    return 0;
}

【C++模板篇之类模板】

类模板

类模板与函数模板的区别

类模板中成员函数创建时机

类模板对象做函数参数

类模板与继承

类模板成员函数类外实现

类模板分文件编写

类模板与友元