黑马C++视频笔记《模板》

/* 模板
 * 概念：建立通用的模具，提高复用性，类型参数化；
 * 模板的特点：
 *  （1）模板不可以直接使用，他只是一个框架；
 *  （2）模板的通用并不是万能的。
 *
 * C++提供两种模板机制：函数模板和类模板。
 *
 *
 * 函数模板
 * 函数模板作用：建立一个通用函数，其函数返回值类型和形参类型可以不具体指定，用一个虚拟的类型来代表。
 * 语法：
 *  ```template<typename T>
 *     函数声明或定义
 *  ```
 *  其中，
 *  （1）template声明创建模板；
 *  （2）typename表明其后面的符号是一种数据类型，也可以用class替代；
 *  （3）T，通用数据类型（一个变量名称），可以替换，通常为大写字母；
 *
 * 两种方式使用函数模板：
 *  如现有函数模板:
 *  ```template<class T>
 *     void mySwap(T &a, T &b)
 *  ```
 *  （1）自动类型推导: `mySwap(a, b)`； // a, b均为int类型
 *  （2）显示指定类型: `mySwap<int>(a, b)`；
 *
 * 函数模板注意事项：
 *  （1）自动类型推导，必须推导出一致的数据类型T才可以使用；
 *  （2）模板必须要确定出T的数据类型，才可以使用。
 *
 * 普通函数和函数模板的区别：
 *  （1）普通函数调用时可以发生自动类型转换（隐式类型转换，如float转int）；
 *  （2）函数模板调用时，如果利用【自动类型推导，不会发生隐式类型转换】；
 *  （3）如果利用【显示指定类型的方式，可以发生隐式类型转换】。
 * 建议使用显示指定类型方式调用函数模板，因为可以自己确定通用类型T。
 *
 * 普通函数与函数模板的调用规则：
 *  （1）如果函数模板和普通函数都可以实现，优先调用普通函数；
 *  （2）可以通过【空模板参数列表】来强调函数模板；
 *  （3）函数模板也可以发生重载；
 *  （4）如果函数模板可以产生更好的匹配，则优先调用函数模板；
 *
 *
 * 类模板
 * 作用：建立一个通用类，类中的成员数据类型可以不具体指定，用一个虚拟的类型来代表.
 * 语法：```template <class T>
 *         类
 *      ```
 *
 * 类模板与函数模板的区别主要有两点:
 *  （1）类模板【没有自动类型推导】的使用方式，只能显示指定类型；
 *  （2）类模板在模板参数列表中可以有默认参数。
 *
 * 类模板中成员函数的创建时机与普通类中成员函数的创建时机有区别：
 *  （1）普通类成员函数一开始就可以创建；
 *  （2）类模板中的成员函数【在调用时才创建】，确定类型后才能确定有没有该方法；
 *
 * 类模板对象做函数参数（即类模板实例化出的对象，向函数传参的方式）：
 * ```
 *  // 简单定义一个类
 *  template<class T1, class T2>
 *  Person{
 *  public:
 *      Person(T1 name, T2 age){
 *      this->m_name = name;
 *      this->m_age = age;
 *      }
 *
 *      T1 m_name;
 *      T2 m_age;
 *  };
 * ```
 *  （1）指定传入的类型：直接显示对象的数据类型；
 *      ```
 *      void myPrint1(Person<string, int> &p); // 简单声明一个函数
 *      Person<string, int> p("孙悟空", 100);  // 显示指定类型实例化一个对象
 *      myPrint1(p); // 调用函数
 *      ```
 *  （2）参数模板化：将对象中的参数变为模板进行传递；
 *      ```
 *      template<class T1, class T2>
 *      void myPrint2(Person<T1, T2> &p); // 即类模板搭配函数模板定义函数
 *      Person<string, int> p("孙悟空", 100); // 显示指定类型实例化一个对象
 *      myPrint2(p2);  // 调用函数
 *      ```
 *  （3）整个类模板化：将这个对象类型，模板化进行传递;
 *      ```
 *      template<class T>
 *      void myPrint3(T &p); // 简单定义一个函数
 *      Person<string, int> p("孙悟空", 100); // 显示指定类型实例化一个对象
 *      myPrint3(p);
 *      ```
 * 一般都是用第一种方式进行函数传参，更加简单方便直观。
 *
 * 类模板与继承
 * 当类模板碰到继承时，需要注意以下几点：
 *  （1）当子类继承的父类是一个类模板时，子类在声明的时候，【要指定出父类中T的类型】；
 *  （2）如果不指定，编译器无法给子类分配内存；
 *  （3）如果想灵活指定父类中T的类型，子类也需要变为模板；
 *
 * 类模板成员函数的类外实现
 * ```
 * // 声明类及其成员函数
 * template<class T1, class T2>
 * class Person{
 * public:
 *  Person(T1 name, T2 age); // 有参构造函数
 *  void showPerson();  // 成员函数
 * }
 *
 * // 类外实现
 * template<class T1, class T2>   // 必须要加上这个
 * Person<T1, T2>:: Person(T1 name, T2 age){}; // 类外实现构造函数
 *
 * template<class T1, class T2> // 必须加上这个
 * Person<T1, T2>:: showPerson(){}; // 作用域后面加上<T1, T2>，以表明这是类模板中的成员函数
 * ```
 *
 * 类模板分文件编写
 * 问题：类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到。
 * 解决方式：
 *  （1）直接包含.cpp源文件，即 `include "myClassTemplate.cpp"`;
 *  （2）将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，非强制要求。
 * 一般都是采用第二种方法。
 *
 * 类模板与友元
 *  （1）全局函数类内实现：直接在类内声明友元实现即可；
 *  （2）全局函数类外实现：需要提前让编译器知道全局函数的存在，即：
 *      ```
 *      // (1)先声明模板类让编译器知道模板类的存在
 *      template<class T1, class T2>
 *      class Person;
 *
 *      // (2)再类外实现全局友元函数
 *      template<class T1, class T2>
 *      void myFriend(Person<T1, T2> p);
 *
 *      // (3)最后声明定义类
 *      template<class T1, class T2>
 *      class Person{
 *          friend myFriend<>(Person<T1, T2> p);
 *      }
 *      ```
 * 一般模板全局函数做友元用类内实现，实现简单，而且编译器可以直接识别。
 */

函数模板案例：

//
// Created by shexuan on 2021/1/17.
//

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


/* 案例描述：
 * （1）利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序；
 * （2）排序规则从大到小，排序算法为选择排序；
 * （3）分别利用char数组和int数组进行测试；
 *
 */


// 排序算法模板
template <class T>
void selectSort(T arr[], int len){
    for (int i=0;i<len;i++){
        int max=i;
        for (int j=i+1; j<len; j++){
            if(arr[j]>arr[max]){
                max = j;
            }
        }
        if (max!=i){
            T temp = arr[i];
            arr[i] = arr[max];
            arr[max] = temp;
        }
    }
}

int main_sort(){
    // 整数数组排序
//    int arr[] = {1,2,3,4,5,6,7,8,9};
//    int len = sizeof(arr)/ sizeof(arr[0]);
//    //selectSort(arr, len);
//    selectSort<int>(arr, len);

    // 字符数组排序
    char arr[] = {'a', 'b', 'c', 'd', 'e'};
    int len = sizeof(arr)/ sizeof(arr[0]);
    cout << "SizeOfArray: " << len << endl;
    selectSort(arr, len);
    for(int i=0; i<len; i++){
        cout << arr[i];
    }
    cout << endl;
}