C++ 泛型编程 模板

客官°小女子只卖身不卖艺 2024-05-05 22:27 151阅读 0赞

1.模板

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

模板的特点：

  • 模板不可以直接使用，它只是一个框架
  • 模板的通用并不是万能的

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

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

2函数模板

函数模板作用：

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

语法：

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

template —- 声明创建模板

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

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

  1. //交换整型函数
  2. void swapInt(int& a, int& b) {
  3.     int temp = a;
  4.     a = b;
  5.     b = temp;
  6. }
  7. //交换浮点型函数
  8. void swapDouble(double& a, double& b) {
  9.     double temp = a;
  10.     a = b;
  11.     b = temp;
  12. }
  13. //利用模板提供通用的交换函数
  14. template<typename T>
  15. void mySwap(T& a, T& b)
  16. {
  17.     T temp = a;
  18.     a = b;
  19.     b = temp;
  20. }
  21. void test01()
  22. {
  23.     int a = 10;
  24.     int b = 20;
  25.     //swapInt(a, b);
  26.     //利用模板实现交换
  27.     //1、自动类型推导
  28.     mySwap(a, b);
  29.     //2、显示指定类型
  30. //    mySwap<int>(a, b);
  31.     cout << "a = " << a << endl;
  32.     cout << "b = " << b << endl;
  33. }

总结：

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

注意事项：

* 自动类型推导，必须推导出一致的数据类型T,才可以使用
* 模板必须要确定出T的数据类型，才可以使用

  1. //利用模板提供通用的交换函数
  2. template<class T>
  3. void mySwap(T& a, T& b)
  4. {
  5.     T temp = a;
  6.     a = b;
  7.     b = temp;
  8. }
  9. // 1、自动类型推导，必须推导出一致的数据类型T,才可以使用
  10. void test01()
  11. {
  12.     int a = 10;
  13.     int b = 20;
  14.     char c = 'c';
  16.     mySwap(a, b); // 正确，可以推导出一致的T
  17.     //mySwap(a, c); // 错误，推导不出一致的T类型
  18. }
  19. // 2、模板必须要确定出T的数据类型，才可以使用
  20. template<class T>
  21. void func()
  22. {
  23.     cout << "func 调用" << endl;
  24. }
  25. void test02()
  26. {
  27.     //func(); //错误，模板不能独立使用，必须确定出T的类型
  28.     func<double>(); //利用显示指定类型的方式，给T一个类型，才可以使用该模板
  29. }

3.普通函数和函数模版的区别

* 普通函数调用时可以发生自动类型转换（隐式类型转换）
* 函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
* 如果利用显示指定类型的方式，可以发生隐式类型转换

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

4.普通函数和函数模板的调用规则

调用规则如下：

  1. 如果函数模板和普通函数都可以实现，优先调用普通函数
  2. 可以通过空模板参数列表来强制调用函数模板
  3. 函数模板也可以发生重载

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

    //普通函数与函数模板调用规则
    void myPrint(int a, int b)
    {

    1.  cout << "调用的普通函数" << endl;

    }

    template
    void myPrint(T a, T b)
    { 

    1.  cout << "调用的模板" << endl;

    }

    template
    void myPrint(T a, T b, T c)
    { 

    1.  cout << "调用重载的模板" << endl;

    }

    void test01()
    {

    1.  //1、如果函数模板和普通函数都可以实现，优先调用普通函数
    2.  // 注意 如果告诉编译器  普通函数是有的，但只是声明没有实现，或者不在当前文件内实现，就会报错找不到
    3.  int a = 10;
    4.  int b = 20;
    5.  myPrint(a, b); //调用普通函数
    7.  //2、可以通过空模板参数列表来强制调用函数模板
    8.  myPrint<>(a, b); //调用函数模板
    10.  //3、函数模板也可以发生重载
    11.  int c = 30;
    12.  myPrint(a, b, c); //调用重载的函数模板
    14.  //4、 如果函数模板可以产生更好的匹配,优先调用函数模板
    15.  char c1 = 'a';
    16.  char c2 = 'b';
    17.  myPrint(c1, c2); //调用函数模板

    }

    int main() {

    1.  test01();
    3.  system("pause");
    5.  return 0;

    }

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

5.函数模版的局限性

**例如：**

```C++
template
void f(T a, T b)
{
a = b;
}
```

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

再例如：

