C++模板（二）

最新推荐文章于 2022-09-06 22:40:36 发布

koozxcv

最新推荐文章于 2022-09-06 22:40:36 发布

阅读量553

点赞数

分类专栏： C/C++

本文链接：https://blog.csdn.net/koozxcv/article/details/50546493

版权

C/C++ 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

C++模板

四、类模板的默认模板类型形参

　　1、可以为类模板的类型形参提供默认值，但不能为函数模板的类型形参提供默认值。函数模板和类模板都可以为模板的非类型形参提供默认值。

　　2、类模板的类型形参默认值形式为：template<class T1, class T2=int> class A{};为第二个模板类型形参T2提供int型的默认值。

　　3、类模板类型形参默认值和函数的默认参数一样，如果有多个类型形参则从第一个形参设定了默认值之后的所有模板形参都要设定默认值，比如template<class T1=int, class T2>class A{};就是错误的，因为T1给出了默认值，而T2没有设定。

　　4、在类模板的外部定义类中的成员时template 后的形参表应省略默认的形参类型。比如template<class T1, class T2=int> class A{public: void h();}; 定义方法为template<class T1,class T2> void A<T1,T2>::h(){}。

定义类模板类型形参：

演示实例1：

　　TemplateDemo.h

 1 #ifndef TEMPLATE_DEMO_HXX
 2 #define TEMPLATE_DEMO_HXX
 3 
 4 template<class T> class A{
 5     public:
 6         T g(T a,T b);
 7         A();
 8 };
 9 
10 #endif

　　TemplateDemo.cpp

 1 #include<iostream.h>
 2 #include "TemplateDemo.h"
 3 
 4 template<class T> A<T>::A(){}
 5 
 6 template<class T> T A<T>::g(T a,T b){
 7     return a+b;
 8 }
 9 
10 void main(){
11     A<int> a;
12     cout<<a.g(2,3)<<endl;
13 }

　　运行结果： 5

　　类模板的默认模板类型形参示例1：

　　TemplateDemo03.h

 1 #ifndef TEMPLATE_DEMO_03
 2 #define TEMPLATE_DEMO_03
 3 //定义带默认类型形参的类模板。这里把T2默认设置为int型。
 4 template<class T1,class T2=int> class CeilDemo{
 5     public:
 6         int ceil(T1,T2);
 7 };
 8 //在类模板的外部定义类中的成员时template 后的形参表应省略默认的形参类型。
 9 template<class T1,class T2> 
10 int CeilDemo<T1,T2>::ceil(T1 a,T2 b){
11     return a>>b;
12 }
13 
14 #endif

　　TemplateDemo03.cpp

1 #include<iostream.h>
2 #include "TemplateDemo03.h"
3 
4 void main(){
5     CeilDemo<int> cd;
6     cout<<cd.ceil(8,2)<<endl;
7 }

　　运行结果：　　　　　　　2　

　　在类模板的外部定义类中的成员时template 后的形参表应省略默认的形参类型，如果没有省略，不会出现编译错误而是提出警告：

1 --------------------Configuration: TemplateDemo03 - Win32 Debug--------------------
2 Compiling...
3 TemplateDemo03.cpp
4 g:\c++\cdaima\templatedemo03\templatedemo03.h(12) : 
5 warning C4519: default template arguments are only allowed on a class template; ignored
6 
7 TemplateDemo03.obj - 0 error(s), 1 warning(s)

　　原作者：类模板类型形参默认值和函数的默认参数一样，如果有多个类型形参则从第一个形参设定了默认值之后的所有模板形参都要设定默认值，比如template<class T1=int, class T2>class A{};就是错误的，因为T1给出了默认值，而T2没有设定。

实例测试如下：

　　类模板的默认模板类型形参示例2：

　　TemplateDemo03.h

 1 #ifndef TEMPLATE_DEMO_03
 2 #define TEMPLATE_DEMO_03
 3 
 4 template<class T1=int,class T2,class T3> class CeilDemo{
 5     public:
 6         int ceil(T1,T2,T3);
 7 };
 8 
 9 template<class T1,class T2,class T3> 
10 int CeilDemo<T1,T2,T3>::ceil(T1 a,T2 b,T3 c){
11     return a+b+c;
12 }
13 
14 #endif

　　TemplateDemo03.cpp

1 #include<iostream.h>
2 #include "TemplateDemo03.h"
3 
4 void main(){
5     CeilDemo<int,int> cd;
6     cout<<cd.ceil(2,3,4)<<endl;
7 }

