当前位置：首页 > 公众号精选 > 后端技术指南针

泛型编程的第一步，掌握模板的特性！

时间：2020-07-07 14:34:46
关键字： 模板   
手机看文章

扫描二维码
随时随地手机看文章

[导读]— 1 — 认识 C++ 是很强大，有各种特性来提高代码的可重用性，有助于减少开发的代码量和工作量。 C++ 提高代码的可重用性主要有两方面： 继承 模板 继承的特性我已在前面篇章写过了「C++ 一篇搞懂继承的常见特性」。 本篇主要是说明「模板」的特性，使用「模


— 1 —

认识


C++ 是很强大，有各种特性来提高代码的可重用性，有助于减少开发的代码量和工作量。


C++ 提高代码的可重用性主要有两方面：


继承的特性我已在前面篇章写过了「C++ 一篇搞懂继承的常见特性」。


本篇主要是说明「模板」的特性，使用「模板」的特性设计，实际上也就是「泛型」程序设计。




— 2 —

函数模板

||  01 变量交换函数模板

假设我们设计一个交换两个整型变量的值的函数，代码如下：

// 交换两个整型变量的值的Swap函数：void Swap(int & x,int & y){ int tmp = x; x = y; y = tmp;}

如果是浮点类型的变量的值交换，则需要把替换 int 类型为 double 即可，代码如下：

// 交换两个double型变量的值的Swap函数:void Swap(double & x,double & y){ double tmp = x; x = y; y = tmp;}

那如果是其他变量类型的值交换，那不是每次都要重新写一次 Swap 函数？是不是很繁琐？且代码后面会越来越冗余。


能否只写一个 Swap 函数，就能交换各种类型的变量？


答案是肯定有的，就是用「函数模板」来解决，「函数模板」的形式：

template <class 类型参数1，class 类型参数2，...>返回值类型 模板名 (形参表){ 函数体};


具体 Swap 「函数模板」代码如下：

template <class T>void Swap(T & x,T & y){ T tmp = x; x = y; y = tmp;}

template 就是模板定义的关键词，T 代表的是任意变量的类型。


那么定义好「函数模板」后，在编译的时候，编译器会根据传入 Swap 函数的参数变量类型，自动生成对应参数变量类型的 Swap 函数：

