第3章 模 板
使用模板可以建立具有通用类型的函数库或类库,为一系列逻辑功能相同而数据类型
不同的函数或类创建框架。模板提供了一种重用程序源代码的有效方法,使大规模软件开
发更加方便。
3.1 模板的概念
模板的本质就是将所处理的数据类型说明为参数,是对具有相同特性的函数或类的再
抽象。它将程序处理的数据类型参数化,可使一段程序代码处理多种不同类型的数据。
C++程序由类和函数组成,类对应类模板,函数对应函数模板。
为了更好地理解,先来考察3个Swap()函数,是如何交换两个整型数、两个单精度实型
数以及两个双精度实型数的。这3个Swap()函数的功能完全一样,只是所处理的数据类型
不同,下面是这3个函数的具体实现: 
void Swap(int &x,int &y) //交换整型数x、y 
{ 
int temp=x; x=y; y=temp; //通过循环赋值交换x、y 
}
void Swap(float &x,float &y) //交换单精度实型数x、y 
{ 
float temp=x; x=y; y=temp; //通过循环赋值交换x、y 
}
void Swap(double &x,double &y) //交换双精度实型数x、y 
{ 
double temp=x; x=y; y=temp; //通过循环赋值交换x、y 
}
上面通过函数重载虽然能让Swap()函数处理多种类型的数据,但不是任意的,只能交
换一对相同类型的数据。最好的解决方法是将类型参数化后得到函数模板。使用函数模板
定义如下: 
template <class Type> //此处的class 不是定义类的标识,只表明Type 是一个类型参数
void Swap(Type &x,Type &y) //交换x、y 
{ 
Type temp=x; x=y; y=temp; //通过循环赋值交换x、y 
}
这样得到可以将任意一种类型Type的两个数据进行互换的函数模板。
·75·

下面的3个类Integer、Float和Double分别用来处理整型数、单精度实型数以及双精
度实型数。这3个类的处理功能完全一样,只是处理的数据类型不同,下面是这3个类的
声明: 
//声明整型类
class Integer 
{p
rivate: 
//数据成员 
int num; //数据值
public: 
//公有函数 
Integer(int n=0): num(n){ } //构造函数
void Set(int n) { num=n; } //设置数据值
int Get() const { return num; } //返回数据值
}; 
//声明单精度实型数类
class Float 
{p
rivate: 
//数据成员 
float num; //数据值
public: 
//公有函数 
Float(float n=0): num(n){ } //构造函数
void Set(float n) { num=n; } //设置数据值
float Get() const { return num; } //返回数据值
}; 
//声明双精度实型数类
class Double 
{p
rivate: 
//数据成员 
double num; //数据值
public: 
//公有函数 
Double(double n=0): num(n){ } //构造函数
void Set(double n) { num=n; } //设置数据值
double Get() const { return num; } //返回数据值
}; 
·76·