　　运行结果：　　　　　　　　9　　

　　上例中我们看到，虽然多个类型形参则从第一个形参T1设定了默认值为int类型，但后面的两个并没有设定默认值。我们在声明对象的时候指明了T2和T3的类型都为int类型，编译、运行没有任何警告和错误。但并不能否定原作者是错的，这只是一个特例，看下面的示例：

类模板的默认模板类型形参示例3：

　　TemplateDemo03.h

 1 #ifndef TEMPLATE_DEMO_03
 2 #define TEMPLATE_DEMO_03
 3 
 4 template<class T1=int,class T2,class T3> class CeilDemo{
 5     public:
 6         double ceil(T1,T2,T3);
 7 };
 8 
 9 template<class T1,class T2,class T3> 
10 double CeilDemo<T1,T2,T3>::ceil(T1 a,T2 b,T3 c){
11     return a+b+c;
12 }
13 
14 #endif

　　TemplateDemo03.cpp

1 #include<iostream.h>
2 #include "TemplateDemo03.h"
3 
4 void main(){
5     CeilDemo<double,double> cd;
6     cout<<cd.ceil(2,3.1,4.1)<<endl;
7 }

　　编译错误：

 1 --------------------Configuration: TemplateDemo03 - Win32 Debug--------------------
 2 Compiling...
 3 TemplateDemo03.cpp
 4 g:\c++\cdaima\templatedemo03\templatedemo03.h(12) : 
 5 error C2244: 'CeilDemo<T1,T2,T3>::ceil' : unable to resolve function overload
 6 g:\c++\cdaima\templatedemo03\templatedemo03.cpp(6) : 
 7 error C2065: 'cd' : undeclared identifier
 8 g:\c++\cdaima\templatedemo03\templatedemo03.cpp(6) : 
 9 error C2228: left of '.ceil' must have class/struct/union type
10 Error executing cl.exe.
11 
12 TemplateDemo03.obj - 3 error(s), 0 warning(s)

　　从上面的例子我们可以看出，当我们试图把T2和T3定义为double类型就会出现错误（T1默认定义的是int类型）。那是不是我们按照作者所说把T2和T3也设定为默认值double，是否还会出现错误？看下面的示例：

类模板的默认模板类型形参示例4：

　　TemplateDemo03.h

 1 #ifndef TEMPLATE_DEMO_03
 2 #define TEMPLATE_DEMO_03
 3 
 4 template<class T1=int,class T2=double,class T3=double> class CeilDemo{
 5     public:
 6         double ceil(T1,T2,T3);
 7 };
 8 
 9 template<class T1,class T2,class T3> 
10 double CeilDemo<T1,T2,T3>::ceil(T1 a,T2 b,T3 c){
11     return a+b+c;
12 }
13 
14 #endif

　　TemplateDemo03.cpp

1 #include<iostream.h>
2 #include "TemplateDemo03.h"
3 
4 void main(){
5     CeilDemo<int,double,double> cd;
6     cout<<cd.ceil(2,3.1,4.1)<<endl;
7 }

　　编译错误：

--------------------Configuration: TemplateDemo03 - Win32 Debug--------------------
Compiling...
TemplateDemo03.cpp
g:\c++\cdaima\templatedemo03\templatedemo03.h(12) : 
error C2244: 'CeilDemo<T1,T2,T3>::ceil' : unable to resolve function overload
g:\c++\cdaima\templatedemo03\templatedemo03.cpp(6) : 
error C2065: 'cd' : undeclared identifier
g:\c++\cdaima\templatedemo03\templatedemo03.cpp(6) : 
error C2228: left of '.ceil' must have class/struct/union type
Error executing cl.exe.

TemplateDemo03.obj - 3 error(s), 0 warning(s)

　　从结果我们可以看出，和上例是一样的错误。从实例中我们可以总结如下：类模板如果有多个类型形参，如果使用类型形参默认值则尽量放在参数列表的末尾，而且默认的参数类型必须相同。如果从第一个形参设定了默认值之后的所有模板形参都要设定和第一个形参同类型的默认值。（声明：本人也是刚接触C++，以上只是我经过实例演示对原作者提出的一些质疑，可能我的示例有不到之处，还望大神们不吝赐教，共同完善此博客，给像我一样的菜鸟提供一个学习的平台！）

　　接下来验证“不能为函数模板的类型形参提供默认值”：

类模板的默认模板类型形参示例5：