int main(){ int n = 1,m = 2; Swap(n,m); //编译器自动生成 void Swap(int & ,int & )函数  double f = 1.2,g = 2.3; Swap(f,g); //编译器自动生成 void Swap(double & ,double & )函数  return 0;}

  • 第 4 行编译器自动生成 void Swap(int &, int & ) 函数；

  • 第 7 行编译器自动生成 void Swap(double &, double & ) 函数。


上面的实例化函数模板的例子，是让编译器自己来判断传入的变量类型，那么我们也可以自己指定函数模板的变量类型，具体代码如下：

int main(){ int n = 1,m = 2; Swap<int>(n,m); // 指定模板函数的变量类型为int  double f = 1.2,g = 2.3; Swap<double>(f,g); // 指定模板函数的变量类型为double  return 0;}

  • 第 4 行指定模板函数的变量类型为 int ；

  • 第 7 行指定模板函数的变量类型为 double 。


— —

||  02 查询数组最大值函数模板

在举一个例子，下面的 MaxElement 函数定义成了函数模板，这样不管是 int、double、char 等类型的数组，都可以使用该函数来查数组最大的值，代码如下：

// 求数组最大元素的MaxElement函数模板template <class T>T MaxElement(T a[], int size) // size是数组元素个数{ T tmpMax = a[0]; for(int i = 1;i < size;++i) { if(tmpMax < a[i]) { tmpMax = a[i]; } } return tmpMax;}

— —

||  03 多个类型参数模板函数

函数模板中，可以不止一个类型的参数：

template <class T1, class T2>T2 MyFun(T1 arg1, T2 arg2){ cout<< arg1 << " "<< arg2<<endl; return arg2;}

T1 是传入的第一种任意变量类型，T2 是传入的第二种任意变量类型。


— —

||  04 函数模板的重载

函数模板可以重载，只要它们的形参表或类型参数表不同即可。

见下面的例子：

// 模板函数 1template<class T1, class T2>void print(T1 arg1, T2 arg2){ cout<< arg1 << " "<< arg2<<endl;}
// 模板函数 2template<class T>void print(T arg1, T arg2){ cout<< arg1 << " "<< arg2<<endl;}
// 模板函数 3template<class T,class T2>void print(T arg1, T arg2){ cout<< arg1 << " "<< arg2<<endl;}

上面都是 print(参数1, 参数2) 模板函数的重载，因为「形参表」或「类型参数表」名字不同。

— —

||  05 函数模板和函数的次序

在有多个函数和函数模板名字相同的情况下，编译器如下规则处理一条函数调用语句：

  1. 先找参数完全匹配的普通函数（非由模板实例化而得的函数）；
  2. 再找参数完全匹配的模板函数；
  3. 再找实参数经过自动类型转换后能够匹配的普通函数；
  4. 上面的都找不到，则报错。

代码例子如下：

// 模板函数 - 1个参数类型template <class T>T Max(T a, T b){ cout << "TemplateMax" <<endl; return 0;}
// 模板函数 - 2个参数类型template <class T, class T2>T Max(T a, T2 b){ cout << "TemplateMax2" <<endl; return 0;}
// 普通函数double Max(double a, double b){ cout << "MyMax" << endl; return 0;}
int main(){ int i=4, j=5;  // 输出MyMax - 匹配普通函数 Max( 1.2, 3.4 );  //输出TemplateMax - 匹配参数一样的模板函 Max( i, j );  //输出TemplateMax2 - 匹配参数类型不同的模板函数 Max( 1.2, 3 );  return 0;}

  • 第 27 行，输出的是MyMax，因为匹配的是普通函数；

  • 第 30 行，输出的是输出TemplateMax，因为匹配参数一样的模板函；

  • 第 33 行，输出的是TemplateMax2，因为匹配参数类型不同的模板函数。


匹配模板函数时，当模板函数只有一个参数类型时，传入了不同的参数类型，是不进行类型自动转换，具体例子如下：

// 模板函数 - 1个参数类型template<class T>T myFunction( T arg1, T arg2){ cout<<arg1<<" "<<arg2<<"\n"; return arg1;}
...
// OK ：替换 T 为 int 类型myFunction( 5, 7);
// OK ：替换 T 为 double 类型myFunction(5.8, 8.4);
// error ：没有匹配到myFunction(int, double)函数myFunction(5, 8.4);

  • 第 12 行，可以正常执行，替换 T 为 int 类型；

  • 第 15 行，可以正常执行，替换 T 为 double 类型 ；

  • 第 18 行，会执行错误！因为没有匹配到 myFunction(int, double)函数。



— 3 —

类模板


||  01 类模板的定义

为了多快好省地定义出一批相似的类，可以定义「类模板」，然后由类模板生成不同的类。


类模板的定义形式如下：

template <class 类型参数1，class 类型参数2，...> //类型参数表class 类模板名{ 成员函数和成员变量};


用类模板定义对象的写法：

   

    
    
     
  • 
    

    
类模板名<真实类型参数表> 对象名(构造函数实参表);

   


   

    
— —

||  02 Pair类模板例子

接下来，用 Pair 类用类模板的方式的实现，Pair 是一对的意思，也就是实现一个键值对（key-value）的关系的类。


代码如下：

// 类模板template <class T1, class T2>class Pair{public: Pair(T1 k, T2 v):m_key(k),m_value(v) {}; bool operator < (const Pair<T1,T2> & p) const;private: T1 m_key; T2 m_value;};
// 类模板里成员函数的写法template <class T1, class T2>bool Pair<T1,T2>::operator < (const Pair<T1,T2> &p) const{ return m_value < p.m_value;}
int main(){ Pair<string,int> Astudent("Jay",20); Pair<string,int> Bstudent("Tom",21);  cout << (Astudent < Bstudent) << endl;  return 0;}

输出结果：

1


需要注意的是，同一个类模板的两个模板类是不兼容的：

Pair<string,int> *p;Pair<string,double> a;p = & a; //错误！！


— —

||  03 函数模板作为类模板成员

当函数模板作为类模板的成员函数时，是可以单独写成函数模板的形式，成员函数模板在使用的时候，编译器才会把函数模板根据传入的函数参数进行实例化，例子如下：

// 类模板template <class T>class A{public: template<class T2> void Func(T2 t) { cout << t; } // 成员函数模板};
int main(){ A<int> a; a.Func('K'); //成员函数模板 Func被实例化 a.Func("hello"); //成员函数模板 Func再次被实例化
 return 0;}


— —

||  04 类模板与非类型参数

类模板的“<类型参数表>”中可以出现非类型参数：

template <class T, int size>class CArray{public: void Print( ){ for( int i = 0;i < size; ++i) cout << array[i] << endl; }private: T array[size];};
CArray<double,40> a2;CArray<int,50> a3; //a2和a3属于不同的类




— 4 —

类模板和派生


||  01 类模板从类模板派生



上图的代码例子如下：

// 基类 - 类模板template <class T1,class T2>class A { T1 v1; T2 v2;};
// 派生类 - 类模板template <class T1,class T2>class B:public A<T2,T1>{ T1 v3; T2 v4;};
// 派生类 - 类模板template <class T>class C:public B<T,T>{ T v5;};
int main(){ B<int,double> obj1; C<int> obj2;    return 0;}


— —

||  02 类模板从模板类派生



上图的代码例子如下：

template <class T1,class T2>class A { T1 v1; T2 v2;};
template <class T>class B:public A<int,double> // A<int,double> 模板类{ T v;};
int main(){ //自动生成两个模板类 ：A<int,double> 和 B<char> B<char> obj1; return 0;}

  • 第 16 行，在创建 B类 对象，会自动生成两个模板类 ：A<int,double> 和 B<char> 。


— —

||  03 类模板从普通类派生



上图的代码例子如下：

// 基类 - 普通类class A{ int v1;};
// 派生类 - 类模板template <class T>class B:public A // 所有从B实例化得到的类 ，都以A为基类{ T v;};
int main(){ B<char> obj1; return 0;}

  • 第 16 行，在创建 B 类对象前，会先构造基类 A 对象。


— —

||  04 普通类从模板类派生



上图的代码例子如下：

template <class T>class A{ T v1;};
class B : public A<int>{ double v;};
int main(){ B obj1; return 0;}

  • 第 14 行，在构造 B 类对象前，会先实例化 A 模板对象。




— 5 —

类模板与友元


||  01 函数、类、类的成员函数作为类模板的友元

代码例子如下：

// 普通函数void Func1() { }
// 普通类class A { };
// 普通类class B{ public: void Func() { } // 成员函数};
// 类模板template <class T>class Tmp{ friend void Func1(); // 友元函数 friend class A; // 友元类 friend void B::Func(); // 友元类的成员函数}; // 任何从 Tmp 实例化来的类 ，都有以上三个友元

任何从 Tmp 实例化来的类 ，都有以上三个友元。


— —

||  02 函数模板作为类模板的友元

// 类模板template <class T1,class T2>class Pair{private: T1 key; //关键字 T2 value; //值public: Pair(T1 k,T2 v):key(k),value(v) { };  // 友元函数模板 template <class T3,class T4> friend ostream & operator<< (ostream & o, const Pair<T3,T4> & p);};
// 函数模板template <class T3,class T4>ostream & operator<< (ostream & o, const Pair<T3,T4> & p){ o << "(" << p.key << "," << p.value << ")" ; return o;}
int main(){ Pair<string,int> student("Tom",29); Pair<int,double> obj(12,3.14);  cout << student << " " << obj; return 0;}


输出结果：

(Tom,29) (12,3.14)

— —

||  03 函数模板作为类的友元

// 普通类class A{private: int v;public: A(int n):v(n) { }  template <class T> friend void Print(const T & p); // 函数模板};
// 函数模板template <class T>void Print(const T & p){ cout << p.v;}
int main(){ A a(4); Print(a); return 0;}


输出结果：

4


— —

||  04 类模板作为类模板的友元

// 类模板template <class T>class B {private: T v;public: B(T n):v(n) { }  template <class T2> friend class A; // 友元类模板};
// 类模板template <class T>class A {public: void Func( ){ B<int> o(10); // 实例化B模板类 cout << o.v << endl; }};
int main(){ A<double> a; a.Func (); return 0;}


输出结果：

10




— 6 —

类模板与静态成员函数



类模板中可以定义静态成员，那么从该类模板实例化得到的所有类，都包含同样的静态成员。


见下面的例子：

template <class T>class A{private: static int count; // 静态成员public: A() { count ++; } ~A() { count -- ; }; A( A & ) { count ++ ; }  static void PrintCount() // 静态函数{  cout << count << endl;     } };
template<> int A<int>::count = 0; // 初始化template<> int A<double>::count = 0; // 初始化
int main(){ A<int> ia; A<double> da; // da和ia不是相同模板类 ia.PrintCount(); da.PrintCount(); return 0;}

输出：

11


上面的代码需要注意的点：

  • 类模板里的静态成员初始化的时候，最前面要加 template<> 。
  • ia 和 da 对象是不同的模板类，因为类型参数是不一致，所以也就是不同的模板类。



推荐阅读：
C++ 一篇搞懂继承的常见特性
掌握了多态的特性，写英雄联盟的代码更少啦！


  小林coding  




免责声明：本文内容由21ic获得授权后发布，版权归原作者所有，本平台仅提供信息存储服务。文章仅代表作者个人观点，不代表本平台立场，如有问题，请联系我们，谢谢！

本站声明： 本文章由作者或相关机构授权发布，目的在于传递更多信息，并不代表本站赞同其观点，本站亦不保证或承诺内容真实性等。需要转载请联系该专栏作者，如若文章内容侵犯您的权益，请及时联系本站删除。
换一批
延伸阅读
[产业新闻]

大学生"定标准"，企业觅英才 首届"ISO国际标准化青年之星大赛"开赛

北京2023年9月12日 /美通社/ -- 新能源汽车的动力电池，需要哪些标准？车载无线通信，哪些参数需要统一？建筑咨询应怎么作？9月1日至10月22日，首届"ISO国际标准化青年之星大赛"活动启动，邀请18岁至35岁高...

关键字： ISO 大赛 模板 宁德时代
[产业新闻]

视觉科技创造极致体验 创客贴以用户体验定义产品标准

北京2023年8月15日 /美通社/ -- 8月11日，以"推动基于用户体验的产品质量变革"为主题的第十一届中国用户体验大会在南京开幕。以科技为引领的数字化转型浪潮不断涌现，企业竞争愈发激烈，用户体验...

关键字： 创客 AI 模板 模块化
[美通社全球TMT]

InEight宣布新的软件创新

（全球TMT2022年9月22日讯）建筑项目管理软件领域企业InEight Inc.宣布了最新的软件创新，包括范围、设计和资源管理方面的新流程标准化，以及新的进展跟踪功能和创建基准验证型进程预估和时间表的能力。该更新还...

关键字： 软件 进程 应用程序 模板
[美通社全球TMT]

创客贴推出免费公益版会员

（全球TMT2022年7月28日讯）创客贴正式推出公益版会员项目，皆在通过创意内容智能解决方案，提升公益组织的内容生产能力，降低公益组织设计成本。目前，已签约使用的公益组织达500余家，好公益平台、南都公益基金会、北京...

关键字： 创客 模板 美的 数字资产
[产业新闻]

让创意变"创益"，创客贴推出免费公益版会员

北京2022年7月28日 /美通社/ -- 在数字化经济、新媒体时代背景下，创意视觉设计对公益组织的重要性愈发凸显。一张精美的视觉海报，可以迅速吸引大众眼球并唤起心中的感知，易于将公益信息加速传播。 因此想要提升公益事...

关键字： 创客 大众 模板 美的
[产业新闻]

一千多家公司毕业Mixpanel免费创业计划

Mixpanel将创业计划提供给更多公司，推出免费公司KPI仪表板模板，帮助初创公司衡量重要指标  旧金山2022年7月20日 /美通社/ -- Mix...

关键字： PANEL MIX 仪表 模板
[产业新闻]

玩美移动淘宝模板小程序正式上线

助力品牌快速布局AR虚拟试妆及AI肌肤检测服务 为更多品牌及消费者打造个性化、专属化的淘宝电商购物之旅 上海2022年6月13日 /美通社/ -- 一年一度的淘宝618正如火如荼的进行中。对于部分品牌来说...

关键字： 模板 移动 小程序 AI技术
[产业新闻]

鼎信诺全新升级审计系统7000系列

北京2022年6月2日 /美通社/ -- 为了适应会计师行业发展新变化，满足新政策的调整，鼎信诺于2022年5月全新推出了审计系统7000系列，在简洁界面的设计原则下，优化功能布局，增加智能高效的效率工具，提升...

关键字： 模板 数据采集 软件 智能化
[美通社全球TMT]

鼎信诺全新推出审计系统7000系列

（全球TMT2022年6月2日讯）为了适应会计师行业发展新变化，满足新政策的调整，鼎信诺于2022年5月全新推出了审计系统7000系列，在简洁界面的设计原则下，优化功能布局，增加智能高效的效率工具，提升用户易用性，进一...

关键字： 模板 数据采集 智能化 软件
[strongerHuang]

做项目，从零开始，还是套用模板？

关注星标公众号，不错过精彩内容作者|strongerHuang微信公众号 | 嵌入式专栏有一种情况：老板从来不催进度，做项目的工程师也不慌不忙，从零开始一步一步创建工程，然后一步一步写代码。当把项目做好，或者项目才做到一...

关键字： 模板
关闭
关闭