CPP模板学习

2022-01-13

字数统计: 4.3k | 阅读时长≈ 17 分钟

模板是 C++ 支持参数化多态的工具，使用模板可以使用户为类或者函数声明一种一般模式。
C++ 的标准库提供许多有用的函数大多结合了模板的观念，如 STL 以及 IO Stream。

模板是一种对类型进行参数化的工具；通常有两种形式：函数模板和类模板:

函数模板针对仅参数类型不同的函数；
类模板针对仅数据成员和成员函数类型不同的类.

使用模板的目的就是能够让程序员编写与类型无关的代码.

函数模板

 template <typename 形参名，typename 形参名，......> 
 返回类型 函数名(参数列表)

{
      函数体
}

template 和 class 是关键字，class 可以用 typename 关键字代替，在这里 typename 和 class 没区别，
<> 括号中的参数叫模板形参，模板形参和函数形参很相像，模板形参不能为空。
模板形参需要调用该模板函数时提供的模板实参来初始化模板形参
一旦编译器确定了实际的模板实参类型就称他实例化了函数模板的一个实例。

1	template <class T> void swap(T& a, T& b){}，

当调用这样的模板函数时类型T就会被被调用时的类型所代替，比如 swap(a,b) 其中 a 和 b 是 int 型，这时模板函数 swap 中的形参 T 就会被 int 所代替，模板函数就变为 swap(int &a, int &b)。而当 swap(c,d) 其中 c 和 d 是 double 类型时，模板函数会被替换为 swap(double &a, double &b)，这样就实现了函数的实现与类型无关的代码。

注意：对于函数模板而言不存在 h(int,int) 这样的调用，不能在函数调用的参数中指定模板形参的类型，对函数模板的调用应使用实参推演来进行，即只能进行 h(2,3) 这样的调用，或者 int a, b; h(a,b)。

类模板

类模板的格式为：

1 2	template<class 形参名，class 形参名，…> class 类名{ ... };

类模板和函数模板都是以 template 开始后接模板形参列表组成，模板形参不能为空，一但声明了类模板就可以用类模板的形参名声明类中的成员变量和成员函数，即可以在类中使用内置类型的地方都可以使用模板形参名来声明。

template<class T> class A
  {
       public: 
       T a;
       T b; 
       T hy(T c, T &d);
  };

在类 A 中声明了两个类型为T的成员变量 a 和 b，还声明了一个返回类型为 T 带两个参数类型为 T 的函数 hy。

类模板对象的创建：比如一个模板类 A，则使用类模板创建对象的方法为 A m ;在类 A 后面跟上一个 <> 尖括号并在里面填上相应的类型，这样的话类 A 中凡是用到模板形参的地方都会被 int 所代替。当类模板有两个模板形参时创建对象的方法为 A m; 类型之间用逗号隔开。

在类模板外部定义成员函数的方法为：

1	template<模板形参列表> 函数返回类型类名<模板形参名>::函数名(参数列表){函数体}

比如有两个模板形参 T1，T2 的类 A 中含有一个 void h() 函数，则定义该函数的语法为：

1	template<class T1,class T2> void A<T1,T2>::h(){}。

注意：当在类外面定义类的成员时 template 后面的模板形参应与要定义的类的模板形参一致。模板的声明或定义只能在全局，命名空间或类范围内进行。即不能在局部范围，函数内进行，比如不能在 main 函数中声明或定义一个模板。

模板的非类型形参

非类型模板形参：模板的非类型形参也就是内置类型形参，如 template class B{} ; 其中int a就是非类型的模板形参。
非类型形参在模板定义的内部是常量值，也就是说非类型形参在模板的内部是常量。
非类型模板的形参只能是整型，指针和引用，像 double，String, String * 这样的类型是不允许的。但是 double &，double ，对象的引用或指针是正确的。
调用非类型模板形参的实参必须是一个常量表达式，即他必须能在编译时计算出结果
注意：任何局部对象，局部变量，局部对象的地址，局部变量的地址都不是一个常量表达式，都不能用作非类型模板形参的实参。
全局变量的地址或引用，全局对象的地址或引用 const 类型变量是常量表达式，可以用作非类型模板形参的实参。
sizeof 表达式的结果是一个常量表达式，也能用作非类型模板形参的实参。
当模板的形参是整型时调用该模板时的实参必须是整型的，且在编译期间是常量，比如 template class A{}; 如果有 int b，这时 A m;将出错，因为 b 不是常量，如果 const int b，这时 A m; 就是正确的，因为这时 b 是常量。
非类型形参一般不应用于函数模板中，比如有函数模板 template void h(T b){} ，若使用 h(2) 调用会出现无法为非类型形参 a 推演出参数的错误，对这种模板函数可以用显示模板实参来解决，如用 h(2) 这样就把非类型形参 a 设置为整数 3。显示模板实参在后面介绍。
非类型模板形参的形参和实参间所允许的转换:
- 允许从数组到指针，从函数到指针的转换。如：template class A{}; int b[1]; A m;即数组到指针的转换。

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

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