　　TemplateDemo04.cpp

 1 #include<iostream.h>
 2 
 3 template<class T1,class T2,class T3>
 4 T1 sum(T1 a,T2 b,T3 c=int){
 5     return a+b+c;
 6 } 
 7 
 8 void main(){
 9     cout<<sum<double,double>(1.1,2.1,3)<<endl;
10 }

　　编译错误：

1 --------------------Configuration: TemplateDemo04 - Win32 Debug--------------------
2 Compiling...
3 TemplateDemo04.cpp
4 g:\c++\cdaima\templatedemo04\templatedemo04.cpp(4) : 
5 error C2062: type 'int' unexpected
6 Error executing cl.exe.
7 
8 TemplateDemo04.obj - 1 error(s), 0 warning(s)

　　更改之后的TemplateDemo.cpp

 1 #include<iostream.h>
 2 
 3 template<class T1,class T2,class T3>
 4 T1 sum(T1 a,T2 b,T3 c){
 5     return a+b+c;
 6 } 
 7 
 8 void main(){
 9     cout<<sum<double,short,int>(1.1,3,257)<<endl;
10 }

　　运行结果：　　　261.1　　　　　

　　原作者演示实例如下：

 1 类模板非类型形参示例
 2 //模板的声明或定义只能在全局，命名空间或类范围内进行。即不能在局部范围，函数内进行，比如不能在main函数中声明或定义一个模板。
 3 //类模板的定义
 4 template<class T>class A{public:T g(T a, T b); A();};  //定义带有一个类模板类型形参T的类A
 5 template<class T1,class T2>class B{public:void g();}; //定义带有两个类模板类型形参T1，T2的类B
 6 //定义类模板的默认类型形参，默认类型形参不适合于函数模板。
 7 template<class T1,class T2=int> class D{public: voidg();}; //定义带默认类型形参的类模板。这里把T2默认设置为int型。
 8 //template<class T1=int, class T2>class E{}; //错误，为T1设了默认类型形参则T1后面的所有形参都必须设置认默值。
 9 