上面实现的3个类的功能相同,只是处理的数据类型不同,都不能处理任意类型的数
据,但采用类型参数化后就可以处理任何类型的数据,这样就得到了类模板。使用类模板定
义如下: 
template <class Type> 
class Number 
{
private: 
//数据成员 
Type num; //数据值
public: 
//公有函数 
Number(Type n=0): num(n){} //构造函数
void Set(Type n) { num=n; } //设置数据值
Type Get() const { return num; } //返回数据值
}; 
注意:函数模板或类模板是对一组函数或类的描述,模板是一种由通用代码构成,使用
类型参数产生一组函数或类的机制。
3.2 函数模板及模板函数
函数模板是对一批功能相同的函数的说明,它不是某一个具体的函数,而是带有类型参
数的一种描述。模板函数是将函数模板内的数据类型参数取某一个具体的数据类型后得到
的具体函数。
3.2.1 函数模板的声明及生成模板函数
使用函数模板的方法是先声明函数模板,然后将其类型参数具体化,形成相应的模板函
数后,才能调用模板函数。
函数模板的一般声明格式如下。
格式1: 
template <class 类型参数名1, class 类型参数名2, …> 
返回值类型函数模板名(形参表) 
{ 
… //函数模板体
}
格式2: 
template <typename 类型参数名1, typename 类型参数名2, …> 
返回值类型函数模板名(形参表) 
{ 
·77·

… //函数模板体
} 
其中,template是一个声明模板的关键字,class在此处并不表示类,只是借用此关键字表示
其后是一个类型参数。“class类型参数名1,class类型参数名2,…”称为类型形参表,类
型参数名可以用任何实际的类型(包括类类型)进行具体化(也称为实例化)得到模板函数。
class和typename的作用相同,都是表示类型名,二者可以互换。大部分C++ 程序员
都喜欢用class,这是因为class更容易输入,typename是新加入标准C++ 中的,使用
typename时,含义非常清楚。
在使用函数模板时,用实际的数据类型具体化(实例化)类型形式参数,再根据实际参数
类型生成一个具体的模板函数,模板函数的函数体与函数模板的函数模板体完全相同,在程
序中真正执行的代码是模板函数的代码。
在使用函数模板生成模板函数时,有两种使用方式。
方式1: 
函数模板名(实参表) 
方式2: 
函数模板名<类型1, 类型2, …>(实参表) 
方式1将根据实参类型确定类型形式参数的具体类型,方式2中,“<类型1,类型2,…>” 
称为类型实参表,用类型实参表中的类型来确定类型形式参数的具体类型。
说明:类型形参表与类型实参表通常只包含一个类型,这时函数模板的一般声明格式
如下。格
式1: 
template <class 类型参数名> 
返回值类型函数模板名(形参表) 
{ 
… //函数模板体
}
格式2: 
template <typename 类型参数名> 
返回值类型函数模板名(形参表) 
{ 
… //函数模板体
}
使用函数模板生成模板函数的两种方式。
方式1: 
函数模板名(实参表) 
方式2: 
·78·

函数模板名<类型> (实参表) 
例3.1 函数模板的声明与模板函数的调用示例,程序演示见3011.mp4~3013.mp4。 
//文件路径名:e3_1\main.cpp 
#include <iostream> //编译预处理命令
using namespace std; //使用命名空间std 
template <class Type> 
Type Max(Type x,Type y) //求x、y 的最大值
{ 
return x<y? y:x; //返回x、y 的最大值
}
int main() //主函数main() 
{ 
cout<<"2 和3 的最大值为"<<Max(2, 3)<<endl; //输出2、3 的最大值
//cout<<"2 和3.0 的最大值为"<<Max(2, 3.0)<<endl; 
//错,无法根据2 和3.0 确定类型形式参数的具体类型
cout<<"2 和3.0 的最大值为"<<Max<int>(2, 3.0)<<endl; //输出2、3.0 的最大值
return 0; //返回值0, 返回操作系统
}
程序运行时屏幕输出如下: 
2 和3 的最大值为3 
2 和3.0 的最大值为3 
从上面的例题可以看出,采用方式1使用函数模板生成模板函数时,同一模板类型参数
的各参数之间必须保持完全一致的类型。
3.2.2 重载函数模板
模板函数类似于重载函数,但是同一个函数模板类型形式参数具体化(实例化)后的所
有模板函数必须执行相同的代码,而函数重载时在每个函数体中可以执行不同的代码,当遇
到执行的代码不同时,不能简单地套用函数模板,而应像重载普通函数那样进行重载。
重载函数模板后,编译器首先匹配类型完全相同的函数,如果匹配失败,再寻求函数模
板进行匹配。
例3.2 重载函数模板与匹配过程示例,程序演示见3021.mp4~3023.mp4。
·79·

