函数模板

1.函数模板

函数模板为通用函数的描叙。

(1)模板函数不能缩短可执行的程序，仍将使用独立的函数定义。但是模板函数更加简单可靠

(2)可以重载函数模板，和一般重载一样，要求函数特征标（参数表相异），且能够参数表包含非模板参数如int等

(3)模板属于编译时多态性，因为编译时自动根据模板生成模板函数。函数重载也是编译多态性。只有虚函数为运行多态。

2.显式具体化

即提供模板的函数的某些具体化版本，当编译器找到与函数调用匹配的具体化定义时，将使用该定义而不是模板。例如定义交换函数swap()，交换普通元素和结构体元素，但是要求结构体元素只要求交换部分数据域，如下：

struct job{
double salary;
int rank;
}

template<tyname T>
void swap(const T&,const T&);//通用版本
template<> void swap<job>(const job&,const job& );//显式具体化版本

template<tyname T>
void swap(const T& a,const T& b)//通用版本
{
T temp=a;
a=b;
b=temp;
}
template<> void swap<job>(const job& a,const job& b)//显式具体化版本,并不交换所有部分
{
double temp=a.salary;
a.salary=b.salary;
b.salary=temp;
}
void main(){
int i=0,j=1;
swap(i,j);//(i=1,j=0)
.......................
job a={1000.00,1};
job b={2000.00,2}
swap(a,b);//(仅仅salary部分交换)
......................
}

3.编译器选择函数版本的规则

(1)完全匹配，但是匹配优先度：普通函数>显式具体化函数>模板函数

(2)提升转换匹配（char short转为int, long转为doubel）

(3)标准转换匹配（int 到 char, long 到double）

(4)用户自定义转换。即下文的显式实例化。

此时应注意，const与非const的区别只存在于指针和引用类型。也就是说，func(int),function(const int)具有相同的匹配等级。若func(int)被最优匹配，则后者也是最优匹配，此时会出现二义性。然后，对于最优匹配的参数表含有指针或者参数的情况，不会出现此种情况。

编译时，编译器倾向选择最具体且需要最少转换的函数。当然，也可以通过人为指定合适的调用，引导编译器。如：

template<tyname T>
T  less(const T& a,const T& b);//#1
{
return a<b?:a,b;
}
int less(int a,int b)//#2
{
return a<b?:a,b;
}
main(){
int i=0,j=1;
double m=1.0,n=2.0;

less(i,j);//#1
less(m,n);//#2
less<>(i,j);//#1,“<>”引导编译，要求使用模板函数匹配
less<int>(m,n);//#1,显式实例化，m、n被强制转换
}

4.非类型参数模板

只有运行时，细节才被真正的确定。但是在这里，处理的细节不是类型，当要使用基于值的模板时，必须显式地指定这些值，才能够对模板进行实例化。。非类型模板参数(Nontype Template Parameters)只能是整数类型, 指针, 引用。整型必须是常量表达式(constant expression), 指针和引用必须指向静态类型。

4.1类中的非参数类型模板

例如定义一个大小事先确定的stack类：

#include<stdexcept>
#include<iostream>
using namespace std;

template<typename T, int MAXSIZE>
class Stack{
private:
T elems[MAXSIZE];
int numElems;
public:
Stack();
void push(T const&);
void pop();
T top() const;
bool empty() const {
return numElems == 0;
}
bool full() const {
return numElems == MAXSIZE;
}
};

template<typename T, int MAXSIZE>
Stack<T, MAXSIZE>::Stack():numElems(0) {}

template<typename T, int MAXSIZE>
void Stack<T, MAXSIZE>::push(T const& elem)
{
if(numElems == MAXSIZE) {
throw out_of_range("Stack<>::push(): stack is full");
}
elems[numElems] = elem;
++numElems;
}

template<typename T, int MAXSIZE>
void Stack<T, MAXSIZE>::pop()
{
if(numElems <= 0) {
throw out_of_range("Stack<>::pop(): stack is empty");
}
--numElems;
}

template<typename T, int MAXSIZE>
T Stack<T, MAXSIZE>::top() const
{
if(numElems <= 0) {
throw out_of_range("Stack<>::top(): stack is empty");
}
return elems[numElems - 1];
}

使用：

#include<iostream>
#include<vector>
#include<deque>
#include<stdexcept>
#include<string>
#include<cstdlib>
#include "stack4.h"
using namespace std;

int main()
{
try {
Stack<int, 20> int20Stack;
Stack<int, 40> int40Stack;
Stack<string, 40> stringStack;

int20Stack.push(7);
cout<<int20Stack.top()<<endl;
int20Stack.pop();

stringStack.push("hello");
cout<<stringStack.top()<<endl;
stringStack.pop();
stringStack.pop();
}
catch(exception const& ex) {
cerr<<"Exception: "<<ex.what()<<endl;
//return EXIT_FAILURE;
}

cin.get();
return 0;
}

4.2函数中的非类型参数模板

例如求数组大小模板函数：

template<unsigned int N,typename T>
int coute(T (&a)
){
return sizeof(a)/sizeof(a[0]);
}

4.3非类型参数模板函数的限制

（1）只能是int，指针或者引用，不能是float或者double，或者类对象之类。例如：

template<double VAT>
double process(double v) //error
{
return V * VAT;
}

template<string name>  //error
class MyClass {
...
};

（2）使用全局指针作为模板参数，即extern类型的常量类型：

5.模板函数的使用要点

① 如果在全局域中声明了与模板参数同名的对象函数或类型，则被隐藏。在下面的例子中tmp 的类型不是double 是模板参数Type。

typedef double Type;
template <class Type>
Type min( Type a, Type b )
{
// tmp 类型为模板参数 Type，不是全局 double
Type tmp = a < b ? a : b;
return tmp;
}

② 在函数模板定义中声明的对象或类型，不能与模板参数同名。

template <class Type>
Type min( Type a, Type b )
{
typedef double Type; // 错误: 重新声明模板参数 Type
Type tmp = a < b ? a : b;
return tmp;
}

③ 返回类型也可是模板类型参数

template <class T1, class T2, class T3>
T1 min( T2, T3 );

④同一模板参数表必须使用不一样的参数名，但是相异的模板参数表可以使用相同的参数名

// 错误: 模板参数名 Type 的非法重复使用
template <class Type, class Type>
Type min( Type, Type );

//正确: 名字 Type 在不同模板之间重复使用
template <class Type>
Type min( Type, Type );
template <class Type>
Type max( Type, Type );

⑤函数模板也可以被声明为inline 或extern 应该把指示符放在模板参数表后面而不是在关键字template 前面。

template <typename Type> inline
Type min( Type, Type );