10 //以下为非类型形参的定义
11 //非类型形参只能是整型，指针和引用，像double，String, String **这样的类型是不允许的。但是double &，double *对象的引用或指
12 针是正确的。
13 template<class T1,int a> class Ci{public:void g();}; //定义模板的非类型形参，形参为整型
14 template<class T1,int &a>class Cip{public:void g();}; 
15 template<class T1,A<int>* m> class Cc{public:void g();}; //定义模板的模板类型形参，形参为int型的类A的对象的指针。
16 template<class T1,double*a>class Cd{public:void g();};  //定义模板的非类型形参，形参为double类型的引用。
17 class E{}; template<class T1,E &m> class Ce{}; //非类型模板形参为对象的引用。
18 //以下非类型形参的声明是错误的。
19 //template<class T1,A m>class Cc{}; //错误，对象不能做为非类型形参，非类型模板形参的类型只能是对象的引用或指针。
20 //template<class T1,double a>class Cc{}; //错误，非类型模板的形参不能是double类型，可以是double的引用。
21 //template<class T1,A<int> m>class Cc{}; //错误，非类型模板的形参不能是对象，必须是对象的引用或指针。这条规则对于模板型参
22 也不例外。
23 //在类模板外部定义各种类成员的方法，
24 //typeid(变量名).name()的作用是提取变量名的类型，如int a，则cout<<typeid(a).name()将输出int
25 template<class T>   A<T>::A(){cout<<"class A goucao"<<typeid(T).name()<<endl;} //在类模板外部定义类的构造函数的方法
26 template<class T> T A<T>::g(T a,T b){cout<<"class A g(T a,T b)"<<endl;} //在类模板外部定义类模板的成员
27 template<class T1,class T2>  voidB<T1,T2>::g(){cout<<"class g f()"<<typeid(T1).name()<<typeid(T2).name()<<endl;}
28 //在类外面定义类的成员时template后面的模板形参应与要定义的类的模板形参一致
29 template<class T1,int a>     voidCi<T1,a>::g(){cout<<"class Ci g()"<<typeid(T1).name()<<endl;}
30 template<class T1,int &a>    voidCip<T1,a>::g(){cout<<"class Cip g()"<<typeid(T1).name()<<endl;} 
31 //在类外部定义类的成员时，template后的模板形参应与要定义的类的模板形参一致
32 template<class T1,A<int> *m> voidCc<T1,m>::g(){cout<<"class Cc g()"<<typeid(T1).name()<<endl;}
33 template<class T1,double* a> voidCd<T1,a>::g(){cout<<"class Cd g()"<<typeid(T1).name()<<endl;}
34 
35 //带有默认类型形参的模板类，在类的外部定义成员的方法。
36 //在类外部定义类的成员时，template的形参表中默认值应省略
37 template<class T1,class T2>  voidD<T1,T2>::g(){cout<<"class D g()"<<endl;}
38 //template<class T1,class T2=int> void D<T1,T2>::g(){cout<<"class D k()"<<endl;} //错误，在类模板外部定义带有默认类型的形
39 参时，在template的形参表中默认值应省略。
40 //定义一些全局变量。
41 int e=2;  doubleed=2.2; double*pe=&ed;
42 A<int> mw; A<int> *pec=&mw; E me;
43 
44 //main函数开始
45 int main()
46 { // template<class T>void h(){} //错误，模板的声明或定义只能在全局，命名空间或类范围内进行。即不能在局部范围，函数内进行。
47 //A<2> m; //错误，对类模板不存在实参推演问题，类模板必须在尖括号中明确指出其类型。
48 //类模板调用实例
49 A<int> ma; //输出"class A goucao int"创建int型的类模板A的对象ma。
50 B<int,int> mb; mb.g(); //输出"class B g() int int"创建类模板B的对象mb，并把类型形参T1和T2设计为int
51 //非类型形参的调用
52 //调用非类型模板形参的实参必须是一个常量表达式，即他必须能在编译时计算出结果。任何局部对象，局部变量，局部对象的地址，局部
53 变量的地址都不是一个常量表达式，都不能用作非类型模板形参的实参。全局指针类型，全局变量，全局对象也不是一个常量表达式，不能
54 用作非类型模板形参的实参。
55 //全局变量的地址或引用，全局对象的地址或引用const类型变量是常量表达式，可以用作非类型模板形参的实参。
56 //调用整型int型非类型形参的方法为名为Ci，声明形式为template<class T1,int a> class Ci
57 Ci<int,3>//正确，数值R是一个int型常量，输出"class Ci g() int"
58 const int a2=3; Ci<int,a2> mci1; mci1.g(); //正确，因为a2在这里是const型的常量。输出"class Ci g() int"
59 //Ci<int,a> mci; //错误，int型变量a是局部变量，不是一个常量表达式。
60 //Ci<int,e> mci; //错误，全局int型变量e也不是一个常量表达式。
61 //调用int&型非类型形参的方法类名为Cip，声明形式为template<class T1,int &a>class Cip
62 Cip<int,e> mcip;  //正确，对全局变量的引用或地址是常量表达式。
63 //Cip<int,a> mcip1; //错误，局部变量的引用或地址不是常量表达式。
64 //调用double*类型的非类形形参类名为Cd，声明形式为template<class T1,double *a>class Cd
65 Cd<int,&ed> mcd; //正确，全局变量的引用或地址是常量表达式。
66 //Cd<int,pe> mcd1; //错误，全局变量指针不是常量表达式。
67 //double dd=3.3; //错误，局部变量的地址不是常量表达式，不能用作非类型形参的实参
68 //Cd<int,&e> mcd;  //错误，非类型形参虽允许一些转换，但这个转换不能实现。
69 
70 //调用模板类型形参对象A<int> *的方法类名为Cc，声名形式为template<class T1,A<int>* m> class Cc
71 Cc<int,&mw> mcc; mcc.g(); //正确，全局对象的地址或者引用是常量表达式
72 //Cc<int,&ma> mcc;  //错误，局部变量的地址或引用不是常量表达式。
73 //Cc<int,pec> mcc2;  //错误，全局对象的指针不是常量表达式。
74 
75 //调用非类型形参E&对象的引用的方法类名为Ce。声明形式为template<class T1,E &m> class Ce
76 E me1; //Ce<int,me1> mce1; //错误，局部对象不是常量表达式
77 Ce<int,me> mce;  //正确，全局对象的指针或引用是常量表达式。
78 //非类型形参的转换示例，类名为Ci
79 //非类型形参允许从数组到指针，从函数到指针的转换，const修饰符的转换，提升转换，整值转换，常规转换。
80 const short s=3; Ci<int,s> mci4†//正确，虽然short型和int不完全匹配，但这里可以将short型转换为int型

c++中 typename 和 class 的区别

在c++Template中，很多地方都用到了typename与class这两个关键字，而且好像可以替换，是不是这两个关键字完全一样呢?

相信学习C++的人对class这个关键字都非常明白，class用于定义类。在模板引入c++后，最初定义模板的方法为： template<class T>......

在这里class关键字表明T是一个类型，后来为了避免class在这两个地方的使用可能给人带来混淆，所以引入了typename这个关键字。它的作用同
class一样表明后面的符号为一个类型，这样在定义模板的时候就可以使用下面的方式了： template<typename T>......

在模板定义语法中关键字class与typename的作用完全一样。

typename难道仅仅在模板定义中起作用吗？其实不是这样，typename另外一个作用为：使用嵌套依赖类型(nested depended name)，如下所示：

class MyArray 
{ 
public：
    typedef int LengthType;
    .....
}

template<class T>
void MyMethod( T myarr ) 
{ 
    typedef typename T::LengthType LengthType; 
    LengthType length = myarr.GetLength; 
}

这个时候typename的作用就是告诉c++编译器，typename后面的字符串为一个类型名称，而不是成员函数或者成员变量，这个时候如果前面没有typename，编译器没有任何办法知道T::LengthType是一个类型还是一个成员名称（静态数据成员或者静态函数），所以编译不能够通过。

C++ STL简介
　　STL（Standard Template Library，标准模板库)是C++对泛型编程思想的实现，最早是惠普实验室开发的。
在被引入C++之前该技术就已经存在了很长的一段时间。后来STL成为ANSI/ISO C++标准的一部分。各个
C++厂商也有各自相应的模板库，这些库效率可能很高，但可移植性不一定好。
　　STL广义上分为三类：algorithm（算法）、container（容器）和iterator（迭代器），几乎所有的代码都采
用了模板类和模板函数的方式，这相比于传统的由函数和类组成的库来说提供了更好的代码重用机会。
　　在C++标准中，STL被组织为下面的13个头文件：<algorithm>、<deque>、<functional>、<iterator>、<vector>、
<list>、<map>、<memory>、<numeric>、<queue>、<set>、<stack> 和<utility>。
1) 算法（algorithm）
　　STL提供了大约100个实现算法的模版函数，算法部分主要由头文件<algorithm>，<numeric> 和<functional>组成。
　　<algorithm>是所有STL头文件中最大的一个，它是由一大堆模板函数组成的，其中常用到的功能范围涉及到比较、
交换、查找、遍历操作、复制、修改、移除、反转、排序、合并等等。
　　<numeric>体积很小，只包括一些简单数学运算的模板函数。
　　<functional>中则定义了一些模板类，用以声明函数对象。
2) 容器（container）（又称集合collection）
　　在实际的开发过程中，数据结构本身的重要性不会逊于操作于数据结构的算法的重要性，当程序中存在着对时间要
求很高的部分时，数据结构的选择就显得更加重要。
　　通过设置一些模版类，STL容器对最常用的数据结构提供了支持，这些模板的参数允许指定容器中元素的数据类
型，可以将许多重复而乏味的工作简化。
如下表：