//文件路径名:e3_2\main.cpp 
#include <iostream> //编译预处理命令
#include <string.h> //编译预处理命令
using namespace std; //使用命名空间std 
template<class Type> 
Type Max(Type x,Type y) //求x、y 的最大值
{ 
return x<y? y:x; //返回x、y 的最大值
}
char *Max(char *str1, char *str2) //求str1、str2 的最大值
{ 
return strcmp(str1, str2)<0 ? str2 : str1; //返回str1、str2 的最大值
}
int main() //主函数main() 
{ 
cout<<"2 和3 的最大值为"<<Max(2, 3)<<endl; //输出2、3 的最大值, 匹配函数模板
cout<<"China 与American 的最大值为"<<Max("China", "American")<<endl; 
//输出"China","American"的最大值, 匹配函数
return 0; //返回值0, 返回操作系统
}
程序运行时屏幕输出如下: 
2 和3 的最大值为3 
China 与American 的最大值为China 
char*Max(char*str1,char*str2)函数中的函数名与函数模板的函数模板名相同, 
但操作代码不同,函数体中的比较采用了字符串比较函数,所以要用重载的方法把它们区分
开,遵循的原则是首选函数名、参数类型都匹配的函数,再找模板。本例在调用Max(2,3) 
函数时,由于实参是整型,与char*Max(char*str1,char*str2)函数的形参类型不匹
配,因此只能匹配函数模板,在调用Max("China","American")函数时,实参为字符串,与
char*Max(char*str1,char*str2)函数的形参类型相匹配,因此匹配此函数。
例3.3 重载函数模板示例,程序演示见3031.mp4~3033.mp4。 
·80·

//文件路径名:e3_3\main.cpp 
#include <iostream> //编译预处理命令
using namespace std; //使用命名空间std 
template <class Type> 
Type Max(Type x,Type y) //求x、y 的最大值
{ 
return x<y? y:x; //返回x、y 的最大值
}
template <class Type> 
Type Max(Type x,Type y,Type z) //求x、y、z 的最大值
{ 
Type m=x<y? y:x; //m 为x、y 的最大值
m=m<z? z:m; //m、z 的最大值
return m; //返回最大值
}
template <class Type> 
Type Max(Type a[], int n) //求a[0],a[1],…,a[n-1]的最大值
{ 
Type m=a[0]; //假设a[0]为最大值
for (int i=1; i<n; i++) 
if (m<a[i]) m=a[i]; //如a[i]更大,则将a[i]赋值给m 
return m; //返回最大值
}
int main() //主函数main() 
{ 
int a[]={1,9,7,5,6,3}; //定义数组a 
cout<<"数组a 的最大元素值为"<<Max(a,6)<<endl; //输出数组a 的最大元素值
cout<<"2 和3 的最大值为"<<Max(2,3)<<endl; //输出2、3 的最大值
cout<<"2,3 和8 的最大值为"<<Max(2,3,8)<<endl; //输出2、3、8 的最大值
return 0; //返回值0, 返回操作系统
}
程序运行时屏幕输出如下: 
数组a 的最大元素值为9 
2 和3 的最大值为3 
2,3 和8 的最大值为8 
本例中根据实参的个数与类型来匹配不同的函数模板。
3.3 类模板及模板类
类模板与函数模板类似,它可以为任意数据类型定义一种类模板,使用不同的数据类型
具体化(实例化)类模板生成具体的模板类,模板类可以用于生成具体的对象。
·81·

