泛型编程的第一步，掌握模板的特性！
- 2020 年 3 月 31 日
- 筆記
— 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 函数模板的重载
函数模板可以重载，只要它们的形参表或类型参数表不同即可。
见下面的例子：
// 模板函数 1 template<class T1, class T2> void print(T1 arg1, T2 arg2) { cout<< arg1 << " "<< arg2<<endl; } // 模板函数 2 template<class T> void print(T arg1, T arg2) { cout<< arg1 << " "<< arg2<<endl; } // 模板函数 3 template<class T,class T2> void print(T arg1, T arg2) { cout<< arg1 << " "<< arg2<<endl; }
上面都是 print(参数1, 参数2) 模板函数的重载，因为「形参表」或「类型参数表」名字不同。
— —
|| 05 函数模板和函数的次序
在有多个函数和函数模板名字相同的情况下，编译器如下规则处理一条函数调用语句：
- 先找参数完全匹配的普通函数（非由模板实例化而得的函数）；
- 再找参数完全匹配的模板函数；
- 再找实参数经过自动类型转换后能够匹配的普通函数；
- 上面的都找不到，则报错。
代码例子如下：
// 模板函数 - 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; }
输出：
1 1
上面的代码需要注意的点：
- 类模板里的静态成员初始化的时候，最前面要加
template<>。 - ia 和 da 对象是不同的模板类，因为类型参数是不一致，所以也就是不同的模板类。
