C++类模板

一、类模板

1、作用

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

2、语法

template<typename T>
类

template --- 声明创建模板

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

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

二、类模板和函数模板的区别

1、类模板没有自动类型推导的使用方式

2、类模板在模板参数列表中可以有默认参数

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
//类模板
template <class NameType=string, 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<> p("猪八戒", 999); //类模板中的模板参数列表 可以指定默认参数
    p.showPerson();
}
int main()
{
    test01();
    test02();
    system("pause");
    return 0;
}

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

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

1、普通类中的成员函数一开始就可以创建

2、类模板中的成员函数在调用时才创建

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
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();
    system("pause");
    return 0;
}

四、类模板对象做函数参数

一共有三种传入方式：

1. 指定传入的类型 --- 直接显示对象的数据类型

2. 参数模板化 --- 将对象中的参数变为模板进行传递

3. 整个类模板化 --- 将这个对象类型模板化进行传递

一般使用第一种方式，因为比较简易

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

其他两种：

 1 #include <bits/stdc++.h>
 2 using namespace std;
 3 const int maxn = 1e5 + 5;
 4 //类模板
 5 template <class NameType, class AgeType = int>
 6 class Person
 7 {
 8 public:
 9     Person(NameType name, AgeType age)
10     {
11         this->mName = name;
12         this->mAge = age;
13     }
14     void showPerson()
15     {
16         cout << "name: " << this->mName << " age: " << this->mAge << endl;
17     }
18 
19 public:
20     NameType mName;
21     AgeType mAge;
22 };
23 //1、指定传入的类型
24 void printPerson1(Person<string, int> &p)
25 {
26     p.showPerson();
27 }
28 void test01()
29 {
30     Person<string, int> p("孙悟空", 100);
31     printPerson1(p);
32 }
33 //2、参数模板化
34 template <class T1, class T2>
35 void printPerson2(Person<T1, T2> &p)
36 {
37     p.showPerson();
38     cout << "T1的类型为： " << typeid(T1).name() << endl;
39     cout << "T2的类型为： " << typeid(T2).name() << endl;
40 }
41 void test02()
42 {
43     Person<string, int> p("猪八戒", 90);
44     printPerson2(p);
45 }
46 //3、整个类模板化
47 template <class T>
48 void printPerson3(T &p)
49 {
50     cout << "T的类型为： " << typeid(T).name() << endl;
51     p.showPerson();
52 }
53 void test03()
54 {
55     Person<string, int> p("唐僧", 30);
56     printPerson3(p);
57 }
58 int main()
59 {
60     test01();
61     test02();
62     test03();
63     system("pause");
64     return 0;
65 }

View Code

五、类模板与继承

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

1、当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型

2、如果不指定，编译器无法给子类分配内存

3、如果想灵活指定出父类中T的类型，子类也需变为类模板

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
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();
    system("pause");
    return 0;
}

六、类模板成员函数类外实现

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
//类模板中成员函数类外实现
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();
    system("pause");
    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;
}

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

#include <bits/stdc++.h>
using namespace std;
#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、全局函数类内实现 - 直接在类内声明友元即可（这个实现起来简单）

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

#include <bits/stdc++.h>
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();
    system("pause");
    return 0;
}

相关阅读:
线性代数思维导图——3.向量
 微分中值定理的基础题型总结
 构造函数
 Python课程笔记（七）
0241. Different Ways to Add Parentheses (M)
0014. Longest Common Prefix (E)
0013. Roman to Integer (E)
0011. Container With Most Water (M)
0010. Regular Expression Matching (H)
0012. Integer to Roman (M)
原文地址：https://www.cnblogs.com/kongbursi-2292702937/p/14726329.html