• C++泛型编程：函数模板 和 类模板详细介绍。

    1.模板：

    1.1何为模板？

    即模子，生成器。

    1.2C++的模板的形式有两种

    函数模板与类模板。

    1.3如何定义一个函数模板？

    就像定义函数一样，定义一个函数模板，把函数中类型抽象出来，

    同时告诉编译器下面的函数是一个函数模子或函数生成器。

    1.4语法形式：

    1. template + <class T1, class T2 = double, class T3 = int ....>
    2. 模板头中的类型参数列表也可以有默认值。
    3. T add(T a, T b)
    4. {
    5.     return a + b;
    6. }

    1.5模板的编译机制：

    1.编译器并不是把模板处理成能够处理任何类型的函数，而是一个函数或类的生成器。

    2.函数模板通过具体类型产生不同的函数（产生了模板函数）

    3.编译器会对函数模板进行两次编译，第一次在声明的地方对模板本身进行编译，在调用的地方对参数替换后的代码进行编译使用函数模板与真正的函数，谁的调用效率高呢？当然是真正的函数，因为函数模板还需要编译器进行翻译一遍才能调用。所以现开发中并不一定要把所有函数你都要定义成函数模板，所以类型替换之后的函数模板就成了一个函数实例了，这样才能调用。

    1.5.1代码实例：

    1. #include 
    2. using namespace std;
    3. template <class T>
    4. T my_add(T a, T b)
    5. {
    6.     return a + b;
    7. }
    8. int main()
    9. {
    10.     my_add<int>(10,20);
    11.     my_add<float>(3.14f,5.21f);
    12.     my_add<double>(5.21,3.14);
    13.     return 0;
    14. }

    2函数模板

    2.1调用方式：

    2.1.1显式调用：函数名后使用<>尖括号指定具体参数调用。

    1. using namespace std;
    2. template <class T>
    3. T my_add(T a, T b)
    4. {
    5.     return a + b;
    6. }
    7. int main()
    8. {
    9.     
    10.     my_add<int>(10,20);
    11.     my_add<float>(3.14f,5.21f);
    12.     my_add<double>(5.21,3.14);
    13.     return 0;
    14. }

    2.1.1隐式调用:由编译器自动根据参数推导参数类型再调用。

    1. #include 
    2. using namespace std;
    3. template <class T>
    4. T my_add(T a, T b)
    5. {
    6.     return a + b;
    7. }
    8. int main()
    9. {
    10.     
    11.     my_add(10,20);
    12.     my_add(3.14f,5.21f);
    13.     my_add(5.21,3.14);
    14.     return 0;
    15. }

    2.2函数模板的特化与调用优先级：

    2.2.1当只有基础模板和特化模板时。

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. template <class T>
    6. T my_add(T a,T b)
    7. {
    8.     cout<<"这是一个基础模板"<
    9.     return a+b;
    10. }
    11.  
    12. template <class T>
    13. T my_add(int a,int b)
    14. {
    15.     cout<<"这是一个特化模板"<
    16.     return a+b;
    17. }
    18.  
    19.  
    20.  
    21. int main()
    22. {
    23.  
    24.     cout<<my_add(10,20)<
    25.  
    26.     return 0;
    27. }

    结果图：

     当只有基础模板和特化模板时，隐式调用基础模板。

    2.2.2当有基础模板和特化模板，还有实例时候。

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. template <class T>
    6. T my_add(T a,T b)
    7. {
    8.     cout<<"这是一个基础模板"<
    9.     return a+b;
    10. }
    11.  
    12. template <class T>
    13. T my_add(int a,int b)
    14. {
    15.     cout<<"这是一个特化模板"<
    16.     return a+b;
    17. }
    18.  
    19. int my_add(int a,int b)
    20. {
    21.     cout<<"这是一个实例"<
    22.  
    23.     return a+b;
    24. }
    25.  
    26. int main()
    27. {
    28.  
    29.     cout<<my_add(10,20)<
    30.  
    31.     return 0;
    32. }

    结果图：

     当有基础模板和特化模板，还有实例时候，隐式调用用实例。

    2.2.3当有基础模板和特化模板，还有实例时候，显示调用

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. template <class T>
    6. T my_add(T a,T b)
    7. {
    8.     cout<<"这是一个基础模板"<
    9.     return a+b;
    10. }
    11.  
    12. template <class T>
    13. T my_add(int a,int b)
    14. {
    15.     cout<<"这是一个特化模板"<
    16.     return a+b;
    17. }
    18.  
    19. int my_add(int a,int b)
    20. {
    21.     cout<<"这是一个实例"<
    22.  
    23.     return a+b;
    24. }
    25.  
    26. int main()
    27. {
    28.  
    29.    cout<<my_add<int>(10,20)<
    30.  
    31.     return 0;
    32. }

    结果图：

     当有基础模板和特化模板，还有实例时候，显示调用用特化模板。

    2.2.4总结：

    当有函数实例时：隐式调用将直接调用函数实例。

    如果没有函数实例时，隐式调用将直接调用函数模板的基础模板。

    如果使用显示调用，当优先调用特化的与类型匹配的函数模板。

    3.C++11函数模板的新特性：可变参函数模板：

    3.1概念：

    所谓的可变参模板是指类型参数为一一个可变是类型，这个类型使用class...来修饰。

    3.2代码实现：（实现一个c中的printf的函数）

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. void printf()
    6. {
    7.  
    8. }
    9.  
    10. template <class Firstarg,class... Arg>
    11.  
    12. void printf(Firstarg firstarg, Arg... arg)
    13. {
    14.     cout<
    15.  
    16.     printf(arg...);
    17. }
    18. int main()
    19. {
    20.  
    21.     printf("lisi","cc");
    22.  
    23.     return 0;
    24. }

    结果图：

     

    4.类模板

    4.1类模板的定义形式：

    注意：在使用类模板时，不存在编译推导类型，必须手动指定具体类型。

    1. template <class T1, class T2, class T3 ...> 
    2. //class修饰符也可使用typename来修饰。
    3. class + 类名
    4. {
    5.     //类模板的模板体。
    6.     private:
    7.         //类模板中的属性。
    8.     public:
    9.         //类中的方法
    10.     protected:
    11.         
    12. };

    4.2代码实例

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. template <class T1,class T2>
    6. class A
    7. {
    8.     T1 name;
    9.     T2 age;
    10. public:
    11.     A(T1 name,T2 age)
    12.     {
    13.         this->age=age;
    14.         this->name=name;
    15.     }
    16.  
    17.     void show_info()
    18.     {
    19.         cout<<"name="<",age="<
    20.     }
    21. };
    22.  
    23. int main()
    24. {
    25. //    A a("lisi",20);
    26. //    a.show_info();
    27.  
    28.     Aint>* a=new Aint>("lisi",20);
    29.     a->show_info();
    30.     return 0;
    31. }

    结果图：

    5类模板中的特殊属性的初始化方式及继承与多态

    5.1代码实例：

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5. template  <class T1,class T2>
    6. class A
    7. {
    8.     T1 name;
    9.     T2 age;
    10. public:
    11.     A(T1 name,T2 age)
    12.     {
    13.         this->name=name;
    14.         this->age=age;
    15.     }
    16.  
    17.     virtual void show_info()
    18.     {
    19.         cout<<"name="<<this->name<<",age"<
    20.     }
    21.  
    22.     void set_name(T1 name)
    23.     {
    24.         this->name=name;
    25.     }
    26.  
    27.     T1 get_name()
    28.     {
    29.         return  this->name;
    30.     }
    31.  
    32.     void set_age(T2 age)
    33.     {
    34.         this->age=age;
    35.     }
    36.  
    37.     T2 get_age()
    38.     {
    39.         return this->age;
    40.     }
    41. };
    42.  
    43. template <class T1,class T2,class T3>
    44. class B:public A
    45. {
    46.     const int id;
    47.     static int count;
    48. public:
    49.     B(T1 name,T2 age,T3 _id):id(_id),A(name,age)
    50.     {
    51.  
    52.     }
    53.  
    54.     void show_info()
    55.     {
    56.         cout<<"id="<<this->id<<",name="<<this->get_name()<<",age"<<this->get_age()<
    57.     }
    58. };
    59.  
    60. int main()
    61. {
    62.     //1.栈上
    63.     Bint,int> b("lisi",20,1001);
    64.     b.show_info();
    65.  
    66.     //2.堆上
    67.     Bint,int>* b1=new Bint,int>("zhangsan",29,1002);
    68.     b1->show_info();
    69.  
    70.     //3.实现多态
    71.     Aint>* a=new Bint,int>("wangwu",50,1003);
    72.     a->show_info();
    73.  
    74.     return 0;
    75. }

    结果图：

     5.2使用类模板去实现一个数据结构：实现一个顺序栈模板

    5.2.1首先我们使用一下多文件编程，类似于c的那种，我们会发现问题如下：

    main.cpp文件：

    1. #include 
    2. #include "socket.h"
    3.  
    4. using namespace std;
    5.  
    6. int main()
    7. {
    8.     socket<int> s(2);
    9.  
    10.     return 0;
    11. }

    stack.h文件:

    1. #ifndef SOCKET_H
    2. #define SOCKET_H
    3. using namespace std;
    4. #include 
    5.  
    6. template <class T>
    7. class socket
    8. {
    9.     T* m_date;
    10.     int len;
    11.     int max_size;
    12.  
    13. public:
    14.     //构造
    15.     socket(int _len);
    16.     //析构
    17.     ~socket();
    18.     //入栈
    19.     void push(const socket& other);
    20.     //出栈
    21.     void out();
    22.     //获取栈顶的值
    23.     T get_out();
    24.     //判断是否为空
    25.     bool is_empty();
    26.  
    27. };
    28.  
    29. #endif // SOCKET_H

    stack.cpp文件：

    1. #include "socket.h"
    2.  
    3. template <class T>
    4. socket::socket(int _max_size)
    5. {
    6.     this->m_date=new T[len];
    7.     this->len=0;
    8.     this->max_size=_max_size;
    9. }

    结果图：

    结果分析：如图所以，结果告诉我们无法连接到构造函数，这是由于我们使用的是模板类，模板类需要被编译两次，如果我们像这样把stack.cpp和stack.h分开写的话，stack.cpp里面的模板只被编译了一次，所以我们无法连接到构造函数。

    5.2.2使分文件编程的方式实现一个模板栈：

    在C++分文件编程时，在业内常用的一种文件标准是后缀为.hpp的模板文件。

    代码实现：

    stack.cpp文件：

    1. #ifndef STACK_HPP
    2. #define STACK_HPP
    3. using namespace std;
    4. #include 
    5.  
    6. template  <class T>
    7. class Stack
    8. {
    9.     T* my_data;
    10.     int len;
    11.     int max_size;
    12. public:
    13.     //构造函数
    14.     Stack(int _max_size);
    15.  
    16.     //析构函数
    17.     ~Stack();
    18.  
    19.     //入栈
    20.     void push(const int& other);
    21.  
    22.     //出栈
    23.     void out_data();
    24.  
    25.     //获取栈顶的值
    26.     T get_data();
    27.  
    28.     //判断是否为空
    29.     bool is_empty();
    30.  
    31. };
    32.  
    33. #endif // STACK_HPP
    34.  
    35. template <class T>
    36. Stack::Stack(int _max_size)
    37. {
    38.     this->my_data=new int[_max_size];
    39.     this->len=0;
    40.     this->max_size=_max_size;
    41. }
    42.  
    43. template <class T>
    44. Stack::~Stack()
    45. {
    46.     if(this->my_data!=nullptr){
    47.         delete this->my_data;
    48.     }
    49. }
    50.  
    51. template <class T>
    52. void Stack::push(const int& other)
    53. {
    54.     if(this->max_size
    55.         return;
    56.     }
    57.  
    58.     my_data[len]=other;
    59.     ++(this->len);
    60. }
    61.  
    62. template <class T>
    63. void Stack::out_data()
    64. {
    65.     if(len<=0){
    66.         return;
    67.     }
    68.  
    69.     --(this->len);
    70. }
    71.  
    72. template <class T>
    73. T Stack::get_data()
    74. {
    75.     return this->my_data[len-1];
    76. }
    77.  
    78. template <class T>
    79. bool Stack::is_empty()
    80. {
    81.     if(this->len==0){
    82.         return true;
    83.     }
    84.  
    85.     return false;
    86. }

    main.cpp文件：

    1. #include 
    2. #include "stack.hpp"
    3.  
    4. using namespace std;
    5.  
    6. int main()
    7. {
    8.     Stack<int> s(12);
    9.  
    10.     s.push(1);
    11.     s.push(2);
    12.     s.push(3);
    13.  
    14.     while(!s.is_empty()){
    15.         cout<get_data()<
    16.         s.out_data();
    17.     }
    18.     return 0;
    19. }

    结果图：

     分析：因为这次我们把函数的实现放在了hpp文件里面，当我们调用头文件的时候问编译一次，还有就是当调用声明的时候也会编译一次，所以就达到了类模板的使用要求，所以这次我们就可以链接到。

    5.3类模板的特化：

    1. #include 
    2.  
    3. using namespace std;
    4.  
    5.  
    6. template<class T1>
    7. class A
    8. {
    9. public:
    10.     A()
    11.     {
    12.         cout<<"A的基础模板"<
    13.     }
    14. };
    15.  
    16. template <>
    17. class A <int>
    18. {
    19. public:
    20.     A()
    21.     {
    22.         cout<<"A的特化模板"<
    23.     }
    24. };
    25.  
    26. template <class T2,class T3>
    27. class B
    28. {
    29. public:
    30.   B()
    31.   {
    32.       cout<<"B的基础模板"<
    33.   }
    34. };
    35.  
    36. template <class T2>
    37. class Bfloat>
    38. {
    39. public:
    40.     B()
    41.     {
    42.         cout<<"B的偏化模板"<
    43.     }
    44.  
    45. };
    46.  
    47. int main()
    48. {
    49.   A<float> a;
    50.   A<int> a1;
    51.  
    52.   B<int ,int> b1;
    53.   B<int ,float> b2;
    54.  
    55.     return 0;
    56. }

    结果图：

     分析：当使用类模板去定义对象时，因为具体指定使参数类型，所以他将优先调用与之指定类型相匹配的特化或偏特化版本。否则，将直接调用全特化。

    5.4C++中类模板中的内嵌类

    内嵌类一般情况下是为外围类而服务：比如说：STL容器中所提供的迭代器就是一种内嵌类。内嵌类并不是对外公开的，只做为外围类的一个辅助类。隐藏在外围类的内部，对外不可以见。只能通过：：域名访问的形式，才能访问到。

    5.4.1代码实例：

    1. #include 
    2. using namespace std;
    3. template <typename  T>
    4. class A
    5. {
    6. public:
    7.     
    8.     class B
    9.     {
    10.         int a = 100;
    11.         int b = 200;
    12.         static B* c;
    13.     };
    14. };
    15.  
    16. template <class T>
    17. typename A::B* A::B::c =  nullptr;
    18. int main()
    19. {
    20.     A<int> a;
    21.     cout << sizeof (a) << endl;
    22.  
    23.     A<float>::B b1;
    24.     cout << sizeof(b1) <
    25.     return 0;
    26. }

    5.4.2内嵌类需要注意的几点内容：

    1.内嵌类可以访问定义在外围类（enclosing class）中的静态实例变量。外围类不可以访问嵌套类的成员.

    2.不能从内嵌类中访问外部类的非静态成员.

    3.可以在外部通过作用域限定符调用.

  • 相关阅读:
    静态路由 网络实验
    APP性能测试指标
    Linux 文件类信息统计指令(awk、sort、wc -l)
    Spring 四种方式教你异步接口返回结果
    19个Web前端交互式3D JavaScript框架和库
    微信小程序获取用户头像和昵称完美解决方法（最新方法）
    论文综述的重要性及写作
    基于SpERT的中文关系抽取
    pdf提取其中一页，怎么实现？
    【UniApp】-uni-app-项目计算功能(苹果计算器)
  • 原文地址：https://blog.csdn.net/a2998658795/article/details/126062413