数据结构		实现头文件
向量(vector)	顺序性容器	<vector>
列表(list)	顺序性容器	<list>
双队列(deque)	顺序性容器	<deque>
集合(set)	关联容器	<set>
多重集合(multiset)	关联容器	<set>
栈(stack)	容器适配器	<stack>
队列(queue)	容器适配器	<queue>
优先队列(priority_queue)	容器适配器	<queue>
映射(map)	关联容器	<map>
多重映射(multimap)	关联容器	<map>

3)迭代器（iterator）
　　迭代器是一种允许程序员检查容器内元素，并实现元素遍历的数据类型。C++标准库为每一种标准容器定义了一种迭代器类型。迭代器类型提供了比下标操作更一般化的方法：所有的标准库容器都定义了相应的迭代器类型，而只有少数的容器（比如数组）支持下标操作。因为迭代器对所有的容器都适用，现代C++程序更倾向于使用迭代器而不是下标操作访问容器元素。
　　迭代器从作用上来说是STL最基本的部分，迭代器在STL中用来将算法和容器联系起来，起着一种黏和剂的作用。几乎STL提供的所有算法都是通过迭代器存取元素序列进行工作的，每一个容器都定义了其本身所专有的迭代器，用以存取容器中的元素。
　　迭代器部分主要由头文件<utility>,<iterator> 和<memory>组成。<utility>是一个很小的头文件，它包括了贯穿使用在STL中的几个模板的声明，<iterator>中提供了迭代器使用的许多方法， <memory>为容器中的元素分配存储空间，同时也为某些算法执行期间产生的临时对象提供机制,<memory>中的主要部分是模板类allocator，它负责产生所有容器中的默认分配器。