```C++
template
void f(T a, T b)
{
if(a > b) { … }
}
```

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

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

  1. #include<iostream>
  2. using namespace std;
  3. #include <string>
  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.     if (a == b)
  20.     {
  21.         return true;
  22.     }
  23.     else
  24.     {
  25.         return false;
  26.     }
  27. }
  28. //具体化，显示具体函数模板以template<>开头，并通过名称来指出类型
  29. //具体化优先于常规模板
  30. template<> bool myCompare(Person &p1, Person &p2)
  31. {
  32.     if ( p1.m_Name  == p2.m_Name && p1.m_Age == p2.m_Age)
  33.     {
  34.         return true;
  35.     }
  36.     else
  37.     {
  38.         return false;
  39.     }
  40. }
  41. void test01()
  42. {
  43.     int a = 10;
  44.     int b = 20;
  45.     //内置数据类型可以直接使用通用的函数模板
  46.     bool ret = myCompare(a, b);
  47.     if (ret)
  48.     {
  49.         cout << "a == b " << endl;
  50.     }
  51.     else
  52.     {
  53.         cout << "a != b " << endl;
  54.     }
  55. }
  57. void test02()
  58. {
  59.     Person p1("Tom", 10);
  60.     Person p2("Tom", 10);
  61.     //自定义数据类型，不会调用普通的函数模板
  62.     //可以创建具体化的Person数据类型的模板，用于特殊处理这个类型
  63.     bool ret = myCompare(p1, p2);
  64.     if (ret)
  65.     {
  66.         cout << "p1 == p2 " << endl;
  67.     }
  68.     else
  69.     {
  70.         cout << "p1 != p2 " << endl;
  71.     }
  72. }
  74. int main() {
  75.     test01();
  76.     test02();
  77.     return 0;
  78. }
  • 利用具体化的模板，可以解决自定义类型的通用化
  • 学习模板并不是为了写模板，而是在STL能够运用系统提供的模板

6.类模板

类模板作用：

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

语法：

template
类

template —- 声明创建模板

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

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

  1. #include<iostream>
  2. using namespace std;
  3. #include <string>
  4. // 类模板
  5. template<class NameType,class AgeType>
  6. class Person{
  7. public:
  8.     Person(NameType name,AgeType age){
  9.         this->m_Name = name;
  10.         this->m_Age = age;
  11.     }
  12.     void showPerson(){
  13.         cout<<"name:"<<this->m_Name<<" age:"<<this->m_Age<<endl;
  14.     }
  15.     NameType m_Name;
  16.     AgeType m_Age;
  17. };
  19. int main() {
  20. //    指定Nametype为int，Agetype为string
  21.     Person<int,string> p1(10,"Tom");
  22.     p1.showPerson();
  23.     return 0;
  24. }

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

类模板与函数模板区别

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

  1. 类模板没有自动类型推导的使用方式

  2. 类模板在模板参数列表中可以有默认参数

    //类模板
    template

    //1、类模板没有自动类型推导的使用方式
    void test01()
    {

    1.  // Person p("孙悟空", 1000); // 错误 类模板使用时候，不可以用自动类型推导
    2.  Person <string ,int>p("孙悟空", 1000); //必须使用显示指定类型的方式，使用类模板
    3.  p.showPerson();

    }

    //2、类模板在模板参数列表中可以有默认参数
    void test02()
    {

    1.  Person <string> p("猪八戒", 999); //类模板中的模板参数列表 可以指定默认参数
    2.  p.showPerson();

    }

但是我发现，这东西就像占位参数一样，只要有一个默认参数，之后所有的参数都必须有默认参数。

  1. #include<iostream>
  2. using namespace std;
  3. #include <string>
  4. // 类模板 
  5. template<class AgeType =int,class NameType=string >
  6. class Person{
  7. public:
  8.     Person(NameType name,AgeType age){
  9.         this->m_Name = name;
  10.         this->m_Age = age;
  11.     }
  12.     void showPerson(){
  13.         cout<<"name:"<<this->m_Name<<" age:"<<this->m_Age<<endl;
  14.     }
  15.     NameType m_Name;
  16.     AgeType m_Age;
  17. };
  19. int main() {
  20. //    指定Nametype为int，Agetype为string
  21.     Person p1("Tom",20);
  22.     p1.showPerson();
  23.     return 0;
  24. }

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

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

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

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

类模板对象做函数参数

