174讲 类模板

类模板的作用：

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

示例：

#include<iostream>
#include"string"
using namespace std;

template<typename NameType,typename AgeType>//类模板基本语法
class Person {
public:
    Person(NameType name,AgeType age) {
        this->m_Age = age;
        this->m_Name = name;
    }
    NameType getName() {
        return m_Name;
    }
    AgeType getAge() {
        return m_Age;
    }

private:
    NameType m_Name;
    AgeType m_Age;

};

void test() {
    string name1 = "张三";
    double age1 = 12.6;
    Person<string , double> p1(name1, age1);  //类模板调用语法。
    cout << "name = " << p1.getName() << "\t age = " << p1.getAge();
    char temp = 'a';
    int x = 3;
    Person<char, int > p2(temp,x);
    cout << "name = " << p2.getName() << "\t age = " << p2.getAge();
}

void main() {
    test();
}

类模板与函数模板的区别

主要区别：

1. 类模板没有自动类型推导的使用方式；
2. 类模板在模板参数列表中可以有默认参数；(函数模板没有默认参数这个选项。。算是互补了)

template<typename NameType = string,typename AgeType = int>//类模板默认参数基本语法
class Person{

}

Person<> p1("name",19);

类模板对象做函数参数

学习目标：

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

一共有三种传入方式：

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

#include<iostream>
#include"string"
using namespace std;

//类模板对象做函数参数
/*
1. 指定传入的类型----直接显示对象的数据类型
2. 参数模板化----将对象中的参数变为模板进行传递
3. 整个类模板化----将这个对象类型 模板化进行传递
*/
template<class T1,class T2>
class Person {
public:
    Person(T1 name, T2 age) {
        this->name = name;
        this->age = age;
    }
    void showPerson() {
        cout << "Hello World" << endl;
        cout << "name = " << this->name << "\t age = " << this->age << endl;
    }
    T1 name;
    T2 age;
};

//1.显示传递，指定传入类型为Person .
void printPerson1(Person<string,int> &p1) {

    p1.showPerson();

}

void test1() {
    Person<string, int> p1("张三", 18);
    printPerson1(p1);
}

//2.参数模板化
template<class T1,class T2>
void printPerson2(Person<T1,T2> &p) {
    p.showPerson();

}

void test2() {
    Person<string, int> p2("李四",12);
    printPerson2(p2);
}

//3.类模板化
template<class T>
void printPerson3(T &p) {
    p.showPerson();
}

void test3() {
    Person<string, int> p3("瓦伦丁", 11);
    printPerson3(p3);
}

void main() {
    test1();
    test2();
    test3();
}

Summary

• 通过类模板创建对象，可以有3种 传参方式
• 使用较为广泛的是第一种 ---指定传入类型。

知识点：想要知道自身的数据类型可以用 typeid(T).name();来查明其数据类型。

类模板与继承

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

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

#include<iostream>
#include "string"
using namespace std;

template<class T>
class Base {
public:
    Base() {
        cout << "父类中T 的类型为： " << typeid(T).name() << endl;
    }
    T name;
    int age;
};

class Son : public Base<string> { //这里必须指定父类的数据类型，不然编译器在创建子类对象的时候不知道给它分配多少内存
};

//如果想要灵活地指定父类的类型，子类也需要编程模板类
template<class T1,class T2>
class Son2 :public Base<T2> {
public:
    Son2() {
        cout << "T1 的数据类型为：" << typeid(T1).name() << endl;
        cout << "T2 的数据类型为：" << typeid(T2).name() << endl;
    }
    T1 Son_Hobby;//
};

void main() {
    Son2<string,int> son2;
}

Summary

如果父类是类模板，子类需要指定出父类的数据类型。不然编译器懵了，它不知道创建对象时候分配多少内存。

类模板成员函数类外实现

#include<iostream>
#include"string"
using namespace std;
template <class T1,class T2>
class Person {
public:
    Person(T1 name, T2 age) {
        this->m_Age = age;
        this->m_Name = name;
    }
    void showPerson();
    T1 m_Name;
    T2 m_Age;
};

template<class T1,class T2>
void Person<T1,T2>::showPerson() {
    cout << "m_Name = " << m_Name << "\t m_Age= " << this->m_Age << endl;
}

void test() {
    Person<string, int> p1("法外狂徒", 18);
    p1.showPerson();
}

void main() {

    test();
}

Summary

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

template void Person::showPerson() {}

下一步类文件的分文件编写。