title: C++(八)泛型编程之模板date: 2021-04-21 22:49:54.975 updated: 2021-04-23 17:41:02.664 url: /?p=99 categories: C++ tags: C++
泛型编程与模板 所谓泛型,其实是参数化类型。我们知道函数是对一段代码段的封装,从而减少重复代码的编写。而泛型也是与函数又相同的思想。
在编写函数或者类的时候,往往相同逻辑的一段代码,却因为类型不同导致又要写好几个函数或者类来实现。后来聪明的程序员们,直接把类型作为一个参数,像函数一样传参,就又能偷懒了,这一实现就是泛型(参数化类型)。
模板是 C++ 中对泛型编程的实现。模板最成功的应用就是 C++ 的标准模板库(STL)。也可以说,泛型编程就是大量编写模板、使用模板的程序设计。模板的意思其实也非常直观了,我们经常说“这两个人简直就是一个模板整出来的”,放在C++ 中其实是一个意思。
泛型编程在 C++ 中的重要性和带来的好处不亚于面向对象的特性。
在 C++ 中,模板分为函数模板和类模板两种。熟练的 C++ 程序员,在编写函数时都会考虑能否将其写成函数模板,编写类时都会考虑能否将其写成类模板,以便实现重用。
值(Value)和类型(Type)是数据的两个主要特征,它们在C++中都可以被参数化。
函数模板入门 示例 我们通过函数重载定义了四个名字相同、参数列表不同的函数,如下所示:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 void Swap (int *a, int *b) { int temp = *a; *a = *b; *b = temp; } void Swap (float *a, float *b) { float temp = *a; *a = *b; *b = temp; } void Swap (char *a, char *b) { char temp = *a; *a = *b; *b = temp; } void Swap (bool *a, bool *b) { char temp = *a; *a = *b; *b = temp; }
重复性代码太多,我们使用函数模板(Function Template) 来压缩这段代码量。如下:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 #include <iostream> using namespace std ; template<typename T> void Swap (T *a, T *b) { T temp = *a; *a = *b; *b = temp; } int main () { int n1 = 100 , n2 = 200 ; Swap(&n1, &n2); cout <<n1<<", " <<n2<<endl ; float f1 = 12.5 , f2 = 56.93 ; Swap(&f1, &f2); cout <<f1<<", " <<f2<<endl ; char c1 = 'A' , c2 = 'B' ; Swap(&c1, &c2); cout <<c1<<", " <<c2<<endl ; bool b1 = false , b2 = true ; Swap(&b1, &b2); cout <<b1<<", " <<b2<<endl ; return 0 ; }
运行结果:
200, 100
56.93, 12.5
B, A
1, 0
我们直接关注第四行代码,template<typename T>
被称为模板头 。
template
是定义函数模板的关键字,它后面紧跟尖括号<>
,尖括号包围的是类型参数(也可以说是虚拟的类型,或者说是类型占位符)。typename
是另外一个关键字,用来声明具体的类型参数,这里的类型参数就是T
。
我们使用引用来作为模板函数的形参,如下:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 #include <iostream> using namespace std ; template<typename T> void Swap (T &a, T &b) { T temp = a; a = b; b = temp; } int main () { int n1 = 100 , n2 = 200 ; Swap(n1, n2); cout <<n1<<", " <<n2<<endl ; float f1 = 12.5 , f2 = 56.93 ; Swap(f1, f2); cout <<f1<<", " <<f2<<endl ; char c1 = 'A' , c2 = 'B' ; Swap(c1, c2); cout <<c1<<", " <<c2<<endl ; bool b1 = false , b2 = true ; Swap(b1, b2); cout <<b1<<", " <<b2<<endl ; return 0 ; }
引用不但使得函数定义简洁明了,也使得调用函数方便了很多。整体来看,引用让编码更加漂亮。
总结 下面我们来总结一下定义模板函数的语法:
1 2 3 template <typename 类型参数1 , typename 类型参数2 , ...> 返回值类型 函数名(形参列表){ //在函数体中可以使用类型参数 }
类型参数可以有多个,它们之间以逗号,分隔。类型参数列表以< >包围,形式参数列表以( )包围。
typename
关键字也可以使用class
关键字替代 ,它们没有任何区别。C++ 早期对模板的支持并不严谨,没有引入新的关键字,而是用 class 来指明类型参数,但是 class 关键字本来已经用在类的定义中了,这样做显得不太友好,所以后来 C++ 又引入了一个新的关键字 typename,专门用来定义类型参数。不过至今仍然有很多代码在使用 class 关键字,包括 C++ 标准库、一些开源程序等。
函数模板也可以提前声明,不过声明时需要带上模板头,并且模板头和函数定义(声明)是一个不可分割的整体,它们可以换行,但中间不能有分号。
类模板入门 声明类模板的语法为:
1 2 3 template<typename 类型参数1 , typename 类型参数2 , …> class 类名{ };
类模板和函数模板都是以 template 开头(当然也可以使用 class,目前来讲它们没有任何区别),后跟类型参数;类型参数不能为空,多个类型参数用逗号隔开。
一但声明了类模板,就可以将类型参数用于类的成员函数和成员变量了。换句话说,原来使用 int、float、char 等内置类型的地方,都可以用类型参数来代替。
假如我们现在要定义一个类来表示坐标,要求坐标的数据类型可以是整数、小数和字符串,例如:
x = 10、y = 10
x = 12.88、y = 129.65
x = “东经180度”、y = “北纬210度”
这个时候就可以使用类模板,请看下面的代码:
1 2 3 4 5 6 7 8 9 10 11 12 13 template<typename T1, typename T2> class Point {public: Point(T1 x, T2 y): m_x(x), m_y(y){ } public: T1 getX () const ; void setX (T1 x) ; T2 getY () const ; void setY (T2 y) ; private: T1 m_x; T2 m_y; };
x 坐标和 y 坐标的数据类型不确定,借助类模板可以将数据类型参数化,这样就不必定义多个类了。
注意:模板头和类头是一个整体,可以换行,但是中间不能有分号。
上面的代码仅仅是类的声明,我们还需要在类外定义成员函数。在类外定义成员函数时仍然需要带上模板头,格式为:
1 2 3 4 template<typename 类型参数1 , typename 类型参数2 , …> 返回值类型 类名<类型参数1 , 类型参数2 , ...>::函数名(形参列表){ }
第一行是模板头,第二行是函数头,它们可以合并到一行,不过为了让代码格式更加清晰,一般是将它们分成两行。
下面就对 Point 类的成员函数进行定义:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 template<typename T1, typename T2> T1 Point<T1, T2>::getX() const { return m_x; } template<typename T1, typename T2> void Point<T1, T2>::setX(T1 x){ m_x = x; } template<typename T1, typename T2> T2 Point<T1, T2>::getY() const { return m_y; } template<typename T1, typename T2> void Point<T1, T2>::setY(T2 y){ m_y = y; }
请读者仔细观察代码,除了 template 关键字后面要指明类型参数,类名 Point 后面也要带上类型参数,只是不加 typename 关键字了。另外需要注意的是,在类外定义成员函数时,template 后面的类型参数要和类声明时的一致。
使用类模板创建对象 上面的两段代码完成了类的定义,接下来就可以使用该类创建对象了。使用类模板创建对象时,需要指明具体的数据类型。请看下面的代码:
1 2 3 Point<int , int > p1 (10 , 20 ) ; Point<int , float > p2 (10 , 15.5 ) ; Point<float , char *> p3 (12.4 , "东经180度" ) ;
与函数模板不同的是,类模板在实例化时必须显式地指明数据类型,编译器不能根据给定的数据推演出数据类型。
除了对象变量,我们也可以使用对象指针的方式来实例化:
1 2 Point<float , float > *p1 = new Point<float , float >(10.6 , 109.3 ); Point<char *, char *> *p = new Point<char *, char *>("东经180度" , "北纬210度" );
需要注意的是,赋值号两边都要指明具体的数据类型,且要保持一致。下面的写法是错误的:
1 2 3 4 Point<float , float > *p = new Point<float , int >(10.6 , 109 ); Point<float , float > *p = new Point(10.6 , 109 );
综合示例 用类模板实现可变长数组。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 #include <iostream> #include <cstring> using namespace std ; template <class T > class CArray { int size; T *ptr; public: CArray(int s = 0 ); CArray(CArray & a); ~CArray(); void push_back (const T & v) ; CArray & operator=(const CArray & a); T length () { return size; } T & operator[](int i) { return ptr[i]; } }; template<class T > CArray<T>::CArray(int s):size(s) { if (s == 0 ) ptr = NULL ; else ptr = new T[s]; } template<class T > CArray<T>::CArray(CArray & a) { if (!a.ptr) { ptr = NULL ; size = 0 ; return ; } ptr = new T[a.size]; memcpy (ptr, a.ptr, sizeof (T ) * a.size); size = a.size; } template <class T > CArray<T>::~CArray() { if (ptr) delete [] ptr; } template <class T > CArray<T> & CArray<T>::operator=(const CArray & a) { if (this == & a) return * this; if (a.ptr == NULL ) { if ( ptr ) delete [] ptr; ptr = NULL ; size = 0 ; return * this; } if (size < a.size) { if (ptr) delete [] ptr; ptr = new T[a.size]; } memcpy (ptr,a.ptr,sizeof (T)*a.size); size = a.size; return *this; } template <class T > void CArray<T>::push_back(const T & v){ if (ptr) { T *tmpPtr = new T[size+1 ]; memcpy (tmpPtr,ptr,sizeof (T)*size); delete []ptr; ptr = tmpPtr; } else ptr = new T[1 ]; ptr[size++] = v; } int main () { CArray<int > a; for (int i = 0 ;i < 5 ;++i) a.push_back(i); for (int i = 0 ; i < a.length(); ++i) cout << a[i] << " " ; return 0 ; }
C++函数模板的重载 当需要对不同的类型使用同一种算法(同一个函数体)时,为了避免定义多个功能重复的函数,可以使用模板。然而,并非所有的类型都使用同一种算法,有些特定的类型需要单独处理,为了满足这种需求,C++ 允许对函数模板进行重载,程序员可以像重载常规函数那样重载模板定义。
我们定义了 Swap() 函数用来交换两个变量的值,一种方案是使用指针,另外一种方案是使用引用,请看下面的代码:
1 2 3 4 5 6 7 8 9 10 11 12 template<typename T> void Swap (T *a, T *b) { T temp = *a; *a = *b; *b = temp; } template<class T> void Swap (T &a, T &b) { T temp = a; a = b; b = temp; }
这两种方案都可以交换 int、float、char、bool 等基本类型变量的值,但是却不能交换两个数组。
对于方案①,调用函数时传入的是数组指针,或者说是指向第 0 个元素的指针,这样交换的仅仅是数组的第 0 个元素,而不是整个数组。数组和指针本来是不等价的,只是当函数的形参为指针时,传递的数组也会隐式地转换为指针。
对于方案②,假设传入的是一个长度为 5 的 int 类型数组(该数组的类型是 int [5]
),那么 T 的真实类型为int [5]
,T temp
会被替换为int [5] temp
,这显然是错误的。另外一方面,语句a=b;
尝试对数组 a 赋值,而数组名是常量,它的值不允许被修改,所以也会产生错误。总起来说,方案②会有两处语法错误。
交换两个数组唯一的办法就是逐个交换所有的数组元素,请看下面的代码:
1 2 3 4 5 6 7 8 template<typename T> void Swap (T a[], T b[], int len) { T temp; for (int i=0 ; i<len; i++){ temp = a[i]; a[i] = b[i]; b[i] = temp; } }
在该函数模板中,最后一个参数的类型为具体类型(int),而不是泛型。并不是所有的模板参数都必须被泛型化。
下面是一个重载函数模板的完整示例:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 #include <iostream> using namespace std ; template<class T> void Swap (T &a, T &b) ; template<typename T> void Swap (T a[], T b[], int len) ; void printArray (int arr[], int len) ; int main () { int m = 10 , n = 99 ; Swap(m, n); cout <<m<<", " <<n<<endl ; int a[5 ] = { 1 , 2 , 3 , 4 , 5 }; int b[5 ] = { 10 , 20 , 30 , 40 , 50 }; int len = sizeof (a) / sizeof (int ); Swap(a, b, len); printArray(a, len); printArray(b, len); return 0 ; } template<class T> void Swap (T &a, T &b) { T temp = a; a = b; b = temp; } template<typename T> void Swap (T a[], T b[], int len) { T temp; for (int i=0 ; i<len; i++){ temp = a[i]; a[i] = b[i]; b[i] = temp; } } void printArray (int arr[], int len) { for (int i=0 ; i<len; i++){ if (i == len-1 ){ cout <<arr[i]<<endl ; }else { cout <<arr[i]<<", " ; } } }
运行结果:
99, 10
10, 20, 30, 40, 50
1, 2, 3, 4, 5
函数模板的实参类型推断 在使用类模板创建对象时,程序员需要显式的指明实参(也就是具体的类型)。例如对于下面的 Point 类:
1 template<typename T1, typename T2> class Point ;
我们可以在栈上创建对象,也可以在堆上创建对象:
1 2 Point<int , int > p1 (10 , 20 ) ; Point<char *, char *> *p = new Point<char *, char *>("东京180度" , "北纬210度" );
因为已经显式地指明了 T1、T2 的具体类型,所以编译器就不用再自己推断了,直接拿来使用即可。
而对于函数模板,调用函数时可以不显式地指明实参(也就是具体的类型)。请看下面的例子:
1 2 3 4 5 6 7 template<typename T> void Swap (T &a, T &b) ; int n1 = 100 , n2 = 200 ;Swap(n1, n2); float f1 = 12.5 , f2 = 56.93 ;Swap(f1, f2);
虽然没有显式地指明 T 的具体类型,但是编译器会根据 n1 和 n2、f1 和 f2 的类型自动推断出 T 的类型。这种通过函数实参来确定模板实参(也就是类型参数的具体类型)的过程称为模板实参推断。
在模板实参推断过程中,编译器使用函数调用中的实参类型来寻找类型参数的具体类型。
模板实参推断过程中的类型转换 对于普通函数(非模板函数),发生函数调用时会对实参的类型进行适当的转换,以适应形参的类型。这些转换包括:
算数转换:例如 int 转换为 float,char 转换为 int,double 转换为 int 等。
派生类向基类的转换:也就是向上转型,请猛击《C++向上转型(将派生类赋值给基类)》了解详情。
const 转换:也即将非 const 类型转换为 const 类型,例如将 char _ 转换为 const char _。
数组或函数指针转换:如果函数形参不是引用类型,那么数组名会转换为数组指针,函数名也会转换为函数指针。
用户自定的类型转换。
例如有下面两个函数原型:
1 2 void func1 (int n, float f) ;void func2 (int *arr, const char *str) ;
它们具体的调用形式为:
1 2 3 4 int nums[5 ];char *url = "http://c.biancheng.net" ;func1(12.5 , 45 ); func2(nums, url);
对于 func1(),12.5 会从double转换为int,45 会从int转换为float;对于 func2(),nums 会从int [5]转换为int _,url 会从char _转换为const char *。
而对于函数模板,类型转换则受到了更多的限制,仅能进行「const 转换」和「数组或函数指针转换」,其他的都不能应用于函数模板 。例如有下面几个函数模板:
1 2 3 4 5 template<typename T> void func1 (T a, T b) ; template<typename T> void func2 (T *buffer) ; template<typename T> void func3 (const T &stu) ; template<typename T> void func4 (T a) ; template<typename T> void func5 (T &a) ;
它们具体的调用形式为:
1 2 3 4 5 6 7 int name[20 ];Student stu1 ("张华" , 20 , 96.5 ) ; func1(12.5 , 30 ); func2(name); func3(stu1); func4(name); func5(name);
对于func1(12.5, 30)
,12.5 的类型为 double,30 的类型为 int,编译器不知道该将 T 实例化为 double 还是 int,也不会尝试将 int 转换为 double,或者将 double 转换为 int,所以调用失败。
请读者注意 name,它本来的类型是int [20]
:
对于func2(name)
和func4(name)
,name 的类型会从 int [20] 转换为 int _,也即将数组转换为指针,所以 T 的类型分别为 int _ 和 int。
对于func5(name)
,name 的类型依然为 int [20],不会转换为 int *,所以 T 的类型为 int [20]。
可以发现,当函数形参是引用类型时,数组不会转换为指针。这个时候读者要注意下面这样的函数模板:
1 template<typename T> void func (T &a, T &b) ;
如果它的具体调用形式为:
1 2 3 int str1[20 ];int str2[10 ];func(str1, str2);
由于 str1、str2 的类型分别为 int [20] 和 int [10],在函数调用过程中又不会转换为指针,所以编译器不知道应该将 T 实例化为 int [20] 还是 int [10],导致调用失败。
为函数模板显式地指明实参 函数模板的实参推断是指「在函数调用过程中根据实参的类型来寻找类型参数的具体类型」的过程,这在大部分情况下是奏效的,但是当类型参数的个数较多时,就会有个别的类型无法推断出来,这个时候就必须显式地指明实参。
下面是一个实参推断失败的例子:
1 2 3 4 5 template<typename T1, typename T2> void func (T1 a) { T2 b; } func(10 );
func() 有两个类型参数,分别是 T1 和 T2,但是编译器只能从函数调用中推断出 T1 的类型来,不能推断出 T2 的类型来,所以这种调用是失败的,这个时候就必须显式地指明 T1、T2 的具体类型。
「为函数模板显式地指明实参」和「为类模板显式地指明实参」的形式是类似的,就是在函数名后面添加尖括号< >
,里面包含具体的类型。例如对于上面的 func(),我们要这样来指明实参:
显式指明的模板实参会按照从左到右的顺序与对应的模板参数匹配:第一个实参与第一个模板参数匹配,第二个实参与第二个模板参数匹配,以此类推。只有尾部(最右)的类型参数的实参可以省略,而且前提是它们可以从传递给函数的实参中推断出来。
对于上面的 func(),虽然只有 T2 的类型不能自动推断出来,但是由于它位于类型参数列表的尾部(最右),所以必须同时指明 T1 和 T2 的类型。对代码稍微做出修改:
1 2 3 4 5 6 template<typename T1, typename T2> void func (T2 a) { T1 b; } func<int >(10 ); func<int , int >(20 );
由于 T2 的类型能够自动推断出来,并且它位于参数列表的尾部(最右),所以可以省略。
显式地指明实参时可以应用正常的类型转换 上面我们提到,函数模板仅能进行「const 转换」和「数组或函数指针转换」两种形式的类型转换,但是当我们显式地指明类型参数的实参(具体类型)时,就可以使用正常的类型转换(非模板函数可以使用的类型转换)了。
例如对于下面的函数模板:
1 template<typename T> void func (T a, T b) ;
它的具体调用形式如下:
1 2 func(10 , 23.5 ); func<float >(20 , 93.7 );
在第二种调用形式中,我们已经显式地指明了 T 的类型为 float,编译器不会再为「T 的类型到底是 int 还是 double」而纠结了,所以可以从容地使用正常的类型转换了。
C++模板的显式具体化 C++ 没有办法限制类型参数的范围,我们可以使用任意一种类型来实例化模板。但是模板中的语句(函数体或者类体)不一定就能适应所有的类型,可能会有个别的类型没有意义,或者会导致语法错误。
例如有下面的函数模板,它用来获取两个变量中较大的一个:
1 2 3 template<class T> const T& Max (const T& a, const T& b) { return a > b ? a : b; }
请读者注意a > b
这条语句,>
能够用来比较 int、float、char 等基本类型数据的大小,但是却不能用来比较结构体变量、对象以及数组的大小,因为我们并没有针对结构体、类和数组重载>
。
另外,该函数模板虽然可以用于指针,但比较的是地址大小,而不是指针指向的数据,所以也没有现实的意义。
除了>
,+
-
*
/
=
=
<
等运算符也只能用于基本类型,不能用于结构体、类、数组等复杂类型。总之,编写的函数模板很可能无法处理某些类型,我们必须对这些类型进行单独处理。
模板是一种泛型技术,它能接受的类型是宽泛的、没有限制的,并且对这些类型使用的算法都是一样的(函数体或类体一样)。但是现在我们希望改变这种“游戏规则”,让模板能够针对某种具体的类型使用不同的算法(函数体或类体不同),这在 C++ 中是可以做到的,这种技术称为模板的显示具体化(Explicit Specialization) 。
函数模板和类模板都可以显示具体化,下面我们先讲解函数模板的显示具体化,再讲解类模板的显示具体化。
函数模板的显式具体化 在讲解函数模板的显示具体化语法之前,我们先来看一个显示具体化的例子:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 #include <iostream> #include <string> using namespace std ; typedef struct { string name; int age; float score; } STU; template<class T> const T& Max (const T& a, const T& b) ; template<> const STU& Max<STU>(const STU& a, const STU& b); ostream & operator<<(ostream &out, const STU &stu); int main () { int a = 10 ; int b = 20 ; cout <<Max(a, b)<<endl ; STU stu1 = { "王明" , 16 , 95.5 }; STU stu2 = { "徐亮" , 17 , 90.0 }; cout <<Max(stu1, stu2)<<endl ; return 0 ; } template<class T> const T& Max (const T& a, const T& b) { return a > b ? a : b; } template<> const STU& Max<STU>(const STU& a, const STU& b){ return a.score > b.score ? a : b; } ostream & operator<<(ostream &out, const STU &stu){ out<<stu.name<<" , " <<stu.age <<" , " <<stu.score; return out; }
运行结果:
20
王明 , 16 , 95.5
本例中,STU 结构体用来表示一名学生(Student),它有三个成员,分别是姓名(name)、年龄(age)、成绩(score);Max() 函数用来获取两份数据中较大的一份。
要想获取两份数据中较大的一份,必然会涉及到对两份数据的比较。对于 int、float、char 等基本类型的数据,直接比较它们本身的值即可,而对于 STU 类型的数据,直接比较它们本身的值不但会有语法错误,而且毫无意义,这就要求我们设计一套不同的比较方案,从语法和逻辑上都能行得通,所以本例中我们比较的是两名学生的成绩(score)。
不同的比较方案最终导致了算法(函数体)的不同,我们不得不借助模板的显示具体化技术对 STU 类型进行单独处理。第 14 行代码就是显示具体化的声明,第 34 行代码进行了定义。
请读者注意第 34 行代码,Max中的STU表明了要将类型参数 T 具体化为 STU 类型,原来使用 T 的位置都应该使用 STU 替换,包括返回值类型、形参类型、局部变量的类型。
Max 只有一个类型参数 T,并且已经被具体化为 STU 了,这样整个模板就不再有类型参数了,类型参数列表也就为空了,所以模板头应该写作template<>
。
另外,Max<STU>
中的STU
是可选的,因为函数的形参已经表明,这是 STU 类型的一个具体化,编译器能够逆推出 T 的具体类型。简写后的函数声明为:
1 template<> const STU& Max (const STU& a, const STU& b) ;
函数的调用规则 回顾一下前面学习到的知识,在 C++ 中,对于给定的函数名,可以有非模板函数、模板函数、显示具体化模板函数以及它们的重载版本,在调用函数时,显示具体化优先于常规模板,而非模板函数优先于显示具体化和常规模板。
类模板的显式具体化 除了函数模板,类模板也可以显示具体化,并且它们的语法是类似的。
在《C++类模板》一节中我们定义了一个 Point 类,用来输出不同类型的坐标。在输出结果中,
横坐标 x 和纵坐标 y 是以逗号,为分隔的,但是由于个人审美的不同,我希望当 x 和 y 都是字符串时以|
为分隔,是数字或者其中一个是数字时才以逗号,
为分隔。为了满足我这种奇葩的要求,可以使用显示具体化技术对字符串类型的坐标做特殊处理。
下面的例子演示了如何对 Point 类进行显示具体化:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 #include <iostream> using namespace std ; template<class T1 , class T2 > class Point { public: Point(T1 x, T2 y): m_x(x), m_y(y){ } public: T1 getX () const { return m_x; } void setX (T1 x) { m_x = x; } T2 getY () const { return m_y; } void setY (T2 y) { m_y = y; } void display () const ; private: T1 m_x; T2 m_y; }; template<class T1 , class T2 > void Point<T1, T2>::display() const { cout <<"x=" <<m_x<<", y=" <<m_y<<endl ; } template<> class Point <char *, char *>{ public: Point(char *x, char *y): m_x(x), m_y(y){ } public: char *getX () const { return m_x; } void setX (char *x) { m_x = x; } char *getY () const { return m_y; } void setY (char *y) { m_y = y; } void display () const ; private: char *m_x; char *m_y; }; void Point<char *, char *>::display() const { cout <<"x=" <<m_x<<" | y=" <<m_y<<endl ; } int main () { ( new Point<int , int >(10 , 20 ) ) -> display(); ( new Point<int , char *>(10 , "东京180度" ) ) -> display(); ( new Point<char *, char *>("东京180度" , "北纬210度" ) ) -> display(); return 0 ; }
运行结果:
x=10, y=20
x=10, y=东京180度
x=东京180度 | y=北纬210度
请读者注意第 25 行代码,Point<char*, char*>
表明了要将类型参数 T1、T2 都具体化为char*
类型,原来使用 T1、T2 的位置都应该使用char*替换。Point 类有两个类型参数 T1、T2,并且都已经被具体化了,所以整个类模板就不再有类型参数了,模板头应该写作template<>
。
再来对比第 19、40 行代码,可以发现,当在类的外部定义成员函数时,普通类模板的成员函数前面要带上模板头,而具体化的类模板的成员函数前面不能带模板头。
部分显式具体化 在上面的显式具体化例子中,我们为所有的类型参数都提供了实参,所以最后的模板头为空,也即template<>
。另外 C++ 还允许只为一部分类型参数提供实参,这称为部分显式具体化。
部分显式具体化只能用于类模板,不能用于函数模板。
仍然以 Point 为例,假设我现在希望“只要横坐标 x 是字符串类型”就以|来分隔输出结果,而不管纵坐标 y 是什么类型,这种要求就可以使用部分显式具体化技术来满足。请看下面的代码:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 #include <iostream> using namespace std ; template<class T1 , class T2 > class Point { public: Point(T1 x, T2 y): m_x(x), m_y(y){ } public: T1 getX () const { return m_x; } void setX (T1 x) { m_x = x; } T2 getY () const { return m_y; } void setY (T2 y) { m_y = y; } void display () const ; private: T1 m_x; T2 m_y; }; template<class T1 , class T2 > void Point<T1, T2>::display() const { cout <<"x=" <<m_x<<", y=" <<m_y<<endl ; } template<typename T2> class Point <char *, T2>{ public: Point(char *x, T2 y): m_x(x), m_y(y){ } public: char *getX () const { return m_x; } void setX (char *x) { m_x = x; } T2 getY () const { return m_y; } void setY (T2 y) { m_y = y; } void display () const ; private: char *m_x; T2 m_y; }; template<typename T2> void Point<char *, T2>::display() const { cout <<"x=" <<m_x<<" | y=" <<m_y<<endl ; } int main () { ( new Point<int , int >(10 , 20 ) ) -> display(); ( new Point<char *, int >("东京180度" , 10 ) ) -> display(); ( new Point<char *, char *>("东京180度" , "北纬210度" ) ) -> display(); return 0 ; }
运行结果:
x=10, y=20
x=东京180度 | y=10
x=东京180度 | y=北纬210度
本例中,T1 对应横坐标 x 的类型,我们将 T1 具体化为char*
,第 25 行代码就是类模板的部分显示具体化。
模板头template<typename T2>
中声明的是没有被具体化的类型参数;类名Point<char*, T2>
列出了所有类型参数,包括未被具体化的和已经被具体化的。
类名后面之所以要列出所有的类型参数,是为了让编译器确认“到底是第几个类型参数被具体化了”,如果写作template<typename T2> class Point<char*>
,编译器就不知道char*代表的是第一个类型参数,还是第二个类型参数。
C++模板中的非类型参数 模板是一种泛型技术,目的是将数据的类型参数化,以增强 C++ 语言(强类型语言)的灵活性。C++ 对模板的支持非常自由,模板中除了可以包含类型参数,还可以包含非类型参数,例如:
1 2 template<typename T, int N> class Demo { }; template<class T, int N> void func (T (&arr)[N]) ;
T 是一个类型参数,它通过class
或typename
关键字指定。N 是一个非类型参数,用来传递数据的值,而不是类型,它和普通函数的形参一样,都需要指明具体的类型。类型参数和非类型参数都可以用在函数体或者类体中。
当调用一个函数模板或者通过一个类模板创建对象时,非类型参数会被用户提供的、或者编译器推断出的值所取代。
在函数模板中使用非类型参数 在《C++函数模板的重载》一节中,我们通过 Swap() 函数来交换两个数组的值,其原型为:
1 template<typename T> void Swap (T a[], T b[], int len) ;
形参 len 用来指明要交换的数组的长度,调用 Swap() 函数之前必须先通过sizeof
求得数组长度再传递给它。
有读者可能会疑惑,为什么在函数内部不能求得数组长度,一定要通过形参把数组长度传递进去呢?这是因为数组在作为函数参数时会自动转换为数组指针,而sizeof只能通过数组名求得数组长度,不能通过数组指针求得数组长度。
多出来的形参 len 给编码带来了不便,我们可以借助模板中的非类型参数将它消除,请看下面的代码:
template<typename T, unsigned N> void Swap(T (&a)[N], T (&b)[N]){
T temp;
for(int i=0; i<N; i++){
temp = a[i];
a[i] = b[i];
b[i] = temp;
}
}
T (&a)[N]表明 a 是一个引用,它引用的数据的类型是T [N],也即一个数组;T (&b)[N]也是类似的道理。分析一个引用和分析一个指针的方法类似,编译器总是从它的名字开始读取,然后按照优先级顺序依次解析,这一点已在《只需一招,彻底攻克C语言指针》中进行了讲解。
调用 Swap() 函数时,需要将数组名字传递给它:
1 2 3 int a[5 ] = { 1 , 2 , 3 , 4 , 5 };int b[5 ] = { 10 , 20 , 30 , 40 , 50 };Swap(a, b);
编译器会使用数组类型int来代替类型参数T,使用数组长度5来代替非类型参数N。
下面是一个完整的示例:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 #include <iostream> using namespace std ; template<class T> void Swap (T &a, T &b) ; template<typename T, unsigned N> void Swap (T (&a)[N], T (&b)[N]) ; template<typename T, unsigned N> void printArray (T (&arr)[N]) ; int main () { int m = 10 , n = 99 ; Swap(m, n); cout <<m<<", " <<n<<endl ; int a[5 ] = { 1 , 2 , 3 , 4 , 5 }; int b[5 ] = { 10 , 20 , 30 , 40 , 50 }; Swap(a, b); printArray(a); printArray(b); return 0 ; } template<class T> void Swap (T &a, T &b) { T temp = a; a = b; b = temp; } template<typename T, unsigned N> void Swap (T (&a)[N], T (&b)[N]) { T temp; for (int i=0 ; i<N; i++){ temp = a[i]; a[i] = b[i]; b[i] = temp; } } template<typename T, unsigned N> void printArray (T (&arr)[N]) { for (int i=0 ; i<N; i++){ if (i == N-1 ){ cout <<arr[i]<<endl ; }else { cout <<arr[i]<<", " ; } } }
运行结果:
99, 10
10, 20, 30, 40, 50
1, 2, 3, 4, 5
printArray() 也使用了非类型参数,这样只传递数组名字就能够打印数组元素了。
在类模板中使用非类型参数 C/C++ 规定,数组一旦定义后,它的长度就不能改变了;换句话说,数组容量不能动态地增大或者减小。这样的数组称为静态数组(Static array) 。静态数组有时候会给编码代码不便,我们可以通过自定义的 Array 类来实现动态数组(Dynamic array) 。所谓动态数组,是指数组容量能够在使用的过程中随时增大或减小。
动态数组的完整实现代码如下:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 #include <iostream> #include <cstring> #include <cstdlib> using namespace std ; template<typename T, int N> class Array {public: Array(); ~Array(); public: T & operator[](int i); int length () const { return m_length; } bool capacity (int n) ; private: int m_length; int m_capacity; T *m_p; }; template<typename T, int N> Array<T, N>::Array(){ m_p = new T[N]; m_capacity = m_length = N; } template<typename T, int N> Array<T, N>::~Array(){ delete[] m_p; } template<typename T, int N> T & Array<T, N>::operator[](int i){ if (i<0 || i>=m_length){ cout <<"Exception: Array index out of bounds!" <<endl ; } return m_p[i]; } template<typename T, int N> bool Array<T, N>::capacity(int n){ if (n > 0 ){ int len = m_length + n; if (len <= m_capacity){ m_length = len; return true ; }else { T *pTemp = new T[m_length + 2 * n * sizeof (T)]; if (pTemp == NULL ){ cout <<"Exception: Failed to allocate memory!" <<endl ; return false ; }else { memcpy ( pTemp, m_p, m_length*sizeof (T) ); delete[] m_p; m_p = pTemp; m_capacity = m_length = len; } } }else { int len = m_length - abs (n); if (len < 0 ){ cout <<"Exception: Array length is too small!" <<endl ; return false ; }else { m_length = len; return true ; } } } int main () { Array<int , 5 > arr; for (int i=0 , len=arr.length(); i<len; i++){ arr[i] = 2 *i; } for (int i=0 , len=arr.length(); i<len; i++){ cout <<arr[i]<<" " ; } cout <<endl ; arr.capacity(8 ); for (int i=5 , len=arr.length(); i<len; i++){ arr[i] = 2 *i; } for (int i=0 , len=arr.length(); i<len; i++){ cout <<arr[i]<<" " ; } cout <<endl ; arr.capacity(-4 ); for (int i=0 , len=arr.length(); i<len; i++){ cout <<arr[i]<<" " ; } cout <<endl ; return 0 ; }
运行结果:
0 2 4 6 8
0 2 4 6 8 10 12 14 16 18 20 22 24
0 2 4 6 8 10 12 14 16
Array 是一个类模板,它有一个类型参数T
和一个非类型参数N
,T 指明了数组元素的类型,N 指明了数组长度。
capacity() 成员函数是 Array 类的关键,它使得数组容量可以动态地增加或者减小。传递给它一个正数时,数组容量增大;传递给它一个负数时,数组容量减小。
之所以能通过[ ]
来访问数组元素,是因为在 Array 类中以成员函数的形式重载了[ ]
运算符,并且返回值是数组元素的引用。如果直接返回数组元素的值,那么将无法给数组元素赋值。
非类型参数的限制 非类型参数的类型不能随意指定,它受到了严格的限制,只能是一个整数,或者是一个指向对象或函数的指针(也可以是引用)。
当非类型参数是一个整数时,传递给它的实参,或者由编译器推导出的实参必须是一个常量表达式,例如10
、2 * 30
、18 + 23 - 4
等,但不能是n
、n + 10
、n + m
等(n 和 m 都是变量)。
对于上面的 Swap() 函数,下面的调用就是错误的:
1 2 3 4 5 int len;cin >>len;int a[len];int b[len];Swap(a, b);
对上面的 Array 类,以下创建对象的方式是错误的:
1 2 3 int len;cin >>len;Array<int , len> arr;
这两种情况,编译器推导出来的实参是 len,是一个变量,而不是常量。
当非类型参数是一个指针(引用)时,绑定到该指针的实参必须具有静态的生存期;换句话说,实参必须存储在虚拟地址空间中的静态数据区。局部变量位于栈区,动态创建的对象位于堆区,它们都不能用作实参。
C++ 模板的实例化 模板不会占用内存,最终生成的函数或者类才会占用内存。由模板生成函数或类的过程叫做模板的实例化(Instantiate) ,相应地,针对某个类型生成的特定版本的函数或类叫做模板的一个实例(Instantiation) 。
模板的实例化是按需进行的,用到哪个类型就生成针对哪个类型的函数或类,不会提前生成过多的代码。也就是说,编译器会根据传递给类型参数的实参(也可以是编译器自己推演出来的实参)来生成一个特定版本的函数或类,并且相同的类型只生成一次。实例化的过程也很简单,就是将所有的类型参数用实参代替。
例如,给定下面的函数模板和函数调用:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 template<typename T> void Swap (T &a, T &b) { T temp = a; a = b; b = temp; } int main () { int n1 = 100 , n2 = 200 , n3 = 300 , n4 = 400 ; float f1 = 12.5 , f2 = 56.93 ; Swap(n1, n2); Swap(f1, f2); Swap(n3, n4); return 0 ; }
编译器会根据不同的实参实例化出不同版本的 Swap() 函数。对于Swap(n1, n2)调用,编译器会生成并编译一个 Swap() 版本,其中 T 被替换为 int:
1 2 3 4 5 void Swap (int &a, int &b) { int temp = a; a = b; b = temp; }
对于Swap(f1, f2)
调用,编译器会生成另一个 Swap() 版本,其中 T 被替换为 float。对于Swap(n3, n4)
调用,编译器不会再生成新版本的 Swap() 了,因为刚才已经针对 int 生成了一个版本,直接拿来使用即可。
另外需要注意的是类模板的实例化,通过类模板创建对象时并不会实例化所有的成员函数,只有等到真正调用它们时才会被实例化;如果一个成员函数永远不会被调用,那它就永远不会被实例化。这说明类的实例化是延迟的、局部的,编译器并不着急生成所有的代码 。
通过类模板创建对象时,一般只需要实例化成员变量和构造函数。成员变量被实例化后就能够知道对象的大小了(占用的字节数),构造函数被实例化后就能够知道如何初始化了;对象的创建过程就是分配一块大小已知的内存,并对这块内存进行初始化。
请看下面的例子:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 #include <iostream> using namespace std ; template<class T1 , class T2 > class Point {public: Point(T1 x, T2 y): m_x(x), m_y(y){ } public: T1 getX () const { return m_x; } void setX (T1 x) { m_x = x; } T2 getY () const { return m_y; }; void setY (T2 y) { m_y = y; }; void display () const ; private: T1 m_x; T2 m_y; }; template<class T1 , class T2 > void Point<T1, T2>::display() const { cout <<"x=" <<m_x<<", y=" <<m_y<<endl ; } int main () { Point<int , int > p1 (10 , 20 ) ; p1.setX(40 ); p1.setY(50 ); cout <<"x=" <<p1.getX()<<", y=" <<p1.getY()<<endl ; Point<char *, char *> p2 ("东京180度" , "北纬210度" ) ; p2.display(); return 0 ; }
运行结果:
x=40, y=50
x=东京180度, y=北纬210度
p1 调用了所有的成员函数,整个类会被完整地实例化。p2 只调用了构造函数和 display() 函数,剩下的 get 函数和 set 函数不会被实例化。
值得提醒的是,Point<int, int>
和Point<char*, char*>
是两个相互独立的类,它们的类型是不同的,不能相互兼容,也不能自动地转换类型,所以诸如p1 = p2;
这样的语句是错误的,除非重载了=
运算符。
C++ 模板多文件编程 在将函数应用于多文件编程时,我们通常是将函数定义放在源文件(.cpp
文件)中,将函数声明放在头文件(.h
文件)中,使用函数时引入(#include
命令)对应的头文件即可。
编译是针对单个源文件的,只要有函数声明,编译器就能知道函数调用是否正确;而将函数调用和函数定义对应起来的过程,可以延迟到链接时期。正是有了链接器的存在,函数声明和函数定义的分离才得以实现。
将类应用于多文件编程也是类似的道理,我们可以将类的声明和类的实现分别放到头文件和源文件中。类的声明已经包含了所有成员变量的定义和所有成员函数的声明(也可以是 inline 形式的定义),这样就知道如何创建对象了,也知道如何调用成员函数了,只是还不能将函数调用与函数实现对应起来,但是这又有什么关系呢,反正链接器可以帮助我们完成这项工作。
总起来说,不管是函数还是类,声明和定义(实现)的分离其实是一回事,都是将函数定义放到其他文件中,最终要解决的问题也只有一个,就是把函数调用和函数定义对应起来(找到函数定义的地址,并填充到函数调用处),而保证完成这项工作的就是链接器。
基于传统的编程思维,初学者往往也会将模板(函数模板和类模板)的声明和定义分散到不同的文件中,以期达到「模块化编程」的目的。但事实证明这种做法是不对的,程序员惯用的做法是将模板的声明和定义都放到头文件中。
模板并不是真正的函数或类,它仅仅是用来生成函数或类的一张“图纸”,在这个生成过程中有三点需要明确:
模板的实例化是按需进行的,用到哪个类型就生成针对哪个类型的函数或类,不会提前生成过多的代码;
模板的实例化是由编译器完成的,而不是由链接器完成的;
在实例化过程中需要知道模板的所有细节,包含声明和定义。
将函数模板的声明和定义分散到不同的文件 为了更加深入地说明问题,现在有一个反面教材,它将函数模板的声明和实现分别放到了头文件和源文件。
func.cpp 源码:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 template<typename T> void Swap (T &a, T &b) { T temp = a; a = b; b = temp; } void bubble_sort (int arr[], int n) { for (int i=0 ; i<n-1 ; i++){ bool isSorted = true ; for (int j=0 ; j<n-1 -i; j++){ if (arr[j] > arr[j+1 ]){ isSorted = false ; Swap(arr[j], arr[j+1 ]); } } if (isSorted) break ; } }
func.h 源码:
1 2 3 4 5 #ifndef _FUNC_H #define _FUNC_H template<typename T> void Swap (T &a, T &b) ; void bubble_sort (int arr[], int n) ;#endif
main.cpp 源码
1 2 3 4 5 6 7 8 9 10 11 #include <iostream> #include "func.h" using namespace std ; int main () { int n1 = 10 , n2 = 20 ; Swap(n1, n2); double f1 = 23.8 , f2 = 92.6 ; Swap(f1, f2); return 0 ; }
该工程包含了两个源文件和一个头文件,func.cpp
中定义了两个函数,func.h
中对函数进行了声明,main.cpp
中对函数进行了调用,这是典型的将函数的声明和实现分离的编程模式。
运行上面的程序,会产生一个链接错误,意思是无法找到void Swap<double>(double &, double &)
这个函数。主函数 main() 中共调用了两个版本的 Swap() 函数,它们的原型分别是:
1 2 void Swap<double >(int &, int &);void Swap<double >(double &, double &);
为什么针对 int 的版本能够找到定义,而针对 double 的版本就找不到呢?
我们先来说针对 double 的版本为什么找不到定义。当编译器编译main.cpp
时,发现使用到了 double 版本的 Swap() 函数,于是尝试生成一个 double 版本的实例,但是由于只有声明没有定义,所以生成失败。不过这个时候编译器不会报错,而是对该函数的调用做一个记录,希望等到链接程序时在其他目标文件(.obj 文件或 .o 文件)中找到该函数的定义。很明显,本例需要到func.obj
中寻找。但是遗憾的是,func.cpp
中没有调用 double 版本的 Swap() 函数,编译器不会生成 double 版本的实例,所以链接器最终也找不到 double 版本的函数定义,只能抛出一个链接错误,让程序员修改代码。
那么,针对 int 的版本为什么能够找到定义呢?请读者注意bubble_sort()
函数,该函数用来对数组元素进行排序,在排序过程中需要频繁的交换两个元素的值,所以调用了 Swap() 函数,这样做的结果是:编译生成的func.obj
中会有一个 int 版本的 Swap() 函数定义。编译器在编译main.cpp
时虽然找不到 int 版本的实例,但是等到链接程序时,链接器在func.obj
中找到了,所以针对 int 版本的调用就不会出错。
将类模板的声明和实现分散到不同的文件 我们再看一个类模板的反面教材,它将类模板的声明和实现分别放到了头文件和源文件。
point.h 源码:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 #ifndef _POINT_H #define _POINT_H template<class T1 , class T2 > class Point {public: Point(T1 x, T2 y): m_x(x), m_y(y){ } public: T1 getX () const { return m_x; } void setX (T1 x) { m_x = x; } T2 getY () const { return m_y; }; void setY (T2 y) { m_y = y; }; void display () const ; private: T1 m_x; T2 m_y; }; #endif point.cpp 源码: #include <iostream> #include "point.h" using namespace std ; template<class T1 , class T2 > void Point<T1, T2>::display() const { cout <<"x=" <<m_x<<", y=" <<m_y<<endl ; } main.cpp 源码: #include <iostream> #include "point.h" using namespace std ; int main () { Point<int , int > p1 (10 , 20 ) ; p1.setX(40 ); p1.setY(50 ); cout <<"x=" <<p1.getX()<<", y=" <<p1.getY()<<endl ; Point<char *, char *> p2 ("东京180度" , "北纬210度" ) ; p2.display(); return 0 ; }
该工程包含了两个源文件和一个头文件,point.h
中声明了类模板,point.cpp
中对类模板进行了实现,main.cpp
中通过类模板创建了对象,并调用了成员函数,这是典型的将类的声明和实现分离的编程模式。
运行上面的程序,会产生一个链接错误,意思是无法通过 p2 调用Point<char*, char*>::display() const
这个函数。
类模板声明位于point.h
中,它包含了所有成员变量的定义以及构造函数、get 函数、set 函数的定义,这些信息足够创建出一个完整的对象了,并且可以通过对象调用 get 函数和 set 函数,所以main.cpp
的前 11 行代码都不会报错。而第 12 行代码调用了 display() 函数,该函数的定义位于point.cpp
文件中,并且point.cpp
中也没有生成对应的实例,所以会在链接期间抛出错误。
总结 通过上面的两个反面教材可以总结出,「不能将模板的声明和定义分散到多个文件中」的根本原因是:模板的实例化是由编译器完成的,而不是由链接器完成的,这可能会导致在链接期间找不到对应的实例。
修复上面两个项目的方法也很简单,就是将 func.cpp、point.cpp 的模板定义(实现)部分分别合并到 func.h、point.h 中。如下:
函数模板 func.h源码:
1 2 3 4 5 6 7 8 9 10 11 12 13 #ifndef _FUNC_H #define _FUNC_H template<typename T> void Swap (T &a, T &b) { T temp = a; a = b; b = temp; } void bubble_sort (int arr[], int n) ;#endif
func.cpp源码:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 #include "func.h" void bubble_sort (int arr[], int n) { for (int i=0 ; i<n-1 ; i++){ bool isSorted = true ; for (int j=0 ; j<n-1 -i; j++){ if (arr[j] > arr[j+1 ]){ isSorted = false ; Swap(arr[j], arr[j+1 ]); } } if (isSorted) break ; } }
main.cpp源码:
1 2 3 4 5 6 7 8 9 10 11 12 13 #include <iostream> #include "func.h" using namespace std ; int main () { int n1 = 10 , n2 = 20 ; Swap(n1, n2); double f1 = 23.8 , f2 = 92.6 ; Swap(f1, f2); return 0 ; }
类模板 point.h源码:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 #ifndef _POINT_H #define _POINT_H #include <iostream> using namespace std ; template<class T1 , class T2 > class Point {public: Point(T1 x, T2 y): m_x(x), m_y(y){ } public: T1 getX () const { return m_x; } void setX (T1 x) { m_x = x; } T2 getY () const { return m_y; }; void setY (T2 y) { m_y = y; }; void display () const ; private: T1 m_x; T2 m_y; }; template<class T1 , class T2 > void Point<T1, T2>::display() const { cout <<"x=" <<m_x<<", y=" <<m_y<<endl ; } #endif
main.cpp源码
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 #include <iostream> #include "point.h" using namespace std ; int main () { Point<int , int > p1 (10 , 20 ) ; p1.setX(40 ); p1.setY(50 ); cout <<"x=" <<p1.getX()<<", y=" <<p1.getY()<<endl ; Point<char *, char *> p2 ("东京180度" , "北纬210度" ) ; p2.display(); return 0 ; }
模板的显式实例化 前面讲到的模板的实例化是在调用函数或者创建对象时由编译器自动完成的,不需要程序员引导,因此称为隐式实例化 。相对应的,我们也可以通过代码明确地告诉编译器需要针对哪个类型进行实例化,这称为显式实例化 。
编译器在实例化的过程中需要知道模板的所有细节:对于函数模板,也就是函数定义;对于类模板,需要同时知道类声明和类定义。我们必须将显式实例化的代码放在包含了模板定义的源文件中,而不是仅仅包含了模板声明的头文件中。
显式实例化的一个好处是,可以将模板的声明和定义(实现)分散到不同的文件中了。
函数模板的显式实例化 以上节讲到的 compare() 函数为例,针对 double 类型的显式实例化代码为:
1 template void Swap (double &a, double &b) ;
这条语言由两部分组成,前边是一个template
关键字(后面不带< >
),后面是一个普通的函数原型,组合在一起的意思是:将模板实例化成和函数原型对应的一个具体版本。
将该代码放到 func.cpp 文件的最后,再运行程序就不会出错了。
另外,还可以在包含了函数调用的源文件(main.cpp)中再增加下面的一条语句:
1 extern template void Swap (double &a, double &b) ;
该语句在前面增加了extern
关键字,它的作用是明确地告诉编译器,该版本的函数实例在其他文件中,请在链接期间查找。不过这条语句是多余的,即使不写,编译器发现当前文件中没有对应的模板定义,也会自动去其他文件中查找。
上节我们展示了一个反面教材,告诉大家不能把函数模板的声明和定义分散到不同的文件中,但是现在有了显式实例化,这一点就可以做到了,下面就对上节的代码进行修复。
func.cpp 源码:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 template<typename T> void Swap (T &a, T &b) { T temp = a; a = b; b = temp; } void bubble_sort (int arr[], int n) { for (int i=0 ; i<n-1 ; i++){ bool isSorted = true ; for (int j=0 ; j<n-1 -i; j++){ if (arr[j] > arr[j+1 ]){ isSorted = false ; Swap(arr[j], arr[j+1 ]); } } if (isSorted) break ; } } template void Swap (double &a, double &b) ;
func.h 源码:
1 2 3 4 5 #ifndef _FUNC_H #define _FUNC_H template<typename T> void Swap (T &a, T &b) ; void bubble_sort (int arr[], int n) ;#endif
main.cpp 源码:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 #include <iostream> #include "func.h" using namespace std ; extern template void Swap (double &a, double &b) ;extern template void Swap (int &a, int &b) ;int main () { int n1 = 10 , n2 = 20 ; Swap(n1, n2); double f1 = 23.8 , f2 = 92.6 ; Swap(f1, f2); return 0 ; }
显式实例化也包括声明和定义,定义要放在模板定义(实现)所在的源文件,声明要放在模板声明所在的头文件(当然也可以不写)。
类模板的显式实例化 类模板的显式实例化和函数模板类似。以上节的 Point 类为例,针对char*
类型的显式实例化(定义形式)代码为:
1 template class Point <char *, char *>;
相应地,它的声明形式为:
1 extern template class Point <char *, char *>;
不管是声明还是定义,都要带上class
关键字,以表明这是针对类模板的。
另外需要注意的是,显式实例化一个类模板时,会一次性实例化该类的所有成员,包括成员变量和成员函数。
有了类模板的显式实例化,就可以将类模板的声明和定义分散到不同的文件中了,下面我们就来修复上节的代码。
point.cpp 源文件:
1 2 3 4 5 6 7 8 9 10 #include <iostream> #include "point.h" using namespace std ; template<class T1 , class T2 > void Point<T1, T2>::display() const { cout <<"x=" <<m_x<<", y=" <<m_y<<endl ; } template class Point <char *, char *>; template class Point <int , int >;
point.h 源码:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 #ifndef _POINT_H #define _POINT_H template<class T1 , class T2 > class Point {public: Point(T1 x, T2 y): m_x(x), m_y(y){ } public: T1 getX () const { return m_x; } void setX (T1 x) { m_x = x; } T2 getY () const { return m_y; }; void setY (T2 y) { m_y = y; }; void display () const ; private: T1 m_x; T2 m_y; }; #endif
main.cpp 源码:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 #include <iostream> #include "point.h" using namespace std ; extern template class Point <char *, char *>;extern template class Point <int , int >;int main () { Point<int , int > p1 (10 , 20 ) ; p1.setX(40 ); p1.setY(50 ); cout <<"x=" <<p1.getX()<<", y=" <<p1.getY()<<endl ; Point<char *, char *> p2 ("东京180度" , "北纬210度" ) ; p2.display(); return 0 ; }
总结 函数模板和类模板的实例化语法是类似的,我们不妨对它们做一下总结:
1 2 extern template declaration; //实例化声明 template declaration; //实例化定义
对于函数模板来说,declaration 就是一个函数原型;对于类模板来说,declaration 就是一个类声明。
显式实例化的缺陷 C++ 支持显式实例化的目的是为「模块化编程」提供一种解决方案,这种方案虽然有效,但是也有明显的缺陷:程序员必须要在模板的定义文件(实现文件)中对所有使用到的类型进行实例化。这就意味着,每次更改了模板使用文件(调用函数模板的文件,或者通过类模板创建对象的文件),也要相应地更改模板定义文件,以增加对新类型的实例化,或者删除无用类型的实例化。
一个模板可能会在多个文件中使用到,要保持这些文件的同步更新是非常困难的。而对于库的开发者来说,他不能提前假设用户会使用哪些类型,所以根本就无法使用显式实例化,只能将模板的声明和定义(实现)全部放到头文件中;C++ 标准库几乎都是用模板来实现的,这些模板的代码也都位于头文件中。
总起来说,如果我们开发的模板只有我们自己使用,那也可以勉强使用显式实例化;如果希望让其他人使用(例如库、组件等),那只能将模板的声明和定义都放到头文件中了。
C++ 类模板与继承 类模板和类模板之间、类模板和类之间可以互相继承。它们之间的派生关系有以下四种情况。
类模板从类模板派生
类模板从模板类派生
类模板从普通类派生
普通类从模板类派生
类模板从类模板派生 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 template <class T1 , class T2 > class A { Tl 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 ; }
编译到第 18 行,编译器用 int 替换类模板 B 中的 T1,用 double 替换 T2,生成 B<int, double> 类如下:
1 2 3 4 class B <int , double >: public A <double , int >{ int v3; double v4; };
B <int, double> 的基类是 A <double, int>。于是编译器就要用 double 替换类模板 A 中的 T1,用 int 替换 T2,生成 A<double, int> 类如下:
1 2 3 4 class A <double , int >{ double v1; int v2; };
编译到第 19 行,编译器生成类 C,还有 C 的直接基类 B<int, int>,以及 B<int, int> 的基类 A<int, int>。
类模板从模板类派生 示例程序:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 template<class T1 , class T2 > class A { T1 v1; T2 v2; }; template <class T > class B : public A <int , double >{ T v; }; int main () { B <char > obj1; return 0 ; }
第 4 行,A<int, double> 是一个具体的类的名字,而且它是一个模板类,因此说类模板 B 是从模板类派生而来的。
编译器编译到第 5 行B<Char>obj1;
时会自动生成两个模板类:A<int, double> 和 B。
类模板从普通类派生 1 2 3 4 5 6 7 8 9 10 11 class A { int v1; };template<class T > class B : public A{ T v; }; int main () { B <char > obj1; return 0 ; }
普通类从模板类派生 1 2 3 4 5 6 7 8 9 10 11 12 13 14 template <class T > class A { T v1; int n; }; class B : public A <int > { double v; }; int main () { B obj1; return 0 ; }
C++类模板与友元 函数、类、类的成员函数作为类模板的友元 函数、类、类的成员函数都可以作为类模板的友元。程序示例如下:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 void Func1 () { }class A { };class B { public: void Func () { } }; template <class T > class Tmpl { friend void Func1 () ; friend class A ; friend void B::Func () ; }; int main () { Tmpl<int > i; Tmpl<double > f; return 0 ; }
类模板实例化时,除了类型参数被替换外,其他所有内容都原样保留,因此任何从 Tmp1 实例化得到的类都包含上面三条友元声明,因而也都会把 Func1、类 A 和 B::Func 当作友元。
函数模板作为类模板的友元 将<<运算符重载为一个函数模板,并将该函数模板作为 Pair 模板的友元,这样,任何从 Pair 模板实例化得到的对象都能用<<运算符通过 cout 输出。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 #include <iostream> #include <string> using namespace std ; template <class T1 , class T2 > class Pair { private: T1 key; T2 value; public: Pair(T1 k, T2 v) : key(k), value(v) { }; bool operator < (const Pair<T1, T2> & p) const ; template <class T3 , class T4 > friend ostream & operator << (ostream & o, const Pair<T3, T4> & p); }; template <class T1 , class T2 > bool Pair <T1, T2>::operator< (const Pair<T1, T2> & p) const { return key < p.key; } template <class Tl , class T2 > ostream & operator << (ostream & o, const Pair<T1, T2> & 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 ; }
程序的输出结果是:
(Torn, 29) (12, 3.14)
第 13、14 行将函数模板 operator<< 声明为类模板 Pair 的友元。在 Visual Studio 中,这两行也可以用下面的写法替代:
1 friend ostream & operator<< <T1, T2>(ostream & o, const Pair<T1, T2> & p);
但在 Dev C ++ 中,替代后编译就无法通过了。
编译本程序时,编译器自动生成了两个 operator << 函数,它们的原型分别是:
1 2 ostream & operator << (ostream & o, const Pair<string , int > & p); ostream & operator << (ostream & o, const Pair<int , double > & p);
前者是 Pair <string, int> 类的友元,但不是 Pair<int, double> 类的友元;后者是 Pair<int, double> 类的友元,但不是 Pair<string, int> 类的友元。
函数模板作为类的友元 实际上,类也可以将函数模板声明为友元。程序示例如下:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 #include <iostream> using namespace std ; class A { 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
编译器编译到第 19 行Print(a);
时,就从 Print 模板实例化出一个 Print 函数,原型如下:
1 void Print (const A & p) ;
这个函数本来不能访问 p 的私有成员。但是编译器发现,如果将类 A 的友元声明中的 T 换成 A,就能起到将该 Print 函数声明为友元的作用,因此编译器就认为该 Print 函数是类 A 的友元。
类模板作为类模板的友元 一个类模板还可以将另一个类模板声明为友元。程序示例如下:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 #include <iostream> using namespace std ; template<class T > class A { public: void Func (const T & p) { cout << p.v; } }; template <class T > class B { private: T v; public: B(T n) : v(n) { } template <class T2 > friend class A ; }; int main () { B<int > b (5 ) ; A< B<int > > a; a.Func(b); return 0 ; }
程序的输出结果是:
5
在本程序中,A< B > 类成为 B 类的友元。
C++类模板中的静态成员 类模板中可以定义静态成员,从该类模板实例化得到的所有类都包含同样的静态成员。
程序示例如下:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 #include <iostream> using namespace std ; 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; ia.PrintCount(); da.PrintCount(); return 0 ; }
程序的输出结果是:
1
1
第 14 行和第 15 行,对静态成员变量在类外部加以声明是必需的。在 Visual Studio 2008 中,这两行也可以简单地写成:
1 2 int A<int >::count = 0 ;int A<double >::count = 0 ;
A 和 A 是两个不同的类。虽然它们都有静态成员变量 count,但是显然,A 的对象 ia 和 A 的对象 da 不会共享一份 count。