• C++阶段05笔记01【C++提高编程资料(模板概念、函数模板、类模板)】

    C++| 匠心之作 从0到1入门学编程【视频+课件+笔记+源码】

    目录

    01、模板

    1.1、模板的概念

    1.2、函数模板

    1.2.1、函数模板语法

    1.2.2、函数模板注意事项

    1.2.3、函数模板案例

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

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

    1.2.6、模板的局限性

    1.3、类模板

    1.3.1、类模板语法

    1.3.2、类模板与函数模板区别

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

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

    1.3.5、类模板与继承

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

    1.3.7、类模板分文件编写

    1.3.8、类模板与友元

    1.3.9、类模板案例

    C++提高编程：本阶段主要针对C++泛型编程和STL技术做详细讲解，探讨C++更深层的使用。

    01、模板

    1.1、模板的概念

    模板就是建立通用的模具，大大提高复用性。

    例如生活中的模板。一寸照片模板：

    PPT模板：

     

    模板的特点：1.模板不可以直接使用，它只是一个框架；2.模板的通用并不是万能的。

    1.2、函数模板

    C++另一种编程思想称为泛型编程 ，主要利用的技术就是模板。C++提供两种模板机制：函数模板和类模板。

    1.2.1、函数模板语法

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

    语法：

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

    解释：

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

    示例：

    1. #include 
    2. using namespace std;
    3.  
    4. //交换两个整型数据函数
    5. void swapInt(int &a, int &b) {
    6.     int temp = a;
    7.     a = b;
    8.     b = temp;
    9. }
    10.  
    11. //交换两个浮点型数据函数
    12. void swapDouble(double &a, double &b) {
    13.     double temp = a;
    14.     a = b;
    15.     b = temp;
    16. }
    17.  
    18. //利用模板提供通用的交换函数 //函数模板
    19. template <typename T>//声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型.
    20. void mySwap(T &a, T &b) {
    21.     T temp = a;
    22.     a = b;
    23.     b = temp;
    24. }
    25.  
    26. void test01() {
    27.     int a = 10;
    28.     int b = 20;
    29.     swapInt(a, b);
    30.     cout << "a = " << a << endl;
    31.     cout << "b = " << b << endl;
    32.  
    33.     double c = 1.1;
    34.     double d = 2.2;
    35.     swapDouble(c, d);
    36.     cout << "c = " << c << endl;
    37.     cout << "d = " << d << endl;
    38.  
    39.     //利用函数模板实现交换，两种方式使用函数模板：
    40.     //1、自动类型推导
    41.     mySwap(a, b);
    42.     cout << "a = " << a << endl;
    43.     cout << "b = " << b << endl;
    44.     //2、显示指定类型
    45.     mySwap<int>(a, b);
    46.     cout << "a = " << a << endl;
    47.     cout << "b = " << b << endl;
    48. }
    49.  
    50. int main() {
    51.     test01();
    52.     system("pause");
    53.     return 0;
    54. }

    总结：

    1. 函数模板利用关键字template；

    2. 使用函数模板有两种方式：自动类型推导、显示指定类型；

    3. 模板的目的是为了提高复用性，将类型参数化。

    1.2.2、函数模板注意事项

    注意事项：

    1. 自动类型推导，必须推导出一致的数据类型T才可以使用；

    2. 模板必须要确定出T的数据类型，才可以使用。

    示例：

    1. #include 
    2. using namespace std;
    3.  
    4. //函数模板注意事项
    5. //1、自动类型推导，必须推导出一致的数据类型T才可以使用；
    6. //2、模板必须要确定出T的数据类型才可以使用。
    7.  
    8. //利用模板提供通用的交换函数
    9. template <class T>//typename可以被替换成class
    10. void mySwap(T &a, T &b) {
    11.     T temp = a;
    12.     a = b;
    13.     b = temp;
    14. }
    15.  
    16. // 1、自动类型推导，必须推导出一致的数据类型T才可以使用
    17. void test01() {
    18.     int a = 10;
    19.     int b = 20;
    20.     char c = 'c';
    21.     mySwap(a, b);//正确！可以推导出一致的T.
    22.     //mySwap(a, c);//错误，不能推导出一致的T类型
    23.     cout << "a = " << a << endl;
    24.     cout << "b = " << b << endl;
    25. }
    26.  
    27. // 2、模板必须要确定出T的数据类型才可以使用
    28. template <class T>
    29. void func() {
    30.     cout << "func调用！" << endl;
    31. }
    32.  
    33. void test02() {
    34.     //func();//错误，模板不能独立使用，必须确定出T的类型
    35.     func<int>(); //利用显示指定类型的方式，给T一个类型，才可以使用该模板
    36. }
    37.  
    38. int main() {
    39.     test01();
    40.     test02();
    41.     system("pause");
    42.     return 0;
    43. }

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

    1.2.3、函数模板案例

    案例描述：

    1. 利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序；

    2. 排序规则从大到小，排序算法为选择排序；

    3. 分别利用char数组和int数组进行测试。

    示例：

    1. #include 
    2. using namespace std;
    3.  
    4. //实现通用对数组进行排序的函数
    5. //规则：从大到小
    6. //算法：选择排序
    7. //测试：char数组、int数组
    8.  
    9. //交换的函数模板
    10. template <typename T>
    11. void mySwap(T &a, T &b) {
    12.     T temp = a;
    13.     a = b;
    14.     b = temp;
    15. }
    16.  
    17. template <class T>//也可以替换成typename
    18. //利用选择排序，进行对数组从大到小的排序
    19. void mySort(T arr[], int len) {
    20.     for (int i = 0; i < len; i++) {
    21.         int max = i;//认定最大数值的下标
    22.         for (int j = i + 1; j < len; j++) {
    23.             //认定的最大值比遍历出的数值要小，说明j下标的元素才是真正的最大值
    24.             if (arr[max] < arr[j]) {
    25.                 max = j;//更新最大值下标
    26.             }
    27.         }
    28.         if (max != i) {//如果最大数的下标不是i，则交换两者
    29.             mySwap(arr[max], arr[i]);//交换max和i下标元素
    30.         }
    31.     }
    32. }
    33.  
    34. //提供打印数组模板
    35. template <typename T>//class
    36. void printArray(T arr[], int len) {
    37.     for (int i = 0; i < len; i++) {
    38.         cout << arr[i] << " ";
    39.     }
    40.     cout << endl;
    41. }
    42.  
    43. void test01() {//测试char数组
    44.     char charArr[] = "bdcfeagh";//badcfe
    45.     int num = sizeof(charArr) / sizeof(char);
    46.     mySort(charArr, num);
    47.     printArray(charArr, num);
    48. }
    49.  
    50. void test02() {//测试int数组
    51.     int intArr[] = {7, 5, 8, 1, 3, 9, 2, 4, 6};
    52.     int num = sizeof(intArr) / sizeof(int);
    53.     mySort(intArr, num);
    54.     printArray(intArr, num);
    55. }
    56.  
    57. int main() {
    58.     test01();
    59.     test02();
    60.     system("pause");
    61.     return 0;
    62. }

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

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

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

    • 普通函数调用时可以发生自动类型转换（隐式类型转换）；

    • 函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换；

    • 如果利用显示指定类型的方式，可以发生隐式类型转换。

    示例：

    1. #include 
    2. using namespace std;
    3.  
    4. //普通函数与函数模板区别
    5. //1、普通函数调用可以发生隐式类型转换
    6. //2、函数模板用自动类型推导，不可以发生隐式类型转换
    7. //3、函数模板用显示指定类型，可以发生隐式类型转换
    8.  
    9. //普通函数
    10. int myAdd01(int a, int b) {
    11.     return a + b;
    12. }
    13.  
    14. //函数模板
    15. template <class T>
    16. T myAdd02(T a, T b) {
    17.     return a + b;
    18. }
    19.  
    20. //使用函数模板时，如果用自动类型推导，不会发生自动类型转换,即隐式类型转换
    21. void test01() {
    22.     int a = 10;
    23.     int b = 20;
    24.     char c = 'c';//'c'对应ASCII码99
    25.     cout << myAdd01(a, c) << endl;//正确，将char类型的'c'隐式转换为int类型，'c'对应ASCII码99
    26.  
    27.     //自动类型推导，不会发生隐式类型转换
    28.     //myAdd02(a, c);//报错，使用自动类型推导时，不会发生隐式类型转换
    29.  
    30.     //显示指定类型，会发生隐式类型转换
    31.     myAdd02<int>(a, c);//正确，如果用显示指定类型，可以发生隐式类型转换
    32. }
    33.  
    34. int main() {
    35.     test01();
    36.     system("pause");
    37.     return 0;
    38. }

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

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

    调用规则如下：

    1. 如果函数模板和普通函数都可以实现，优先调用普通函数；

    2. 可以通过空模板参数列表来强制调用函数模板；

    3. 函数模板也可以发生重载；

    4. 如果函数模板可以产生更好的匹配，优先调用函数模板。

    示例：

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

    总结：既然提供了函数模板，最好就不要提供普通函数，否则容易出现二义性。

    1.2.6、模板的局限性

    局限性：模板的通用性并不是万能的。

    例如：

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

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

    再例如：

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

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

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

    示例：

    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. //模板局限性
    6. //模板并不是万能的，有些特定数据类型，需要用具体化的方式做特殊实现
    7.  
    8. class Person {
    9.     public:
    10.         Person(string name, int age) {
    11.             this->m_Name = name;
    12.             this->m_Age = age;
    13.         }
    14.         string m_Name;//姓名
    15.         int m_Age;//年龄
    16. };
    17.  
    18. //普通函数模板
    19. template <class T>
    20. bool myCompare(T &a, T &b) {//对比两个数据是否相等函数
    21.     if (a == b) {
    22.         return true;
    23.     } else {
    24.         return false;
    25.     }
    26. }
    27.  
    28. //具体化，显示具体化的原型和定意思以template<>开头，并通过名称来指出类型
    29. //具体化优先于常规模板
    30. //利用具体化Person的版本实现代码，具体化优先调用
    31. template <>
    32. bool myCompare(Person &p1, Person &p2) {
    33.     if (p1.m_Name == p2.m_Name && p1.m_Age == p2.m_Age) {
    34.         return true;
    35.     } else {
    36.         return false;
    37.     }
    38. }
    39.  
    40. void test01() {
    41.     int a = 10;
    42.     int b = 20;
    43.     //内置数据类型可以直接使用通用的函数模板
    44.     bool ret = myCompare(a, b);
    45.     if (ret) {
    46.         cout << "a == b" << endl;
    47.     } else {
    48.         cout << "a != b" << endl;
    49.     }
    50. }
    51.  
    52. void test02() {
    53.     Person p1("Tom", 10);
    54.     Person p2("Tom", 10);
    55.     //自定义数据类型，不会调用普通的函数模板
    56.     //可以创建具体化的Person数据类型的模板，用于特殊处理这个类型
    57.     bool ret = myCompare(p1, p2);
    58.     if (ret) {
    59.         cout << "p1 == p2" << endl;
    60.     } else {
    61.         cout << "p1 != p2" << endl;
    62.     }
    63. }
    64.  
    65. int main() {
    66.     test01();//a != b
    67.     test02();//p1 == p2
    68.     system("pause");
    69.     return 0;
    70. }

    总结：

    1. 利用具体化的模板，可以解决自定义类型的通用化；

    2. 学习模板并不是为了写模板，而是在STL能够运用系统提供的模板。

    1.3、类模板

    1.3.1、类模板语法

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

    语法：

    1.  template<typename T>
    2.  类

    解释：

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

    示例：

    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. //类模板
    6. template <class NameType, class AgeType>
    7. class Person {
    8.     public:
    9.         Person(NameType name, AgeType age) {
    10.             this->mName = name;
    11.             this->mAge = age;
    12.         }
    13.         void showPerson() {
    14.             cout << "name：" << this->mName << "，age：" << this->mAge << endl;
    15.         }
    16.     public:
    17.         NameType mName;
    18.         AgeType mAge;
    19. };
    20.  
    21. void test01() {
    22.     //指定NameType为string类型，AgeType为int类型
    23.     Personint> P1("孙悟空", 999);
    24.     P1.showPerson();
    25. }
    26.  
    27. int main() {
    28.     test01();
    29.     system("pause");
    30.     return 0;
    31. }

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

    1.3.2、类模板与函数模板区别

    类模板与函数模板区别主要有两点：1.类模板没有自动类型推导的使用方式；2.类模板在模板参数列表中可以有默认参数。

    示例：

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

    总结：1.类模板使用只能用显示指定类型方式；2.类模板中的模板参数列表可以有默认参数。

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

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

    1. 普通类中的成员函数一开始就可以创建；
    2. 类模板中的成员函数在调用时才创建。

    示例： ​

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

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

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

    学习目标：类模板实例化出的对象，向函数传参的方式。

    一共有三种传入方式：

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

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

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

    示例：

    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. //类模板对象做函数参数
    6. //1、指定传入类型
    7. //2、参数模板化
    8. //3、整个类模板化
    9.  
    10. //类模板
    11. //template 
    12. // class Person {
    13. //     public:
    14. //         Person(T1 name, T2 age) {
    15. //             this->mName = name;
    16. //             this->mAge = age;
    17. //         }
    18. //         void showPerson() {
    19. //             cout << "姓名name：" << this->mName << "，年龄age：" << this->mAge << endl;
    20. //         }
    21. //     public:
    22. //         T1 mName;
    23. //         T2 mAge;
    24. // };
    25. template <class NameType, class AgeType = int>
    26. class Person {
    27.     public:
    28.         Person(NameType name, AgeType age) {
    29.             this->mName = name;
    30.             this->mAge = age;
    31.         }
    32.         void showPerson() {
    33.             cout << "姓名name：" << this->mName << "，年龄age：" << this->mAge << endl;
    34.         }
    35.     public:
    36.         NameType mName;
    37.         AgeType mAge;
    38. };
    39.  
    40. //1、指定传入的类型
    41. void printPerson1(Personint> &p) {
    42.     p.showPerson();
    43. }
    44.  
    45. void test01() {
    46.     Personint> p("孙悟空", 100);
    47.     printPerson1(p);
    48.     cout << endl;
    49. }
    50.  
    51. //2、参数模板化
    52. template <class T1, class T2>
    53. void printPerson2(Person &p) {
    54.     p.showPerson();
    55.     cout << "T1的类型为：" << typeid(T1).name() << endl;//T1的类型为：NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
    56.     cout << "T2的类型为：" << typeid(T2).name() << endl;//T2的类型为：i
    57. }
    58.  
    59. void test02() {
    60.     Personint> p("猪八戒", 90);
    61.     printPerson2(p);
    62.     cout << endl;
    63. }
    64.  
    65. //3、整个类模板化
    66. template <class T>
    67. void printPerson3(T &p) {
    68.     cout << "T的数据类型为：" << typeid(T).name() << endl;
    69.     p.showPerson();
    70. }
    71.  
    72. void test03() {
    73.     Personint> p("唐僧", 30);
    74.     printPerson3(p);//T的类型为：6PersonINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiE
    75.     cout << endl;
    76. }
    77.  
    78. int main() {
    79.     test01();
    80.     test02();
    81.     test03();
    82.     system("pause");
    83.     return 0;
    84. }

    总结：

    1. 通过类模板创建的对象，可以有三种方式向函数中进行传参；

    2. 使用比较广泛是第一种：指定传入的类型。

    1.3.5、类模板与继承

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

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

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

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

    示例：

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

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

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

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

    示例：

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

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

    1.3.7、类模板分文件编写

    学习目标：掌握类模板成员函数分文件编写产生的问题以及解决方式。

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

    解决：

    • 解决方式1：直接包含.cpp源文件；

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

    示例：

    person.hpp中代码：

    1. #pragma once//防止头文件重复包含
    2. #include 
    3. #include 
    4. using namespace std;
    5.  
    6. template <class T1, class T2>
    7. class Person {
    8.     public:
    9.         Person(T1 name, T2 age);
    10.         void showPerson();
    11.     public:
    12.         T1 m_Name;
    13.         T2 m_Age;
    14. };
    15.  
    16. //构造函数类外实现
    17. template <class T1, class T2>
    18. Person::Person(T1 name, T2 age) {
    19.     this->m_Name = name;
    20.     this->m_Age = age;
    21. }
    22.  
    23. //成员函数类外实现
    24. template <class T1, class T2>
    25. void Person::showPerson() {
    26.     cout << "姓名：" << this->m_Name << "，年龄：" << this->m_Age << endl;
    27. }

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

    1. #include //类模板分文件编写问题以及解决
    2. using namespace std;
    3.  
    4. //#include "person.h"
    5. #include "person.cpp"//解决方式1，直接包含cpp源文件
    6. //第一种解决方式：直接包含源文件
    7.  
    8. //解决方式2，将声明和实现写到一起，文件后缀名改为.hpp
    9. //第二种解决方式：将.h和.cpp中的内容写到一起，将后缀名改为.hpp文件
    10. //#include "person.cpp"
    11.  
    12. void test01() {
    13.     Personint> p("Tom", 10);
    14.     p.showPerson();
    15. }
    16.  
    17. int main() {
    18.     test01();
    19.     system("pause");
    20.     return 0;
    21. }

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

    1.3.8、类模板与友元

    学习目标：掌握类模板配合友元函数的类内和类外实现。

    1. 全局函数类内实现——直接在类内声明友元即可；
    2. 全局函数类外实现——需要提前让编译器知道全局函数的存在。

    示例：

    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. //2、全局函数配合友元  类外实现 - 先做函数模板声明，下方在做函数模板定义，在做友元
    6. template <class T1, class T2>
    7. class Person;//提前让编译器知道Person类的存在
    8.  
    9. //如果声明了函数模板，可以将实现写到后面，否则需要将实现体写到类的前面让编译器提前看到
    10. // template void printPerson2(Person & p);
    11.  
    12. template <class T1, class T2>
    13. void printPerson2(Person &p) {
    14.     cout << "类外实现 ---- 姓名：" << p.m_Name << "，年龄：" << p.m_Age << endl;
    15. }
    16.  
    17. template <class T1, class T2>
    18. class Person {
    19.     //1、全局函数配合友元-类内实现
    20.     friend void printPerson(Person &p) {//全局函数类内实现
    21.         cout << "姓名：" << p.m_Name << "，年龄：" << p.m_Age << endl;
    22.     }
    23.     //全局函数配合友元-类外实现
    24.     //加空模板参数列表 //如果全局函数是类外实现，需要让编译器提前知道这个函数的存在
    25.     friend void printPerson2<>(Person &p);
    26.     public:
    27.         Person(T1 name, T2 age) {
    28.             this->m_Name = name;
    29.             this->m_Age = age;
    30.         }
    31.     private:
    32.         T1 m_Name;
    33.         T2 m_Age;
    34. };
    35.  
    36. //1、全局函数在类内实现
    37. void test01() {
    38.     Personint> p("Tom", 20);
    39.     printPerson(p);
    40. }
    41.  
    42. //2、全局函数在类外实现
    43. void test02() {
    44.     Personint> p("Jerry", 30);
    45.     printPerson2(p);
    46. }
    47.  
    48. int main() {
    49.     // test01();
    50.     test02();
    51.     system("pause");
    52.     return 0;
    53. }

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

    1.3.9、类模板案例

    案例描述：实现一个通用的数组类，要求如下：

    1. 可以对内置数据类型以及自定义数据类型的数据进行存储；

    2. 将数组中的数据存储到堆区；

    3. 构造函数中可以传入数组的容量；

    4. 提供对应的拷贝构造函数以及operator=防止浅拷贝问题；

    5. 提供尾插法和尾删法对数组中的数据进行增加和删除；

    6. 可以通过下标的方式访问数组中的元素；

    7. 可以获取数组中当前元素个数和数组的容量。

    类模板案例-数组类封装

    示例：

    myArray.hpp中代码

    1. #pragma once//防止头文件重复包含
    2. #include //自己的通用数组类
    3. using namespace std;
    4.  
    5. template <class T>//声明类模板
    6. class MyArray {
    7.     public:
    8.         //构造函数，参数：容量
    9.         MyArray(int capacity) {
    10.             cout << "MyArray有参构造函数调用！" << endl;
    11.             this->m_Capacity = capacity;
    12.             this->m_Size = 0;
    13.             pAddress = new T[this->m_Capacity];
    14.         }
    15.  
    16.         //拷贝构造
    17.         MyArray(const MyArray &arr) {
    18.             cout << "MyArray有参拷贝构造函数调用！" << endl;
    19.             this->m_Capacity = arr.m_Capacity;
    20.             this->m_Size = arr.m_Size;
    21.             this->pAddress = new T[this->m_Capacity];//深拷贝
    22.             for (int i = 0; i < this->m_Size; i++) {//将arr数组中的数据都拷贝过来
    23.                 //如果T为对象，而且还包含指针，必须需要重载=操作符，因为这个等号不是构造而是赋值，
    24.                 //普通类型可以直接=，但是指针类型需要深拷贝
    25.                 this->pAddress[i] = arr.pAddress[i];
    26.             }
    27.         }
    28.  
    29.         //operator=，重载=操作符，防止浅拷贝问题
    30.         MyArray &operator=(const MyArray &myarray) {
    31.             cout << "MyArray的operator=调用！" << endl;
    32.             if (this->pAddress != NULL) {//先判断原来堆区是否有数据，如果有先释放
    33.                 delete[] this->pAddress;
    34.                 this->pAddress = NULL;
    35.                 this->m_Capacity = 0;
    36.                 this->m_Size = 0;
    37.             }
    38.             //深拷贝
    39.             this->m_Capacity = myarray.m_Capacity;
    40.             this->m_Size = myarray.m_Size;
    41.             this->pAddress = new T[this->m_Capacity];//arr.m_Capacity
    42.             for (int i = 0; i < this->m_Size; i++) {
    43.                 this->pAddress[i] = myarray[i];//arr.pAddress[i];
    44.             }
    45.             return *this;
    46.         }
    47.  
    48.         //通过下标方式访问数组中的元素
    49.         T &operator[](int index) {//重载[]操作符，arr[0] = 100
    50.             return this->pAddress[index];//不考虑越界，用户自己去处理
    51.         }
    52.  
    53.         //尾插法
    54.         void Push_back(const T &val) {
    55.             if (this->m_Capacity == this->m_Size) {//判断容量是否等于大小
    56.                 return;
    57.             }
    58.             this->pAddress[this->m_Size] = val;//在数组末尾插入数据
    59.             this->m_Size++;//更新数组大小
    60.         }
    61.  
    62.         //尾删法
    63.         void Pop_back() {//让用户访问不到最后一个元素，即为尾删，逻辑删除
    64.             if (this->m_Size == 0) {
    65.                 return;
    66.             }
    67.             this->m_Size--;
    68.         }
    69.  
    70.         //返回数组容量
    71.         int getCapacity() {//获取数组容量
    72.             return this->m_Capacity;
    73.         }
    74.  
    75.         //返回数组大小
    76.         int getSize() {//获取数组大小
    77.             return this->m_Size;
    78.         }
    79.  
    80.         ~MyArray() {//析构函数
    81.             if (this->pAddress != NULL) {//将堆区数据释放干净
    82.                 cout << "MyArray析构函数调用！" << endl;
    83.                 delete[] this->pAddress;
    84.                 this->pAddress = NULL;
    85.                 this->m_Capacity = 0;
    86.                 this->m_Size = 0;
    87.             }
    88.         }
    89.  
    90.     private:
    91.         T *pAddress;//指针指向堆区开辟的真实数组；指向一个堆空间，这个空间存储真正的数据
    92.         int m_Capacity;//数组容量
    93.         int m_Size;//数组元素个数(数组大小)
    94. };

    类模板案例—数组类封装.cpp中

    1. #include "myArray.hpp"
    2. #include 
    3.  
    4. void printIntArray(MyArray<int> &arr) {//打印输出函数
    5.     for (int i = 0; i < arr.getSize(); i++) {
    6.         cout << arr[i] << " ";
    7.     }
    8.     cout << endl;
    9. }
    10.  
    11. //测试内置数据类型
    12. void test01() {
    13.     MyArray<int> array1(10);
    14.     for (int i = 0; i < 10; i++) {
    15.         //利用尾插法向数组中插入数据
    16.         array1.Push_back(i);
    17.     }
    18.     cout << "array1打印输出为：" << endl;
    19.     printIntArray(array1);
    20.     cout << "array1的大小为：" << array1.getSize() << endl;
    21.     cout << "array1的容量为：" << array1.getCapacity() << endl;
    22.     cout << "--------------------------" << endl;
    23.     MyArray<int> array2(array1);//验证拷贝构造函数
    24.     array2.Pop_back();//尾删
    25.     cout << "array2打印输出：" << endl;
    26.     printIntArray(array2);
    27.     cout << "array2的大小：" << array2.getSize() << endl;
    28.     cout << "array2的容量：" << array2.getCapacity() << endl;
    29.     //MyArray array3(100);
    30.     //array3 = array1;
    31. }
    32.  
    33. //测试自定义数据类型
    34. class Person {
    35.     public:
    36.         Person() {}
    37.         Person(string name, int age) {
    38.             this->m_Name = name;
    39.             this->m_Age = age;
    40.         }
    41.     public:
    42.         string m_Name;
    43.         int m_Age;
    44. };
    45.  
    46. void printPersonArray(MyArray &personArr) {
    47.     for (int i = 0; i < personArr.getSize(); i++) {
    48.         cout << "姓名：" << personArr[i].m_Name << "，年龄：" << personArr[i].m_Age << endl;
    49.     }
    50. }
    51.  
    52. void test02() {
    53.     //创建数组
    54.     MyArray pArray(10);
    55.     Person p1("孙悟空", 30);
    56.     Person p2("韩信", 20);
    57.     Person p3("妲己", 18);
    58.     Person p4("王昭君", 15);
    59.     Person p5("赵云", 24);
    60.     //插入数据，将数据插入到数组中
    61.     pArray.Push_back(p1);
    62.     pArray.Push_back(p2);
    63.     pArray.Push_back(p3);
    64.     pArray.Push_back(p4);
    65.     pArray.Push_back(p5);
    66.     printPersonArray(pArray);//打印数组
    67.     cout << "pArray的大小：" << pArray.getSize() << endl;//输出容量
    68.     cout << "pArray的容量：" << pArray.getCapacity() << endl;//输出大小
    69. }
    70.  
    71. int main() {
    72.     // test01();
    73.     test02();
    74.     system("pause");
    75.     return 0;
    76. }

    总结：能够利用所学知识点实现通用的数组。

  • 相关阅读:
    40-Jenkins-环境变量的使用
    亚马逊跟卖有效找listing，适合各阶段卖家
    磁盘格式化指南：如何正确对磁盘进行分区和初始化？
    我的Vue之旅、02 ES6基础、模块、路径、IO
    零基础都能拿捏的七夕浪漫代码，快去表白或去制造惊喜吧
    [springMVC学习]11、自定义拦截器
    头歌-信息安全技术-用Python实现自己的区块链、支持以太坊的云笔记服务器端开发、编写并测试用于保存云笔记的智能合约、支持以太坊的云笔记小程序开发基础
    IOS常见的bug
    06-JVM-监控及调优案例
    如何成为一个优秀的程序员?
  • 原文地址：https://blog.csdn.net/weixin_44949135/article/details/125977128