3.3.1 类模板的声明及生成模板类
声明一个类模板与声明函数模板的格式类似,必须以关键字template开始,类模板的
一般声明形式如下。
形式1: 
template <class 类型参数名1, class 类型参数名2, … > 
class 类模板名
{ 
… //类模板体
}; 
形式2: 
template <typename 类型参数名1, typename 类型参数名2, … > 
class 类模板名
{ 
… //类模板体
}; 
类模板的成员函数模板不但可以在类模板体内定义,也可以在类模板体外定义。在类
模板体内定义时,与一般类的成员函数的定义方法完全一样;在类模板体外定义时,需要采
用下面的形式。
形式1: 
template <class 类型参数名1, class 类型参数名2, … > 
返回值类型类模板名<类型参数名1, 类型参数名2, … >::成员函数模板名(形参表) 
{ 
… //成员函数模板体
}
形式2: 
template <typename 类型参数名1, typename 类型参数名2, … > 
返回值类型类模板名<类型参数名1, 类型参数名2, … >::成员函数名(形参表) 
{ 
… //成员函数模板体
} 
其中,“class类型参数名1,class类型参数名2,…”与“typename类型参数名1,typename 
类型参数名2,…”为类型形参表,与函数模板中的类型形参表意义一样。
类模板必须用实际的数据类型具体化(实例化)类型形式参数,再根据实际参数类型,生
成一个具体的模板类,然后才能用来定义具体对象。一般语法格式如下: 
类模板名<类型1, 类型2, … >对象名; 
例3.4 使用类模板的示例,程序演示见3041.mp4~3043.mp4。
·82·

//文件路径名:e3_4\main.cpp 
#include <iostream> //编译预处理命令
using namespace std; //使用命名空间std 
//声明数组类模板
template <class Type> 
class Array 
{p
rivate: 
//数据成员 
Type *elem; //存储数据元素值 
int size; //数组元素个数
public: 
//公有函数模板 
Array(int sz): size(sz) { elem=new Type[size]; } //构造函数
~ Array(){ delete elem; } //析构函数
void SetElem(Type e, int i); //设置元素值
Type GetElem(int i) const; //求元素值
}; 
template<class Type> 
void Array <Type>::SetElem(Type e,int i) //设置元素值
{ 
if (i<0||i>=size) 
{ 
cout<<"元素位置错!"<<endl; 
exit(1); //退出程序的运行,返回到操作系统
}e
lem[i]=e; //设置元素值为e 
}
template<class Type> 
Type Array<Type >::GetElem(int i) const //求元素值
{ 
if (i<0||i>=size) 
{ 
cout<<"元素位置错!"<<endl; 
exit(2); //退出程序的运行,返回到操作系统
}r
eturn elem[i]; //返回元素值elem[i] 
}
int main() //主函数main() 
{ 
·83·

int a[]={1,9,7,5,6,3}; //定义数组a 
int n=6; //数组元素个数
Array <int> obj(n); //定义数组对象
int i; //定义临时变量
for (i=0; i<n; i++) 
obj.SetElem(a[i],i); //设置数组元素值
for (i=0; i<n; i++) 
cout<<obj.GetElem(i)<<" "; //输出元素值
cout<<endl; //换行
return 0; //返回值0, 返回操作系统
}
程序运行时屏幕输出如下: 
1 9 7 5 6 3 
怎样选择是将成员函数在类模板体内定义还是在类模板体外定义呢? 建议对函数模板
体实现较简单、行数较少的类模板的成员函数模板都在类模板体内定义;对函数模板体实现
较复杂、行数较多的类模板的成员函数模板在类模板体外定义。
3.3.2 在类型形参表中包含常规参数的类模板
在声明类模板的类型形参表中还可以包含常规参数,常规参数经常是数值。对类模板
进行具体化(实例化)为模板类时,给这些参数所提供的表达式必须是常量表达式。
例3.5 使用在类型形参表中包含常规参数的示例,程序演示见3051.mp4~3053.mp4。 
//文件路径名:e3_5\main.cpp 
#include <iostream> //编译预处理命令
using namespace std; //使用命名空间std 
//声明数组类模板
template <class Type,int size> 
class Array 
{p
rivate: 
//数据成员 
Type elem[size]; //存储数据元素值
public: 
//公有函数模板 
void SetElem(Type e,int i); //设置元素值
·84·

Type GetElem(int i) const; //求元素值
}; 
template <class Type, int size> 
void Array <Type,size>::SetElem(Type e,int i) //设置元素值
{ 
if (i<0||i>=size) 
{ 
cout<<"元素位置错!"<<endl; 
exit(1); //退出程序的运行,返回到操作系统
}e
lem[i]=e; //设置元素值为e 
}
template <class Type,int size> 
Type Array <Type, size>::GetElem(int i) const //求元素值
{ 
if (i<0||i>=size) 
{ 
cout<<"元素位置错!"<<endl; 
exit(2); //退出程序的运行,返回到操作系统
}r
eturn elem[i]; //返回元素值elem[i] 
}
int main() //主函数main() 
{ 
int a[]={1,9,7,5,6,3}; //定义数组a 
const int n=6; //数组元素个数
Array<int,n>obj; //定义数组对象
int i; //定义临时变量
for (i=0; i<n; i++) 
obj.SetElem(a[i],i); //设置数组元素值
for (i=0; i<n; i++) 
cout<<obj.GetElem(i)<<" "; //输出元素值
cout<<endl; //换行
return 0; //返回值0, 返回操作系统
}
程序运行时屏幕输出如下: 
1 9 7 5 6 3 
由于在类模板进行具体化(实例化)为模板类时,类型形参表中包含的表达式参数必须
是常量表达式,因此可以直接用数组储存数据元素值,比例3.4采用指针方式存储数据元素
值更简捷。
·85·

