2020.9.8C++Primer学习笔记————模板函数

C++Primer学习笔记————模板函数

看C++Primer看到了第十章函数模板部分，其中提到了模板函数用法，帮助强类型语言减少简单方法的代码量。

C++是强类型语言，在调用方法时需要对传参有严格的判断，例如实现一个简单的大小判断方法时：

int min( int a, int b ) { 
 return a < b ? a : b; 
} 
double min( double a, double b ) { 
 return a < b ? a : b; 
}
1
2
3
4
5
6

想要对比不同类型的参数需要不同的方法，使得一个简单的方法需要重复定义好几次。
而想要一次编写代替多个重复方法，使用宏定义扩展在某些情况下可以实现，但同时也可能导致结果出错，例如：

#include <iostream> 
#define min(a,b) ((a) < (b) ? (a) : (b)) 


int main() { 
 const int size = 10; 
 int ia[size]; 
 int elem_cnt = 0; 
 int *p = &ia[0]; 
 // 计数数组元素的个数
 while ( min(p++,&ia[size]) != &ia[size] ) 
 ++elem_cnt; 
 cout << "elem_cnt : " << elem_cnt 
 << "\texpecting: " << size << endl; 
 return 0; 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在这个demo中，因为实参操作p++的存在，最后输出的结果会变成
elem_cnt : 5 expecting: 10
实际count次数只有size的一半，因为应用在指针实参 p 上的后置递增操作随每次扩展而被应用了两次，一次是在 a 和 b 的测试中 另一次是在宏的返回值被计算期间。

模板函数：

函数模板提供了一种机制，通过它我们可以保留函数定义和函数调用的语义。在一个程序位置上封装了一段代码，确保在函数调用之前实参只被计算一次，而无需像宏方案那样绕过 C++的强类型检查。
函数模板提供一个种用来自动生成各种类型函数实例的算法，程序员对于函数接口参数和返回类型中的全部或者部分类型进行参数化 parameterize，而函数体保持不变。

上面是摘自C++Primer，总结下来就是将方法的参数类型（而非参数）进行参数化，将 int ，double 等参数类型也当成参数传入方法。
这种函数模板最适合要传入多个同参数类型的参数时，例如：

template <class Type> 
Type min( Type a, Type b ) { 
 return a < b ? a : b; 
} 

int main() { 
 // ok: int min( int, int ); 
 min( 10, 20 ); 
 // ok: double min( double, double ); 
 min( 10.0, 20.0 );
 }
1
2
3
4
5
6
7
8
9
10
11

也可以有不同的参数类型传入，有几个参数类型就声明几个Type：

template <class TypeA, class TypeB> 
TypeB plus( TypeA a, TypeB b ) { 
 return b + a;
} 

int main() { 
 // ok: float plus( int, float ); 
 plus( 10, 20.5 ); 
 }
1
2
3
4
5
6
7
8
9

还可以在模板函数中声明模板非类型参数，其代表一个常量表达式，例如：

template <class Type, int size> 
Type min( const Type (&r_array)[size] ) 
{ 
 /* 找到数组中元素最小值的参数化函数 */ 
 Type min_val = r_array[0]; 
 for ( int i = 1; i < size; ++i ) 
 if ( r_array[i] < min_val ) 
 min_val = r_array[i]; 
 return min_val; 
}
1
2
3
4
5
6
7
8
9
10

其中 size 就是一个 int 类型的常量。

声明冲突：

如果在全局域中声明了与模板参数同名的对象，函数或类型，则该全局名将被隐藏。

typedef double Type; 
template <class Type> 
Type min( Type a, Type b ) 
{ 
 // tmp 类型为模板参数 Type 
 // 不是全局 typedef 
 Type tmp = a < b ? a : b; 
 return tmp; 
}
1
2
3
4
5
6
7
8
9

如上，即模板参数覆盖全局变量。

在函数模板定义中声明的对象或类型不能与模板参数同名，模板类型参数名可以被用来指定函数模板的返回类型。

引入关键字typename：

在函数模板声明中，如传入的参数是一个类的实体：

class PARM{
public:
 char *name;
...
}

PARM Parm;

template <class Parm, class U> 
 Parm minus( Parm* array, U value ) 
{ 
 Parm::name * p; // 这是一个指针声明还是乘法 乘法
}
1
2
3
4
5
6
7
8
9
10
11
12
13

类型Parm要在实例化时才知道他是一个类的实体，Parm::name * p模板函数声明时才是一个指针，对于模板函数内部的定义来说这个 * 代表乘法。
所以这个时候需要引入 typename 关键字来确定变量到底是指针还是一个类内属性：

template <class Parm, class U> 
 Parm minus( Parm* array, U value ) 
{ 
 typename Parm::name * p; // ok: 指针声明
}
1
2
3
4
5

函数模板也可以被声明为 inline 或 extern 形式，但是修饰符需要放在函数名前而不是 template 前。

// ok: 关键字跟在模板参数表之后
template <typename Type> 
 inline 
 Type min( Type, Type ); 
// 错误: inline 指示符放置的位置错误
inline 
template <typename Type> 
 Type min( Array<Type>, int );
1
2
3
4
5
6
7
8

函数模板实例化：

模板函数的声明在被调用时会隐式的进行模板实例化，根据传入的参数生成独立的函数，过程是隐式的。
用函数实参的类型来决定模板实参的类型和值的过程被称为模板实参推演。

template <typename Type, int size> 
 Type min( Type (&p_array)[size] ) { /* ... */ } 
// pf 指向 int min( int (&)[10] ) 
int (*pf)(int (&)[10]) = &min;
1
2
3
4

指针 pf 被函数模板实例的地址初始化，编译器通过检查 pf 指向的函数的参数类型来决定模板实例的实参。
pf 的类型是指向函数的指针，该函数有一个类型为 int(&)[10]的参数，当 min()被实例化时，该参数的类型决定了 Type 的模板实参的类型和 size 的模板实参的值。Type 的模板实参为 int，size 的模板实参为 10，被实例化的函数是 min(int(&)[10]) ，指针 pf 指向这个模板实例。

在取函数模板实例的地址时，必须能够通过上下文环境为一个模板实参决定一个惟一的类型或值。如果不能决定出这个惟一的类型或值，就会产生编译时刻错误：

template <typename Type, int size> 
 Type min( Type (&r_array)[size] ) { /* ... */ } 
typedef int (&rai)[10]; 
typedef double (&rad)[20]; 
void func( int (*)(rai) ); 
void func( double (*)(rad) ); 
int main() { 
 // 错误: 哪一个 min() 的实例? 
 func( &min ); 
}
1
2
3
4
5
6
7
8
9
10

这里func（）不知道该取 int 型 min 函数的地址还是 double 型函数的地址，需要用一个强制类型转换显式地指出实参的类型则可以消除编译时刻错误：

int main() { 
 // ok: 强制转换指定实参类型
 func( static_cast< double(*)(rad) >(&min) ); 
}
1
2
3
4

模板实参推演：

当函数模板被调用时，对函数实参类型的检查决定了模板实参的类型和值，这个过程被称为模板实参推演。

函数模板 min()的函数参数是一个引用，它指向了一个 Type 类型的数组，为了匹配函数参数，函数实参必须也是一个表示数组类型的左值。下面的调用是个错误，因为 pval 是 int*类型而不是 int 数组类型的左值：

template <class Type, int size> 
 Type min( Type (&r_array)[size] ) { /* ... */ }

void f( int pval[9] ) { 
 // 错误: Type (&)[] != int* 
 int jval = min( pval ); 
}
1
2
3
4
5
6
7

想正确传入数组参数，我自己尝试的方法：

int f(int pval[9]) {
	int ia[9];
	memcpy(ia, pval, 9*(sizeof(int)));
	int jval = min(ia);
	return jval;
}
1
2
3
4
5
6

要想成功地进行模板实参推演，函数实参的类型不一定要严格匹配相应函数参数的类型。
下列三种类型转换是允许的：左值转换，限定转换和到一个基类（该基类根据一个类模板实例化而来）的转换。