一共有三种传入方式：

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

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

    include

    using namespace std;

    include

    //类模板
    template
    class Person{
    public:

    1.  Person(NameType name,AgeType age){
    2.      this->m_Name = name;
    3.      this->m_Age = age;
    4.  }
    5.  void showPerson(){
    6.      cout<<"name:"<<this->m_Name<<" age:"<<this->m_Age<<endl;
    7.  }
    8.  NameType m_Name;
    9.  AgeType m_Age;

    };
    // 1.指定传入类型
    void printPerson1(Person &p){

    1.  p.showPerson();

    }
    //2.参数模板化
    template
    void printPerson2(Person &p){

    1.  p.showPerson();
    2.  cout<<"T1的类型为："<<typeid(T1).name()<<endl;
    3.  cout<<"T2的类型为："<<typeid(T2).name()<<endl;

    }
    //3.整个类模板化
    template
    void printPerson3(T &p){

    1.  p.showPerson();
    2.  cout<<"T的类型为："<<typeid(T).name()<<endl;

    }
    int main() {

    1.  Person<string,int> p1("Tom",20);
    2.  printPerson1(p1);
    4.  Person<string,int> p2("Jerry",30);
    5.  printPerson2(p2);
    7.  Person<string,int> p3("David",40);
    8.  printPerson3(p3);
    9.  return 0;

    }

类模板与继承

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

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

  1. #include<iostream>
  2. using namespace std;
  3. #include <string>
  4. template<class T>
  5. class Base{
  6.     T m;
  7. };
  8. //  子类继承类模板，必须为父类模板指定类型，否则编译器无法给子类分配内存
  9. class Son :public Base<int>{
  11. };
  12. // 类模板继承类模板，可以用T1或T2指定父类模板的类型
  13. template<class T1,class T2>
  14. class Son2:public Base<T1>{
  15. public:
  16.     Son2(){
  17.         cout<<"T1的类型为："<<typeid(T1).name()<<endl;
  18.         cout<<"T2的类型为："<<typeid(T2).name()<<endl;
  19.     }
  20. };
  21. int main() {
  22.     Son c;
  23.     Son2<int,string> c2;
  24.     return 0;
  25. }

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

类模板成员函数类外实现

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

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

类模板分文件编写

回顾分文件编写

.h文件写声明

.cpp 文件写实现

#pragma once #防止头文件重复包含

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

所以按照之前的写法会报错

解决办法：

1.在main.cpp主函数中引入Person.cpp,而不是.h文件

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

  1. #pragma once
  2. #include <iostream>
  3. using namespace std;
  4. #include <string>
  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. };
  16. //构造函数 类外实现
  17. template<class T1, class T2>
  18. Person<T1, T2>::Person(T1 name, T2 age) {
  19.     this->m_Name = name;
  20.     this->m_Age = age;
  21. }
  23. //成员函数 类外实现
  24. template<class T1, class T2>
  25. void Person<T1, T2>::showPerson() {
  26.     cout << "姓名: " << this->m_Name << " 年龄:" << this->m_Age << endl;
  27. }
  29. #include<iostream>
  30. using namespace std;
  32. //#include "person.h"
  33. #include "person.cpp" //解决方式1，包含cpp源文件
  35. //解决方式2，将声明和实现写到一起，文件后缀名改为.hpp
  36. #include "person.hpp"
  37. void test01()
  38. {
  39.     Person<string, int> p("Tom", 10);
  40.     p.showPerson();
  41. }
  43. int main() {
  45.     test01();
  47.     system("pause");
  49.     return 0;
  50. }

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

类模板与友元

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

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

  1. #include<iostream>
  2. using namespace std;
  3. #include <string>
  5. //***********************************************
  6. //  全局函数类外实现
  7. template<class T1,class T2>
  8. class Person;
  9. template<class T1,class T2>
  10. void printPerson2(Person<T1,T2> p){
  11.     cout<<p.m_Name<<" 类外实现 "<<p.m_Age<<endl;
  12. }
  13. //***********************************************
  15. template<class T1,class T2>
  16. class Person{
  17. //  1.全局函数配合友元 类内实现
  18.     friend void printPerson(Person<T1,T2> p){
  19.         cout<<p.m_Name<<" "<<p.m_Age<<endl;
  20.     }
  21. //    2.全局函数配合友元 类外实现
  22.     friend void printPerson2<>(Person<T1,T2> p);
  23. public:
  24.     Person(T1 name,T2 age){
  25.         this->m_Name = name;
  26.         this->m_Age = age;
  27.     }
  28. private:
  29.     T1 m_Name;
  30.     T2 m_Age;
  31. };
  32. int main() {
  33.     Person<string,int> p("Tom",20);
  34.     printPerson2(p);
  35.     return 0;
  36. }

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

发表评论

表情：
评论列表 （有 0 条评论，151人围观）

还没有评论，来说两句吧...

相关阅读