类模板的类型形参默认值形式为：template class A{};为第二个模板类型形参T2提供int型的默认值。

类模板类型形参默认值和函数的默认参数一样，如果有多个类型形参则从第一个形参设定了默认值之后的所有模板形参都要设定默认值，比如

1
template<class T1=int, class T2>class A{};

就是错误的，因为T1给出了默认值，而T2没有设定。

在类模板的外部定义类中的成员时 template 后的形参表应省略默认的形参类型。

1
template<class T1, class T2=int> class A{public: void h();};

定义方法为：

1
template<class T1,class T2> void A<T1,T2>::h(){}

模板实例化

模板的实例化指函数模板（类模板）生成模板函数（模板类）的过程。

对于函数模板而言，模板实例化之后，会生成一个真正的函数。

类模板经过实例化之后，只是完成了类的定义，模板类的成员函数需要到调用时才会被初始化。模板的实例化分为隐式实例化和显示实例化。

C++ 只有模板显式实例化 (explicit instantiation), 隐式实例化 (implicit instantiation) ,特化 (specialization,也译作具体化，偏特化)。

首先考虑如下模板函数代码:

1
2
3
4
5
template <typename T>
void swap(T &a, T &b)
{
...
}

隐式实例化
模板函数不是真正的函数定义，他只是如其名提供一个模板，模板只有在运行时才会生成相应的实例，隐式实例化就是这种情况:

1
2
3
4
5
int main(){
....
swap<int>(a,b);
....
}

它会在运行到这里的时候才生成相应的实例，很显然的影响效率 这里顺便提一下 swap(a,b) ;中的是可选的,因为编译器可以根据函数参数类型自动进行判断,也就是说如果编译器不不能自动判断的时候这个就是必要的。

简介调用函数完成模板实例化

将函数入口地址传给一个函数指针，通过函数指针完成函数调用。如果传递给函数指针不是一个真正的函数，那么编译器就会寻找同名的函数模板进行参数推演，进而完成函数模板的实例化。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
using namespace std;
template <typename T> void func(T t){
cout<<t<<endl;
}

//入参为函数指针
void invoke(void (*p)(int)){
int num=10;
p(num);
}
int main(){
invoke(func);
}

显式实例化
显示实例化也称为外部实例化。在不发生函数调用的时候讲函数模板实例化，或者在不适用类模板的时候将类模板实例化称之为模板显示实例化。

前面已经提到隐式实例化可能影响效率,所以需要提高效率的显式实例化,显式实例化在编译期间就会生成实例,方法如下:

1
template void swap<int>(int &a,int &b);

这样就不会影响运行时的效率，但编译时间随之增加。

函数模板实例化
对于函数模板而言，不管是否发生函数调用，都可以通过显示实例化声明将函数模板实例化，格式为：

1
template [函数返回类型] [函数模板名]<实际类型列表>（函数参数列表）

例如：

1
template void func<int>(const int&);

类模板实例化
对于类模板而言，不管是否生成一个模板类的对象，都可以直接通过显示实例化声明将类模板实例化，格式为：

1
template class [类模板名]<实际类型列表>

例如：

1
template class theclass<int>;

函数模板调用方式
隐式模板实参调用
在发生函数模板的调用时，不显示给出模板参数而经过参数推演，称之为函数模板的隐式模板实参调用（隐式调用）。如：

1
2
3
4
template <typename T> void func(T t){
cout<<t<<endl;
}
func(5);//隐式模板实参调用

显示模板实参调用
在发生函数模板的调用时，显示给出模板参数而不需要经过参数推演，称之为函数模板的显示模板实参调用（显示调用）。

显示模板实参调用在参数推演不成功的情况下是有必要的。考察如下程序。

1
2
3
4
5
6
7
8
9
10
11
#include <iostream>
using namespace std;
template <typename T> T Max(const T& t1,const T& t2){
return (t1>t2)?t1:t2;
}

int main(){
int i=5;
//cout<<Max(i,'a')<<endl; //无法通过编译
cout<<Max<int>(i,'a')<<endl; //显示调用，通过编译
}

直接采用函数调用Max(i,’a’)会产生编译错误，因为i和’a’具有不同的数据类型，无法从这两个参数中进行类型推演。而采用Max< int>(i,’a’)调用后，函数模板的实例化不需要经过参数推演，而函数的第二个实参也可以由char转换为int型，从而成功完成函数调用。

编程过程中，建议采用显示模板实参的方式调用函数模板，这样提高了代码的可读性，便于代码的理解和维护。

特化
这个 swap 可以处理一些基本类型如 long int double ,但是如果想处理用户自定义的类型就不行了,特化就是为了解决这个问题而出现的:

