C++语言基础：模板——函数模板和类模板

• 1. template<typename T>

• 2. 函数声明或定义

• 1. template——声明创建模板

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

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

void swapInt(int& a, int& b) { // 普通的交换函数
    int temp = a;
    a = b;
    b = temp;
}

template <typename T> // 声明模板
void swapNum(T& a, T& b) { // 模板类型的交换函数
    T temp = a;
    a = b;
    b = temp;
}

void test01() {
    int a = 10;
    int b = 20;
    swapNum(a, b); // 1. 自动类型推导
    swapNum<int>(a, b); // 2. 显示指定类型
    cout << "a= " << a << " b = " << b << endl;
}

• a = b}

• template<> bool myCompare(Person& a, Person& b)

class Person
{
public:
    Person(string name, int age) {
        m_Name = name;
        m_Age = age;
    }

    string m_Name;
    int m_Age;
};

// 比较模板函数
template<class T> // 声明模板
bool myCompare(T& a, T& b) {
    return a == b;
}

template<> bool myCompare(Person& a, Person& b) {
    return a.m_Age == b.m_Age && a.m_Name == b.m_Name;
}

void test01() {
    int a = 10;
    int b = 10;
    cout << myCompare(a, b) << endl;
    Person p1("张三", 18);
    Person p2("张三", 18);
    cout << myCompare(p1, p2) << endl;
}

• 语法定义
  • 1. template<typename T>
  • 2. 类

• 语法解释
  • 1. template——声明创建模板
  • 2. typename——表明其后面的符号是一种数据类型，可以用class代替
  • 3. T——通用的数据类型，名称可以替换，通常为大写字母

• template<class NameType, class AgeType>
  class Person
  {
  public:
      Person(NameType name, AgeType age) {
          this->m_Name = name;
          this->m_Age = age;
      }
  
      NameType m_Name;
      AgeType m_Age;
  };
  
  void test01() {
      Person<string, int> p1("张三", 18);
      cout << p1.m_Age << p1.m_Name << endl;
  }

• 示例：template<class NameType = string, class AgeType = int> // string 和int就是默认参数

template<class T1, class T2>
class Person
{
public:
    Person(T1 name, T2 age) {
        this->m_Name = name;
        this->m_Age = age;
    }

    void showPerson() {
        cout << "姓名：" << m_Name << " 年龄：" << m_Name << endl;
    }

    T1 m_Name;
    T2 m_Age;
};

// 1、指定传入的类型——直接显示对象的数据类型
void printPerson1(Person<string, int>& p) {
    p.showPerson();
}

// 2、参数模板化 ——将对象中的参数变成模板进行传递
template<class T1, class T2>
void printPerson2(Person<T1, T2> & p) {
    p.showPerson();
    cout << "T1的类型：" << typeid(T1).name() << "T2的类型：" << typeid(T2).name() << endl;
}

// 3、整个类模板化 ——将这个对象类型模板化进行传递
template<class T>
void printPerson3(T& p) {
    p.showPerson();
    cout << "T的类型：" << typeid(T).name() << endl;
}

void test01() {
    Person p("张三", 18);
    printPerson1(p);
    printPerson2(p);
    printPerson3(p);
}

template<class T1, class T2> // 声明模板
Person<T1, T2>::Person(T1 name, T2 age) { // 在作用域之后加上模板类型
    this->m_Name = name;
    this->m_Age=age;
}