• C++【模板】

    目录

    一、函数模板

    1.函数模板格式 

    2.函数模板的实例化

    隐式实例化

    显式实例化 

    3.模板匹配的规则

    二、类模板

    类模板的定义格式 

    类模板的实例化

    使用类模板的实现一个简单的栈

    声明和定义分离的写法 

     

    如果想要交换两个数字的值的话，对于不同的数据类型进行数值交换，我们需要写大量的相似的但不同类型的函数。

    1. void Swap(int& left, int& right)
    2. {
    3.     int temp = left;
    4.     left = right;
    5.     right = temp;
    6. }
    7. void Swap(double& left, double& right)
    8. {
    9.     double temp = left;
    10.     left = right;
    11.     right = temp;
    12. }
    13. void Swap(char& left, char& right)
    14. {
    15.     char temp = left;
    16.     left = right;
    17.     right = temp;
    18. }

    上面的交换两个数据的代码都非常相似，我们有没有可能写一个模板，只写一个模板就能满足上面不同的要求呢？就好比是活字印刷术，只要模具制作好了，涂上墨，直接印刷就是一份新的文稿。

    如果在C++中，也能够存在这样一个模具，通过给这个模具中填充不同材料(类型)，来获得不同材料的铸件(即生成具体类型的代码），那将会节省许多头发。


    泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础

    一、函数模板

    函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本

    1.函数模板格式 

    template
    返回值类型 函数名(参数列表){}  

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. template<typename T>//模板参数 （模板类型）--类似函数参数（参数对象）
    6. //template//在大多数情况typename和class是相同的
    7. //如果是多个就用逗号分隔
    8. //typename后面的类型名字T是随便取的，Ty、K、V，一般是大写字母或者单词首字母大写
    9. //T代表的是一个模板类型（虚拟类型）
    10. void Swap( T& left, T& right)
    11. {
    12.     T temp = left;
    13.     left = right;
    14.     right = temp;
    15. }
    16. int main()
    17. {
    18.     int a=10;
    19.     int b=20;
    20.     cout<<"a:"<"  b:"<
    21.     Swap(a,b);
    22.     cout<<"a:"<"  b:"<
    23.  
    24.     char c='c';
    25.     char d='d';
    26.     cout<<"c:"<"  d:"<
    27.     Swap(c,d);
    28.     cout<<"c:"<"  d:"<
    29.     return 0;
    30. }

     

    注意：typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替
    class) 

    这根Java中的泛型是相似的。JAVA【泛型】_桜キャンドル淵的博客-CSDN博客 

    函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器 

    在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。 

    咋std的命名空间，直接使用swap就可以调用库里面的swap，

    注意：全部小写 

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. int main()
    6. {
    7.     int a=10;
    8.     int b=20;
    9.     cout<<"a:"<"  b:"<
    10.     swap(a,b);
    11.     cout<<"a:"<"  b:"<
    12.  
    13.     char c='c';
    14.     char d='d';
    15.     cout<<"c:"<"  d:"<
    16.     swap(c,d);
    17.     cout<<"c:"<"  d:"<
    18.     return 0;
    19. }

     

    我们这里的交换不能使用异或来实现，因为异或只适用于整型，对于浮点数等其他的数据的存储结构用异或不适用 

    2.函数模板的实例化

    隐式实例化

    用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。
    1. 隐式实例化：让编译器根据实参推演模板参数的实际类型

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. template<class T>
    6. T Add(const T& left, const T& right)
    7. {
    8.     return left + right;
    9. }
    10. int main()
    11. {
    12.     int a1 = 10, a2 = 20;
    13.     double d1 = 10.0, d2 = 20.0;
    14.     Add(a1, a2);
    15.     Add(d1, d2);
    16. /*
    17. 该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型
    18. 通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有
    19. 一个T，
    20. 编译器无法确定此处到底该将T确定为int 或者 double类型而报错
    21. 注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要
    22. 背黑锅
    23. Add(a1, d1);
    24. */
    25. //推演实例化报错
    26. //    Add(1.1,2);
    27. // 此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化
    28. //隐式实例化，编译器自动推演
    29.     cout<<Add(a1, (int)d1)<
    30.     cout <<Add(212.2,323.3)<
    31.     //显式实例化
    32.     cout<<Add<int>(1.1,2)<
    33.     cout<<Add<double>(1.1,2)<
    34.     return 0;
    35. }

     

    当然我们也可以使用两个泛型进行推演。

    在下面的代码中我们推演的结果是按照T1来的，所以返回的是整数。

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. template<class T1, class T2>
    6. T1 Add(const T1& left, const T2& right)
    7. {
    8.     return left + right;
    9. }
    10. int main()
    11. {
    12.     int a1 = 10;
    13.     double d1 = 10.1221;
    14.     cout<<Add(a1, d1)<
    15.     return 0;
    16. }

     

    显式实例化 

    2. 显式实例化：在函数名后的<>中指定模板参数的实际类型 

     在有些情况下我们必须使用显式实例化来构建我们的函数

    在我们下面的代码中，如果我们在调用的时候并没有在Func<>的钻石限定符中写上double，编译器就不会知道我们想开辟的十个元素的数组中每一个元素的类型是double。只有明确显式指定了其中的元素的类型，才能够编译通过。 

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. template<class T>
    6. T* Func(int n)
    7. {
    8.     T* a=new T[n];
    9.     return a;
    10. }
    11. int main()
    12. {
    13.     //必须显式实例化才能调用
    14. //    Func(10);
    15.    auto a= Func<double>(10);
    16.    a[9]=1.2323;
    17.    cout<9]<
    18.     return 0;
    19. }

     

    3.模板匹配的规则

    1. 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数 

      如果有现成的函数和泛型的功能相同的话，优先使用现成的。

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. template<class T>
    6. T Add(const T& left,const T& right)
    7. {
    8.     return left + right;
    9. }
    10. int Add(int left,int right)
    11. {
    12.     return left + right;
    13. }
    14. int main()
    15. {
    16.     int a1 = 10, a2 = 20;
    17.     double d1 = 10.1221, d2 = 20.0;
    18.     cout<<Add(a1, a2)<
    19.     return 0;
    20. }

    上面的代码中我们的模板add和现成的int版add在实现两个整数相加的时候功能是一样的，但是编译器会优先使用现成的。

    在我们下面clion的截图中模板的add是暗色的，就是没有被调用 

     

     2. 对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板

    1. #include
    2. #include
    3. using namespace std;
    4. // 专门处理int的加法函数
    5. int Add(int left, int right)
    6. {
    7.     return left + right;
    8. }
    9. // 通用加法函数
    10. template<class T1, class T2>
    11. T1 Add(T1 left, T2 right)
    12. {
    13.     return left + right;
    14. }
    15. void Test()
    16. {
    17.     Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化
    18.     Add(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
    19. }

    3. 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换 

    二、类模板

    如果我们下面的st1中存储char类型，st2中存储int类型，没有类模板的话是要写两份的，没办法一步到位。

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. typedef int STDataType;
    6.  
    7. class Stack
    8. {
    9. private:
    10.     STDataType * _a;
    11.     int top;
    12.     int capacity;
    13. };
    14.  
    15. int main()
    16. {
    17.     Stack st1;//char
    18.     Stack st2;//int
    19.     return 0;
    20. }

    就像下面的栈需要写两份，其代码非常繁琐。

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. typedef int STDataType;
    6.  
    7. class Stackc
    8. {
    9. private:
    10.     char * _a;
    11.     int top;
    12.     int capacity;
    13. };
    14.  
    15. class Stacki
    16. {
    17. private:
    18.     int * _a;
    19.     int top;
    20.     int capacity;
    21. };
    22.  
    23. int main()
    24. {
    25.     Stackc st1;//char
    26.     Stacki st2;//int
    27.     return 0;
    28. }

     类模板的使用就会极大地方便我们的使用

    1. #include
    2. #include
    3. using namespace std;
    4.  
    5. template<typename T>
    6. class Stack
    7. {
    8. public:
    9.     //这里我们的capacity最好使用一个默认参数，否则如果没有输入的话，
    10.     //很可能为一个的随机数
    11.     Stack(size_t capacity=4)
    12.     :_a(nullptr)
    13.     ,_capacity(0)
    14.     ,_top(0)
    15.     {
    16.         if(capacity>0)
    17.         {
    18.             _a=new T[capacity];
    19.             _capacity=capacity;
    20.             _top=0;
    21.         }
    22.     }
    23. private:
    24.     T* _a;
    25.     size_t _top;
    26.     size_t _capacity;
    27. };
    28.  
    29. int main()
    30. {
    31.     //类模板都是显式实例化
    32.     //虽然它们都用了一个类模板，但是stack,stack并不是一个类型
    33.     Stack<char> st1(10);//char
    34.     //如果我知道我要开多大的空间来存数据，就可以一次性开完，减少扩容消耗
    35.     Stack<int> st2(20);//int
    36.     return 0;
    37. }

    类模板的定义格式 

    1. template<class T1, class T2, ..., class Tn>
    2. class 类模板名
    3. {
    4. // 类内成员定义
    5. };

    类模板的实例化

    类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

    1. // Vector类名，Vector才是类型
    2. Vector<int> s1;
    3. Vector<double> s2;

    使用类模板的实现一个简单的栈

    1. #include
    2. #include
    3. #include
    4. using namespace std;
    5.  
    6. template<typename T>
    7. class Stack
    8. {
    9. public:
    10.     Stack(size_t capacity=0)
    11.     :_a(nullptr)
    12.     ,_capacity(0)
    13.     ,_top(0)
    14.     {
    15.         if(capacity>0)
    16.         {
    17.             _a=new T[capacity];
    18.             _capacity=capacity;
    19.             _top=0;
    20.         }
    21.     }
    22.     ~Stack()
    23.     {
    24.         delete[] _a;
    25.         _a = nullptr;
    26.         _capacity=_top=0;
    27.     }
    28.     void Pop()
    29.     {
    30.         assert(_top>0);
    31.         --_top;
    32.     }
    33.     bool Empty()
    34.     {
    35.         return _top==0;
    36.     }
    37.     //如果是传值返回的话会生成一个拷贝
    38.     //出了作用域这个对象还是在的，应为这个对面在堆中，不会被系统自动释放，是需要我们手动释放的。
    39.     //所以我们可以采用引用的方式，这样就不用拷贝了
    40.     const T& Top()
    41.     {
    42.         assert(_top>0);
    43.         return _a[_top-1];
    44.     }
    45.     void Push(const T&x)
    46.     {
    47.         if(_top==_capacity)
    48.         {
    49.             size_t newCpacity=_capacity==0 ? 4:_capacity*2;
    50.             //1.使用new开辟旧空间
    51.             T*tmp=new T[newCpacity];
    52.             //2.如果第一次是空的话就不用拷贝，如果不是空的话，就自己动手拷贝
    53.             if(_a)
    54.             {
    55.                 //拷贝数据
    56.                 memcpy(tmp,_a,sizeof (T)*_top);
    57.                 //3.释放旧空间
    58.                 delete[] _a;
    59.             }
    60.             _a=tmp;
    61.             _capacity=newCpacity;
    62.         }
    63.         _a[_top]=x;
    64.         ++_top;
    65.     }
    66. private:
    67.     T* _a;
    68.     size_t _top;
    69.     size_t _capacity;
    70. };
    71.  
    72. int main()
    73. {
    74.     try {
    75.         //类模板都是显式实例化
    76.         //虽然它们都用了一个类模板，但是stack,stack并不是一个类型
    77. //        Stack st1(10);//char
    78. //        Stack st2(20);//int
    79.         Stack<int> st1;
    80.         st1.Push(1);
    81.         st1.Push(2);
    82.         st1.Push(3);
    83.         st1.Push(4);
    84.         st1.Push(5);
    85.  
    86. //        st1.Top()++;
    87. //        st1.Top() *=2;
    88.  
    89.         while(!st1.Empty())
    90.         {
    91.             cout<Top()<<" ";
    92.             st1.Pop();
    93.         }
    94.         cout<
    95.     }
    96.     catch (const exception& e)
    97.     {
    98.         cout<what()<
    99.     }
    100.     return 0;
    101. }

     

    注意：

    1.模板不支持分离编译(声明放在.h 定义放在.cpp中)，会出现链接错误。

    2.但在同一个文件中是可以声明和定义分离的。在下面的写法就是声明和定义分离的写法（下面代码中的push）

    声明和定义分离的写法 

    1. #include
    2. #include
    3. #include
    4. using namespace std;
    5.  
    6. template<typename T>
    7. class Stack
    8. {
    9. public:
    10.     Stack(size_t capacity=0)
    11.     :_a(nullptr)
    12.     ,_capacity(0)
    13.     ,_top(0)
    14.     {
    15.         if(capacity>0)
    16.         {
    17.             _a=new T[capacity];
    18.             _capacity=capacity;
    19.             _top=0;
    20.         }
    21.     }
    22.     ~Stack()
    23.     {
    24.         delete[] _a;
    25.         _a = nullptr;
    26.         _capacity=_top=0;
    27.     }
    28.     //出栈操作
    29.     void Pop()
    30.     {
    31.         assert(_top>0);
    32.         --_top;
    33.     }
    34.     //判空操作
    35.     bool Empty()
    36.     {
    37.         return _top==0;
    38.     }
    39.     //如果是传值返回的话会生成一个拷贝
    40.     //出了作用域这个对象还是在的，应为这个对面在堆中，不会被系统自动释放，是需要我们手动释放的。
    41.     //所以我们可以采用引用的方式，这样就不用拷贝了
    42.     const T& Top()
    43.     {
    44.         assert(_top>0);
    45.         return _a[_top-1];
    46.     }
    47.     void Push(const T&x);
    48. private:
    49.     T* _a;
    50.     size_t _top;
    51.     size_t _capacity;
    52. };
    53.  
    54.  
    55. //如果是要采用声明和定义分离的话就要采取下面的写法
    56. //先声明一个模板T
    57. template<class T>
    58. //然后指明这个T就是Stack类中的T。
    59. void Stack::Push(const T&x)
    60. {
    61.     if(_top==_capacity)
    62.     {
    63.         size_t newCpacity=_capacity==0 ? 4:_capacity*2;
    64.         //1.使用new开辟旧空间
    65.         T*tmp=new T[newCpacity];
    66.         //2.如果第一次是空的话就不用拷贝，如果不是空的话，就自己动手拷贝
    67.         if(_a)
    68.         {
    69.             //拷贝数据
    70.             memcpy(tmp,_a,sizeof (T)*_top);
    71.             //3.释放旧空间
    72.             delete[] _a;
    73.         }
    74.         _a=tmp;
    75.         _capacity=newCpacity;
    76.     }
    77.     _a[_top]=x;
    78.     ++_top;
    79. }
    80. int main()
    81. {
    82.     try {
    83.         //类模板都是显式实例化
    84.         //虽然它们都用了一个类模板，但是stack,stack并不是一个类型
    85.         Stack<int> st1;
    86.         st1.Push(1);
    87.         st1.Push(2);
    88.         st1.Push(3);
    89.         st1.Push(4);
    90.         st1.Push(5);
    91.         //如果是为了方式在外面修改栈中的数据的话，可以给前面栈的返回栈顶元素的函数前面加上const
    92.         //来防止被修改
    93. //        st1.Top()++;
    94. //        st1.Top() *=2;
    95.  
    96.         while(!st1.Empty())
    97.         {
    98.             cout<Top()<<" ";
    99.             st1.Pop();
    100.         }
    101.         cout<
    102.     }
    103.     catch (const exception& e)
    104.     {
    105.         cout<what()<
    106.     }
    107.     return 0;
    108. }

     

     模板的可以放在.hpp或者.h里面，然后取调用这个文件。

     即使是全缺省的模板函数，其调用的时候也要加上钻石限定符

    template<typename T=char>

    需要这样调用

    Stack<> st2;
  • 相关阅读:
    tomcat修改默认端口详细步骤（包含运行测试）
    【网络编程】网络层——IP协议
    嵌入式：驱动开发 Day2
    mysql
    labview信号时域分析编程笔记
    【HTTP协议】HTTP协议初体验，深入浅出网络协议
    征服BAT精选《Spring 源码分析》核心，欢迎围观
    【JavaWeb】一文搞懂Java过滤器与拦截器的区别
    vue里的变量定义说明
    Java网络编程——粘包拆包出现的原因及解决方式
  • 原文地址：https://blog.csdn.net/weixin_62684026/article/details/126227734