**3.4 实例研究:快速排序
快速排序(quicksort)有着广泛的应用,典型应用是UNIX系统库函数例程中的qsort()函
数,快速排序的基本思想是任选序列中的一个数据元素(通常选取第一个数据元素)作为枢
轴,并以它和所有剩余数据元素进行比较,将所有较它小的数据元素都排在它前面,将所有
较它大的数据元素都排在它之后,经过一遍排序后,可按此数据元素所在位置为界,将序列
划分为两部分,再对这两部分重复上述过程,直至每一部分中只剩一个数据元素或没有数据
元素为止。
假设待排序的序列为(a[low],a[low+1],…,a[high]),首先任选取序列中的一数据元
素(通常可选第一个数据元素)作为枢轴(pivot),再将所有比pivot小的数据元素排序在
pivot的左边,将所有比pivot大的数据元素排序在pivot的右边,设由此得到的枢轴的位置
是i,则以i作为分界线,将原序列作一次如下的划分: 
(a[low],a[low+1],…,a[i-1]) a[i] (a[i+1],a[i+2],…,a[high]) 
这样划分后得到两个子序列(a[low],a[low+1],…,a[i-1])和(a[i+1],a[i+2],…, 
a[high]),并且枢轴a[i](也就是pivot)已被放到正确的位置上,然后再分别对(a[low], 
a[low],…,a[i-1])和(a[i+1],a[i+2],…,a[high])子序列进行划分,直到每个子序列的
长度都为1或0时为止。
一遍快速排序的具体方法是,设枢轴是a[low],首先从high所指位置开始向左搜索到
第一个小于a[low]的数据元素(此数据元素仍假设为a[high])为止,然后交换a[low]和
a[high],这时枢轴为a[high],再从low所指位置开始向右搜索到第一个大于a[high]的数
据元素(此数据元素仍假设为a[low])为止,然后交换a[low]和a[high],这时枢轴为
a[low];重复这两步直到low=high时为止,这时枢轴的位置为low。
图3.1(a)是对关键字序列(49,38,66,97,38,68)第一遍快速排序的过程,图3.1(b)是排
序全过程。
图3.1 快速排序·86· 示意图

