• CPP 核心编程8-模板

    CPP 核心编程8-模板

    C++另一种编程思想称为 泛型编程 ，主要利用的技术就是模板

    C++提供两种模板机制:函数模板和类模板

    函数模板作用：

    建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。

    语法：

    1. template<typename T>
    2. 函数声明或定义

    解释：

    template --- 声明创建模板

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

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

    1. #include "iostream"
    2.  
    3. using namespace std;
    4. void mySwap(int &a, int &b)
    5. {
    6.     int temp = a;
    7.     a = b;
    8.     b = temp;
    9. }
    10. void mySwap(double &a, double &b)
    11. {
    12.     double temp = a;
    13.     a = b;
    14.     b = temp;
    15. }
    16. //利用模板提供通用的交换函数
    17. template <typename T>
    18. void myTSwap(T &a, T &b)
    19. {
    20.     T temp = a;
    21.     a = b;
    22.     b = temp;
    23. }
    24. void test()
    25. {
    26.     int a = 10;
    27.     int b = 20;
    28.     mySwap(a, b);
    29.     cout << a << endl;
    30.     cout << b << endl;
    31.     double c = 10.2;
    32.     double d = 20.3;
    33.     mySwap(c, d);
    34.     cout << c << endl;
    35.     cout << d << endl;
    36. }
    37. void test2()
    38. {
    39.     char a = 'a';
    40.     char b = 'b';
    41.     // 1 自动类型推导
    42.     myTSwap(a, b);
    43.     cout << a << " " << b << endl;
    44.     // 2 显示指定类型
    45.     int c = 100;
    46.     int d = 200;
    47.     myTSwap<int>(c, d);
    48.     cout << c << " " << d << endl;
    49. }
    50.  
    51. int main()
    52. {
    53.     test();
    54.     test2();
    55.     return 0;
    56. }

    总结：

    • 函数模板利用关键字 template
    • 使用函数模板有两种方式：自动类型推导、显示指定类型
    • 模板的目的是为了提高复用性，将类型参数化

    1.2.2 函数模板注意事项

    注意事项：

    • 自动类型推导，必须推导出一致的数据类型T,才可以使用
    • 模板必须要确定出T的数据类型，才可以使用
    1. #include "iostream"
    2.  
    3. using namespace std;
    4. template <typename T>
    5. void mySwap(T &a, T &b)
    6. {
    7.     T temp = a;
    8.     a = b;
    9.     b = temp;
    10. }
    11. // 1、自动类型推导，必须推导出一致的数据类型T,才可以使用
    12. void test()
    13. {
    14.     int a = 10;
    15.     int b = 20;
    16.     char c = 'c';
    17.     mySwap(a, b); //正确,可以推导出一致的T
    18.     // mySwap(a, c); //错误,推导不出一致的T
    19. }
    20.  
    21. // 2、模板必须要确定出T的数据类型，才可以使用
    22. template <class T>
    23. void func()
    24. {
    25.     cout << "func call" << endl;
    26. }
    27.  
    28. void test1()
    29. {
    30.     // func();//错误 模板不能独立使用,必须确定出T的类型
    31.     func<int>();    //利用显示置顶烈性的方式,给T一个类型,才可以使用改=该模板
    32.     func<double>(); //也可以
    33. }
    34. int main()
    35. {
    36.     test();
    37.     test1();
    38.     return 0;
    39. }

    总结：

    • 使用模板时必须确定出通用数据类型T，并且能够推导出一致的类型

    1.2.3 函数模板案例

    案例描述：

    • 利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序
    • 排序规则从大到小，排序算法为选择排序
    • 分别利用char数组和int数组进行测试
    1. #include "iostream"
    2.  
    3. using namespace std;
    4. template <class T>
    5. void mySort(T arr[], int len)
    6. {
    7.     for (int i = 0; i < len; i++)
    8.     {
    9.         int maxIndex = i;
    10.         for (int j = i + 1; j < len; j++)
    11.         {
    12.             if (arr[maxIndex] < arr[j])
    13.             {
    14.                 maxIndex = j;
    15.             }
    16.         }
    17.         if (maxIndex != i)
    18.         {
    19.             T temp = arr[maxIndex];
    20.             arr[maxIndex] = arr[i];
    21.             arr[i] = temp;
    22.         }
    23.     }
    24. }
    25. template <class T>
    26. void printArray(T arr[], int len)
    27. {
    28.     for (int i = 0; i < len; i++)
    29.     {
    30.         cout << arr[i] << " ";
    31.     }
    32.     cout << endl;
    33. }
    34. void test1()
    35. {
    36.     int arr[] = {32, 3243, 45, 564, 657, 23, 2};
    37.     int len = sizeof(arr) / sizeof(arr[0]);
    38.     mySort(arr, len);
    39.     printArray(arr, len);
    40. }
    41. void test2()
    42. {
    43.     char arr[] = "qwefrhsb";
    44.     int len = sizeof(arr) / sizeof(arr[0]);
    45.     mySort(arr, len);
    46.     printArray(arr, len);
    47. }
    48. int main()
    49. {
    50.     test1();
    51.     test2();
    52.     return 0;
    53. }

    总结：模板可以提高代码复用，需要熟练掌握

    1.2.4 普通函数与函数模板的区别

    普通函数与函数模板区别：

    • 普通函数调用时可以发生自动类型转换（隐式类型转换）
    • 函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
    • 如果利用显示指定类型的方式，可以发生隐式类型转换
    1. #include "iostream"
    2.  
    3. using namespace std;
    4. //普通函数
    5. int myAdd01(int a, int b)
    6. {
    7.     return a + b;
    8. }
    9. //函数模板
    10. template <typename T>
    11. T myAdd02(T a, T b)
    12. {
    13.     return a + b;
    14. }
    15. //使用函数模板时,如果用自动类型推导,不会发生自动类型转换,即隐式类型转换
    16. void test1()
    17. {
    18.     int a = 10;
    19.     int b = 20;
    20.     char c = 'c';
    21.     cout << myAdd01(a, c) << endl; //正确,将char类型的隐式转换为int类型
    22.     // cout << myAdd02(a, c) << endl; //错误,使用自动类型推导时,不会发生隐式类型转换
    23.     cout << myAdd02<int>(a, c) << endl; //正确，如果用显示指定类型，可以发生隐式类型转换
    24. }
    25. int main()
    26. {
    27.     test1();
    28.     return 0;
    29. }

    总结：建议使用显示指定类型的方式，调用函数模板，因为可以自己确定通用类型T

    1.2.5 普通函数与函数模板的调用规则

    调用规则如下：

    1. 如果函数模板和普通函数都可以实现，优先调用普通函数
    2. 可以通过空模板参数列表来强制调用函数模板
    3. 函数模板也可以发生重载
    4. 如果函数模板可以产生更好的匹配,优先调用函数模板
    1. #include "iostream"
    2.  
    3. using namespace std;
    4. //普通函数于模板函数调用规则
    5. void myPrint(int a, int b)
    6. {
    7.     cout << "1调用的普通函数" << endl;
    8. }
    9. template <typename T>
    10. void myPrint(T a, T b)
    11. {
    12.     cout << "2调用的模板函数" << endl;
    13. }
    14. template <typename T>
    15. void myPrint(T a, T b, T c)
    16. {
    17.     cout << "3调用的模板函数" << endl;
    18. }
    19. void test1()
    20. {
    21.     // 1、如果函数模板和普通函数都可以实现，优先调用普通函数
    22.     //  注意 如果告诉编译器  普通函数是有的，但只是声明没有实现，或者不在当前文件内实现，就会报错找不到
    23.     int a = 10;
    24.     int b = 20;
    25.     myPrint(a, b); //调用普通函数
    26.     // 2 可以通过空模板参数列表来强制调用模板函数
    27.     myPrint<>(a, b);
    28.     // 3、函数模板也可以发生重载
    29.     int c = 30;
    30.     myPrint(a, b, c); //调用重载的函数模板
    31.     // 4 如果函数模板可以产生更好的匹配,有限调用函数模板
    32.     char ch1 = 'a';
    33.     char ch2 = 'b';
    34.     myPrint(ch1, ch2); //调用函数模板 因为调用普通的,要发生隐式转换,所以编译器就优先调用函数模板
    35. }
    36. int main()
    37. {
    38.     test1();
    39.     return 0;
    40. }

    1.2.6 模板的局限性

    局限性：

    • 模板的通用性并不是万能的

    例如：

    1. template<class T>
    2. void f(T a, T b)
    3. { 
    4.     a = b;
    5.     }

    在上述代码中提供的赋值操作，如果传入的a和b是一个数组，就无法实现了

    再例如：

    1. template<class T>
    2. void f(T a, T b)
    3. { 
    4.     if(a > b) { ... }
    5.     }

    在上述代码中，如果T的数据类型传入的是像Person这样的自定义数据类型，也无法正常运行

    因此C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板

    1. #include "iostream"
    2.  
    3. using namespace std;
    4. class Person
    5. {
    6. public:
    7.     Person(string name, int age)
    8.     {
    9.         this->m_Name = name;
    10.         this->m_Age = age;
    11.     }
    12.     string m_Name;
    13.     int m_Age;
    14. };
    15. //普通函数模板
    16. template <class T>
    17. bool myCompare(T &a, T &b)
    18. {
    19.     return a == b;
    20. }
    21. //具体化,显示具体化的原型和以template<>开头,并通过名称来指出类型
    22. //具体优化于常规模板
    23. template <>
    24. bool myCompare(Person &p1, Person &p2)
    25. {
    26.     return p1.m_Age == p2.m_Age && p1.m_Name == p2.m_Name;
    27. }
    28.  
    29. void test1()
    30. {
    31.     int a = 10;
    32.     int b = 20;
    33.     //内置数据类型可以直接使用通用的函数模板
    34.     bool ret = myCompare(a, b);
    35.     if (ret)
    36.     {
    37.         cout << "a==b" << endl;
    38.     }
    39.     else
    40.     {
    41.         cout << "a!=b" << endl;
    42.     }
    43. }
    44.  
    45. void test2()
    46. {
    47.     Person p1("Tom", 10);
    48.     Person p2("Tom", 10);
    49.     bool ret = myCompare(p1, p2);
    50.     if (ret)
    51.     {
    52.         cout << "p1==p2" << endl;
    53.     }
    54.     else
    55.     {
    56.         cout << "p1!=p2" << endl;
    57.     }
    58. }
    59. int main()
    60. {
    61.     test1();
    62.     test2();
    63.     return 0;
    64. }

    总结：

    • 利用具体化的模板，可以解决自定义类型的通用化
    • 学习模板并不是为了写模板，而是在STL能够运用系统提供的模板

    1.3 类模板

    1.3.1 类模板语法

    类模板作用：

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

    语法：

    1. template<typename T>
    2. 类

    解释：

    template --- 声明创建模板

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

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

    1. #include "iostream"
    2.  
    3. using namespace std;
    4. template <class NameType, class AgeType>
    5. class Person
    6. {
    7. public:
    8.     Person(NameType name, AgeType age)
    9.     {
    10.         m_Name = name;
    11.         m_Age = age;
    12.     }
    13.     void showPerson()
    14.     {
    15.         cout << "name: " << this->m_Name << " age: " << this->m_Age << endl;
    16.     }
    17.     NameType m_Name;
    18.     AgeType m_Age;
    19. };
    20. void test1()
    21. {
    22.     //置顶NameType 为string类型 AgeType 为 int 类型
    23.     Personint> p1("孙悟空", 1000);
    24.     p1.showPerson();
    25. }
    26.  
    27. void test2()
    28. {
    29. }
    30. int main()
    31. {
    32.     test1();
    33.     test2();
    34.     return 0;
    35. }

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

    1.3.2 类模板与函数模板区别

    类模板与函数模板区别主要有两点：

    1. 类模板没有自动类型推导的使用方式
    2. 类模板在模板参数列表中可以有默认参数
    1. #include "iostream"
    2.  
    3. using namespace std;
    4. //类模板
    5. template <class NameType, class AgeType = int>
    6. class Person
    7. {
    8. public:
    9.     Person(NameType name, AgeType age)
    10.     {
    11.         this->name = name;
    12.         this->age = age;
    13.     }
    14.     void showPerson()
    15.     {
    16.         cout << " age: " << this->age << " name: " << this->name << endl;
    17.     }
    18.     NameType name;
    19.     AgeType age;
    20. };
    21. // 1 类模板没有自动类型推导的使用方式
    22. void test1()
    23. {
    24.     // Person p("孙悟空", 1000);错误 类模板使用时候 不可以用自动类型推导
    25.     Personint> p("孙悟空", 1000);
    26.     p.showPerson();
    27. }
    28. // 2 类模板在模板参数列表中可以有默认参数
    29. void test2()
    30. {
    31.     Person p("猪八戒", 999); //类模板中的模板参数列表 可以指定默认参数
    32.     p.showPerson();
    33. }
    34. int main()
    35. {
    36.     test1();
    37.     test2();
    38.     return 0;
    39. }

    总结：

    • 类模板使用只能用显示指定类型方式
    • 类模板中的模板参数列表可以有默认参数

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

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

    • 普通类中的成员函数一开始就可以创建
    • 类模板中的成员函数在调用时才创建
    1. #include "iostream"
    2.  
    3. using namespace std;
    4. class Person1
    5. {
    6. public:
    7.     void showPerson1()
    8.     {
    9.         cout << "Person1 show" << endl;
    10.     }
    11. };
    12. class Person2
    13. {
    14. public:
    15.     void showPerson2()
    16.     {
    17.         cout << "Person2 show" << endl;
    18.     }
    19. };
    20. template <class T>
    21. class MyClass
    22. {
    23. public:
    24.     T obj;
    25.     //类模板中的成员函数,并不是一开始就创建的,而是在模板调用时再生成
    26.     void fun1()
    27.     {
    28.         obj.showPerson1();
    29.     }
    30.     void fun2()
    31.     {
    32.         obj.showPerson2();
    33.     }
    34. };
    35. void test1()
    36. {
    37.     MyClass m;
    38.     m.fun1();
    39.     // m.fun2(); //编译会出错，说明函数调用才会去创建成员函数
    40. }
    41. int main()
    42. {
    43.     test1();
    44.  
    45.     return 0;
    46. }

    总结：类模板中的成员函数并不是一开始就创建的，在调用时才去创建

    1.3.4 类模板对象做函数参数

    学习目标：

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

    一共有三种传入方式：

    1. 指定传入的类型 --- 直接显示对象的数据类型
    2. 参数模板化 --- 将对象中的参数变为模板进行传递
    3. 整个类模板化 --- 将这个对象类型 模板化进行传递
    1. #include "iostream"
    2.  
    3. using namespace std;
    4. //类模板
    5. template <class NameType, class AgeType = int>
    6. class Person
    7. {
    8. public:
    9.     Person(NameType name, AgeType age)
    10.     {
    11.         this->m_Age = age;
    12.         this->m_Name = name;
    13.     }
    14.     void showPerson()
    15.     {
    16.         cout << "age" << this->m_Age << " name:" << this->m_Name << endl;
    17.     }
    18.  
    19.     NameType m_Name;
    20.     AgeType m_Age;
    21. };
    22. // 1 指定传入的类型
    23. void printPerson1(Personint> &p)
    24. {
    25.     p.showPerson();
    26. }
    27. void test1()
    28. {
    29.     Personint> p("孙悟空", 1000);
    30.     printPerson1(p);
    31. }
    32. // 2 参数模板化
    33. template <typename T1, typename T2>
    34. void printPerson2(Person &p)
    35. {
    36.     p.showPerson();
    37.     cout << "T1的类型为： " << typeid(T1).name() << endl;
    38.     cout << "T2的类型为： " << typeid(T2).name() << endl;
    39. }
    40. void test2()
    41. {
    42.     Personint> p("孙悟空", 1000);
    43.     printPerson2(p);
    44. }
    45.  
    46. // 3 整个类模板化
    47. template <class T>
    48. void printPerson3(T &p)
    49. {
    50.     p.showPerson();
    51.     cout << "T的类型为： " << typeid(T).name() << endl;
    52. }
    53.  
    54. void test3()
    55. {
    56.     Personint> p("a", 100);
    57.     printPerson3(p);
    58. }
    59. int main()
    60. {
    61.     test1();
    62.     test2();
    63.     test3();
    64.  
    65.     return 0;
    66. }

    总结：

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

    1.3.5 类模板与继承

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

    • 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型
    • 如果不指定，编译器无法给子类分配内存
    • 如果想灵活指定出父类中T的类型，子类也需变为类模板
    1. #include "iostream"
    2.  
    3. using namespace std;
    4. template <class T>
    5. class Base
    6. {
    7.     T m;
    8. };
    9. // class Son:public Base //错误 c++编译器需要给子类分配内存,必须知道父类中T的类型才可以向下继承
    10. class Son : public Base<int>
    11. {
    12. };
    13. void test()
    14. {
    15.     Son s;
    16. }
    17. //类模板继承类模板,可以用T2指定父类中的T类型
    18. template <class T1, class T2>
    19. class Son2 : public Base
    20. {
    21. public:
    22.     Son2()
    23.     {
    24.         cout << typeid(T1).name() << endl;
    25.         cout << typeid(T2).name() << endl;
    26.     }
    27. };
    28. void test2()
    29. {
    30.     Son2<int, char> s;
    31. }
    32. int main()
    33. {
    34.     test();
    35.     test2();
    36.     return 0;
    37. }
    38. i
    39. c

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

    1.3.6 类模板成员函数类外实现

    学习目标：能够掌握类模板中的成员函数类外实现

    1. #include "iostream"
    2. using namespace std;
    3. //类模板中成员函数类外实现
    4. template <class T1, class T2>
    5. class Person
    6. {
    7. public:
    8.     //成员函数类内声明
    9.     Person(T1 name, T2 age);
    10.     void showPerson();
    11.     T1 m_Name;
    12.     T2 m_Age;
    13. };
    14. //构造函数 类外实现
    15. template <class T1, class T2>
    16. Person::Person(T1 name, T2 age)
    17. {
    18.     m_Name = name;
    19.     m_Age = age;
    20. }
    21.  
    22. //成员函数 类外实现
    23. template <class T1, class T2>
    24. void Person::showPerson()
    25. {
    26.     cout << "show person" << endl;
    27. }
    28.  
    29. void test()
    30. {
    31.     Personint> p("孙武", 100);
    32.     p.showPerson();
    33. }
    34. int main()
    35. {
    36.     test();
    37.     return 0;
    38. }

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

    1.3.7 类模板分文件编写

    学习目标：

    • 掌握类模板成员函数分文件编写产生的问题以及解决方式

    问题：

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

    解决：

    • 解决方式1：直接包含.cpp源文件
    • 解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制

    person.hpp

    1. #pragma once
    2. #include "iostream"
    3. using namespace std;
    4.  
    5. template <class T1, class T2>
    6. class Person
    7. {
    8. public:
    9.     Person(T1 name, T2 age);
    10.     void showPerson();
    11.  
    12.     int m_Age;
    13.     string m_Name;
    14. };
    15.  
    16. //构造函数 类外实现
    17. template <class T1, class T2>
    18. Person::Person(T1 name, T2 age)
    19. {
    20.     this->m_Age = age;
    21.     this->m_Name = name;
    22. }
    23.  
    24. //成员函数 类外实现
    25. template <class T1, class T2>
    26. void Person::showPerson()
    27. {
    28.     cout << "name:" << this->m_Name << " age " << this->m_Age << endl;
    29. }

    mian.cpp

    1.  
    2.  
    3. #include "person.hpp"
    4.  
    5. void test()
    6. {
    7.     Personint> p("bob", 100);
    8.     p.showPerson();
    9. }
    10. int main()
    11. {
    12.     test();
    13.     return 0;
    14. }

    总结：主流的解决方式是第二种，将类模板成员函数写到一起，并将后缀名改为.hpp

    1.3.8 类模板与友元

    学习目标：

    • 掌握类模板配合友元函数的类内和类外实现

    全局函数类内实现 - 直接在类内声明友元即可

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

    1. #include "iostream"
    2. using namespace std;
    3.  
    4. // 1 全局函数配合友元 类内实现
    5. template <class T1, class T2>
    6. class Person
    7. {
    8.     friend void showPerson(const Person &p)
    9.     {
    10.         cout << "age " << p.mage << " name" << p.mname << endl;
    11.     }
    12.  
    13. public:
    14.     Person(T1 name, T2 age)
    15.     {
    16.         this->mage = age;
    17.         this->mname = name;
    18.     }
    19.  
    20. private:
    21.     int mage;
    22.     string mname;
    23. };
    24. void test()
    25. {
    26.     Personint> p("bob", 22);
    27.     showPerson(p);
    28. }
    29. int main()
    30. {
    31.     test();
    32.     return 0;
    33. }
    1. #include "iostream"
    2. using namespace std;
    3.  
    4. template <class T1, class T2>
    5. class Person;
    6.  
    7. //如果声明了函数模板，可以将实现写到后面，否则需要将实现体写到类的前面让编译器提前看到
    8. // template 
    9. // void showPerson2(const Person &p);
    10.  
    11. //这里放到Person类的前面,就不需要上面注释的 声明函数模板
    12. template <class T1, class T2>
    13. void showPerson2(const Person &p)
    14. {
    15.     cout << "age " << p.mage << " name" << p.mname << endl;
    16. }
    17.  
    18. template <class T1, class T2>
    19. class Person
    20. {
    21.     // 1 全局函数配合友元 类内实现
    22.     friend void showPerson(const Person &p)
    23.     {
    24.         cout << "age " << p.mage << " name" << p.mname << endl;
    25.     }
    26.     //全局函数配合友元  类外实现
    27.     // friend void showPerson2(const Person &p); 这是普通全局函数的友元 得加<>
    28.     friend void showPerson2<>(const Person &p);
    29.  
    30. public:
    31.     Person(T1 name, T2 age)
    32.     {
    33.         this->mage = age;
    34.         this->mname = name;
    35.     }
    36.  
    37. private:
    38.     int mage;
    39.     string mname;
    40. };
    41.  
    42. void test1()
    43. {
    44.     Personint> p("bob", 22);
    45.     showPerson(p);
    46. }
    47. void test2()
    48. {
    49.     Personint> p("wade", 33);
    50.     showPerson2(p);
    51. }
    52.  
    53. //放到Person类的后面,就需要提前在类前面声明函数模板,让编译器知道
    54. // template 
    55. // void showPerson2(const Person &p)
    56. // {
    57. //     cout << "age " << p.mage << " name" << p.mname << endl;
    58. // }
    59.  
    60. int main()
    61. {
    62.     test1();
    63.     test2();
    64.     return 0;
    65. }

    总结：建议全局函数做类内实现，用法简单，而且编译器可以直接识别

  • 相关阅读:
    oracle客户端的安装（SQL Developer）
    最难的IB课程为什么含金量最高？
    力扣第47天--- 第647题、第516题
    SQLMAP插件tamper模块介绍
    ...args: any[] TypeScript 中的剩余参数语法
    SpringMVC-接收请求中的json数据及日期类型参数传递
    下班后根本联系不上，这样的员工可以辞退吗
    插入排序算法的速度测试 [数据结构][Java]
    No141.精选前端面试题，享受每天的挑战和学习
    Linux内核内存管理：详解虚拟地址空间-MMU
  • 原文地址：https://blog.csdn.net/wade1010/article/details/128192027