1
template <> void swap<job>(job a,job b){...}

模板的特化（具体化）和偏特化
类模板

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
#include <iostream>
using namespace std;
template<typename T1,typename T2>
class Test{
public:
Test(T1 i,T2 j):a(i),b(j){cout<<"模板类"<<endl;}
private:
T1 a;
T2 b;
};
template<> //全特化，由于是全特化，参数都指定了，参数列表故为空。
class Test<int ,char>{
public:
Test(int i,char j):a(i),b(j){cout<<"全特化"<<endl;}
private:
int a;
int b;
};
template<typename T2> //由于只指定了一部分参数，剩下的未指定的需在参数列表中，否则报错。
class Test<char,T2>{
public:
Test(char i,T2 j):a(j),b(j){cout<<"个数偏特化"<<endl;}
private:
char a;
T2 b;
};
template<typename T1,typename T2> //这是范围上的偏特化
class Test<T1*,T2*>{
public:
Test(T1* i,T2* j):a(i),b(j){cout<<"指针偏特化"<<endl;}
private:
T1* a;
T2* b;
};
template<typename T1,typename T2>//同理这也是范围上的偏特化
class Test<T1 const,T2 const>{
public:
Test(T1 i,T2 j):a(i),b(j){cout<<"const偏特化"<<endl;}
private:
T1 a;
T2 b;
};
int main()
{
int a;
Test<double,double> t1(0.1,0.2);
Test<int,char> t2(1,'A');
Test<char,bool> t3('A',true);
Test<int*,int*> t4(&a,&a);
Test<const int,const int> t5(1,2);
return 0;
}

结果：

函数模板

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
#include <iostream>
using namespace std;
//模板函数
template<typename T1,typename T2>
void fun(T1 a,T2 b){
cout<<"模板函数"<<endl;
}
//全特化
template<>
void fun(int a,char b){
cout<<"全特化"<<endl;
}
//函数不存在偏特化，以下代码是错误的
/*
template<typename T2>
void fun(char a,T2 b){
cout<<"偏特化"<<ednl;
}
*/
int main()
{
int a=0;
char b='A';
fun(a,a);
fun(a,b);
return 0;
}

结果：

模板类的继承
模板类的继承包括四种：：

1、普通类继承模板类）

2、（模板类继承了普通类（非常常见））

3、类模板继承类模板

4、模板类继承类模板，即继承模板参数给出的基类

其中，普通类继承模板类比较简单，如：

1
2
3
4
5
6
7
8
template<class T>
class TBase{
T data;
……
};
class Derived:public TBase<int>{
……
};

模板类继承普通类：

1
2
3
4
5
6
7
8
class TBase{
……
};
template<class T>
class TDerived:public TBase{
T data;
……
};

类模板继承类模板：

1
2
3
4
5
6
7
8
9
10
template<class T>
class TBase{
T data1;
……
};
template<class T1,class T2>
class TDerived:public TBase<T1>{
T2 data2;
……
};

模板类继承模板参数给出的基类 ——继承哪个基类由模板参数决定：

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
#include<iostream>
using namespace std;

class BaseA{
public:
BaseA(){cout<<"BaseA founed"<<endl;}
};

class BaseB{
public:
BaseB(){cout<<"BaseB founed"<<endl;}
};

template<typename T, int rows>
class BaseC{
private:
T data;
public:
BaseC():data(rows){
cout<<"BaseC founed "<< data << endl;}
};

template<class T>
class Derived:public T{
public:
Derived():T(){cout<<"Derived founed"<<endl;}
};

void main()
{
Derived<Base A> x;// BaseA作为基类
Derived<Base B> y;// BaseB作为基类
Derived<Base C<int, 3> > z; // BaseC<int,3>作为基类
}

模板实例化问题
在我们使用类模板时，只有当代码中使用了类模板的一个实例的名字，而且上下文环境要求必须存在类的定义时，这个类模板才被实例化：

声明一个类模板的指针和引用，不会引起类模板的实例化，因为没有必要知道该类的定义

定义一个类类型的对象时需要该类的定义，因此类模板会被实例化

在使用 sizeof() 时，它是计算对象的大小，编译器必须根据类型将其实例化出来，所以类模板被实例化.

new 表达式要求类模板被实例化。

引用类模板的成员会导致类模板被编译器实例化

需要注意的是，类模板的成员函数本身也是一个模板。标准 C++ 要求这样的成员函数只有在被调用或者取地址的时候，才被实例化。用来实例化成员函数的类型，就是其成员函数要调用的那个类对象的类型。

版权声明： 本博客所有文章除特别声明外，著作权归作者所有。转载请注明出处！

分享



扫一扫，分享到微信

C++

上一篇
CPP智能指针理解
 下一篇
CPP嵌套从属名称与typename