程序演示见3cs1.mp4~3cs3.mp4。 
下面是快速排序算法及测试程序上机操作步骤。
(1)建立工程quick_sort。
(2)建立头文件quick_sort.h,实现快速排序算法,具体内容如下: 
#ifndef _ _QUICK_SORT_H_ _ //如果没有定义_ _QUICK_SORT_H_ _ 
#define _ _QUICK_SORT_H_ _ //那么定义_ _QUICK_SORT_H_ _ 
template <class Type> 
int Partition(Type a[], int low, int high) 
//交换a[low..high]中的元素,使枢轴移动到适当位置,要求在枢轴之前的元素
//不大于枢轴,在枢轴之后的元素不小于枢轴的,并返回枢轴的位置
{ 
while (low<high) 
{ 
while (low<high&&a[high]>=a[low]) 
{ //a[low]为枢轴,使high 右边的元素不小于a[low] 
high--; 
} Type tem=a[low]; a[low]=a[high]; a[high]=tem; //交抽a[low]、a[high] 
while (low<high&&a[low]<=a[high]) 
{ //a[high]为枢轴,使low 左边的元素不大于a[high] 
low++; 
}t
em=a[low]; a[low]=a[high]; a[high]=tem; //交抽a[low]、a[high] 
}r
eturn low; //返回枢轴位置
}
template <class Type> 
void QuickSortHelp(Type a[],int low,int high) 
//对数组a[low..high]中的元素进行快速排序
{ 
if (low<high) 
{ //子序列a[low..high]长度大于1 
int pivotLoc=Partition(a,low,high); //进行一遍找分
QuickSortHelp(a,low, pivotLoc -1); //对序列a[low, pivotLoc-1]递归排序
QuickSortHelp(a,pivotLoc+1, high); //对序列a[pivotLoc+1,high]递归排序
} 
·87·

}
template <class Type> 
void QuickSort(Type a[],int n) //对数组a 进行快速排序
{ QuickSortHelp(a,0,n -1); } 
#endif 
(3)建立源程序文件main.cpp,实现main()函数,具体代码如下: 
//文件路径名: quick_sort\main.cpp 
#include <iostream> //编译预处理命令
using namespace std; //使用命名空间std 
#include "quick_sort.h" //快速排序
int main() //主函数main() 
{ 
int a[]={49,38,66,97,38,68}; //数组
int i,n=6; //定义变量
cout<<"排序前:"; 
for (i=0; i<n; i++) cout<<a[i]<<" "; //输出a 
cout<<endl; //换行
QuickSort(a, n); //快带排序
cout<<"排序后:"; 
for (i=0; i<n; i++) cout<<a[i]<<" "; //输出a 
cout<<endl; //换行
return 0; //返回值0, 返回操作系统
}
程序运行时屏幕输出如下: 
排序前:49 38 66 97 38 68 
排序后:38 38 49 66 68 97 
3.5 程序陷阱
模板是标准C++新加入的功能,各C++编译器对模板处理细节可能所有区别,例如对
于类模板的友元函数模板,各C++编译器就有不同的使用格式。
对于VisualC++6.0和VisualC++2022,可采用如下格式: 
//本程序适合于Visual C++6.0 和Visual C++2022 
//文件路径名:trap 3_1\main.cpp 
·88·

#include <iostream> //编译预处理命令
using namespace std; //使用命名空间std 
//声明类模板MyCalss 
template <class Type> 
class MyCalss 
{p
rivate: 
//数据成员 
Type value; //存储数据元素值
public: 
//公有函数 
MyCalss(const Type &v): value(v){ } //构造函数
template <class Type> 
friend void Show(const MyCalss<Type>&obj); //输出对象的信息
}; 
template <class Type> 
void Show(const MyCalss <Type>&obj) //输出对象的信息
{ cout<<obj.value<<endl; } 
int main() //主函数main() 
{ 
MyCalss <int> obj(8); //定义对象
Show(obj); //输出对象的信息
return 0; //返回值0, 返回操作系统
}
对于VisualC++6.0,还可去掉类体模板中的“template<classType>”,也就是采用如
下格式: 
//本程序适合于Visual C++6.0 
//文件路径名:trap 3_2\main.cpp 
#include <iostream> //编译预处理命令
using namespace std; //使用命名空间std 
//声明类模板MyCalss 
template <class Type> 
class MyCalss 
{p
rivate: 
//数据成员 
Type value; //存储数据元素值
·89·

public: 
//公有函数模板 
MyCalss(const Type &v): value(v){ } //构造函数模板 
friend void Show(const MyCalss<Type>&obj); //输出对象的信息
}; 
template <class Type> 
void Show(const MyCalss<Type>&obj) //输出对象的信息
{ cout<<obj.value<<endl; } 
… 
对于Dev-C++5.11只能将模板函数的定义放在类模板体内,并且不能加“template<class 
Type>”,也就是采用如下格式: 
//本程序适合于Dev-C++ 
//文件路径名:trap3_3\main.cpp 
#include <iostream> //编译预处理命令
using namespace std; //使用命名空间std 
//声明类模板MyCalss 
template <class Type> 
class MyCalss 
{
private: 
//数据成员 
Type value; //存储数据元素值
public: 
//公有函数模板 
MyCalss(const Type &v): value(v){ } //构造函数模板 
friend void Show(const MyCalss<Type>&obj){ cout<<obj.value<<endl; } 
//输出对象的信息
}; 
… 
习 题 3 
一、选择题
1.下列关于模板的叙述中,错误的是。
A.模板声明中的第一个符号总是关键字template 
B.在模板声明中用“<”和“>”括起来的部分是模板的类型形参表
C.类模板不能有数据成员
D.在一定条件下函数模板的类型实参可以省略
·90·

2.有以下函数模板定义: 
template <class Type> 
Type Fun(const Type &x, const Type &y) { return x * x+y * y; } 
在下列对Fun()的调用中,错误的是。
A.Fun(3,5) B.Fun(3.0,5.5) 
C.Fun(3,5.5) D.Fun<int>(3,5.5) 
3.关于关键字class和typename,下列表述中正确的是。
A.程序中typename都可以替换为class 
B.程序中的class都可以替换为typename 
C.在模板类型形参表中只能用typename声明参数的类型
D.在模板类型形参表中只能用class声明参数的类型
4.有以下函数模板: 
template <class Type> 
Type Square(const Type &x) { return x * x; } 
其中,Type是。
A.函数形参B.函数实参
C.模板类型形参D.模板类型实参
5.C++中的模板包括。
A.对象模板和函数模板B.对象模板和类模板
C.函数模板和类模板D.变量模板和对象模板
二、填空题
1.已知一个函数模板的声明如下: 
template <typename T1,typename T2> 
T1 Fun(T2 n) { return n*5.0; } 
若要求以int型数7为函数实参调用该模板函数,并返回一个double型数,则该调用应
表示为。
2.已知intdbl(intn){returnn+n;}和longdbl(longn){returnn+n;}是一个函
数模板的两个模板函数,则该函数模板的声明是 
template <typename Type> 
3.下面程序的运行结果是。 
//文件路径名:ex3_2_3\main.cpp 
#include <iostream> //编译预处理命令
using namespace std; //使用命名空间std 
template <class Type> 
·91·

Type Min(const Type &a, const Type &b) //求a、b 的最小值
{ 
if (a<b) return a; //a 更小 
else return b; //b 更小
}
int main() //主函数main() 
{ 
int n1=4,n2=5; //定义整型变量
double d1=0.35,d2=4.4; //定义实型变量
cout<<"最小整数="<<Min(n1, n2)<<","<<"最小实型="<<Min(d1, d2)<<endl; 
//输出信息
return 0; //返回值0, 返回操作系统
}
三、编程题
1.试使用函数模板实现输出一个数组各元素的值,要求编写测试程序。
2.编写一个复数类模板Complex,其数据成员real和image的类型未知,定义相应的
成员函数模板,包括构造函数模板、输出复数值的函数模板、求复数和的函数模板和求复数
差的函数模板,主函数中定义模板类对象,分别以int和double实例化类型参数。 
*3.编写一个使用数组类模板Array对数组求最大值和求元素和的程序,要求编写出测
试程序。 
*4.对数组求最大值和求元素和的算法都编写为函数模板,要求编写出测试程序。 
**5.对数组求最大值和求元素和的函数采用静态成员函数的方式封装成数组算法类模
板ArrayAlg,要求编写出测试程序。
·92·