c++模板及应用习题答案.doc

(完整版)c++模板及应用习题答案
1。概念填空题
1.1 C++最重要的特性之一就是代码重用,为了实现代码重用，代码必须具有 通用性 .通用代码需要不受数据 类型 的影响，并且可以自动适应数据类型的变化。这种程序设计类型称为 参数化 程序设计。模板是C++支持参数化程序设计的工具，通过它可以实现参数化 多态性 性。
1.2函数模板的定义形式是template 〈模板参数表〉 返回类型 函数名（形式参数表)｛…}。其中，〈模板参数表〉中参数可以有 多 个，用逗号分开.模板参数主要是 模板类型 参数。它代表一种类型，由关键字 typename 或 class 后加一个标识符构成，标识符代表一个潜在的内置或用户定义的类型参数。类型参数由可以是任意合法标识符.C++规定参数名必须在函数定义中至少出现一次.
1.3编译器通过如下匹配规则确定调用那一个函数：首先，寻找最符合 函数名 和 参数类型 的一般函数，若找到则调用该函数;否则寻找一个 函数模板 ,将其实例化成一个 模板函数 ，看是否匹配，如果匹配，就调用该 模板函数 ；再则，通过 类型转换 规则进行参数的匹配.如果还没有找到匹配的函数则调用错误.如果有多于一个函数匹配，则调用产生 二义性 ，也将产生错误。
1。4类模板使用户可以为类声明一种模式，使得类中的某些数据成员、某些成员函数的参数、某些成员函数的返回值能取 任意类型 （包括 系统预定类型 和 用户自定义的类型）.类是对一组对象的公共性质的抽象，而类模板则是对不同类的 数据类型? 的抽象，因此类模板是属于更高层次的抽象.由于类模板需要一种或多种 类型 参数,所以类模板也常常称为 参数化类 .

2. 简答题
2.1简述函数模板生成函数的过程。
2。2 简述类模板生成对象的过程.
2。3 简述函数模板与模板函数、类模板与模板类的区别.

3。 选择题
3。1关于函数模板，描述错误的是(A )。
A。函数模板必须由程序员实例化为可执行的函数模板
B。函数模板的实例化由编译器实现
C.一个类定义中，只要有一个函数模板，则这个类是类模板
D.类模板的成员函数都是函数模板,类模板实例化后，成员函数也随之实例化
3.2下列的模板说明中，正确的是（D )。
A.template〈typename T1，T2〉
B。template〈class T1，T2>
C.template<class T1,class T2〉
D。template<typename T1，typename T2>
3。3 函数模板定义如下：
template 〈typename T〉
Max（ T a， T b ，T ＆c）｛c=a+b;}
下列选项正确的是（B ）。
A. int x， y; char z; B.double x, y， z;
Max(x, y， z); Max（ x, y， z）;
C。int x， y; float z; D。float x; double y， z；
Max( x, y, z）; Max（ x,y， z);
3。4 下列有关模板的描述错误的是（D).
A． 模板把数据类型作为一个设计参数，称为参数化程序设计。
B． 使用时，模板参数与函数参数相同，是按位置而不是名称对应的。
C． 模板参数表中可以有类型参数和非类型参数。
D． 类模板与模板类是同一个概念。
3.5类模板的使用实际上是将类模板实例化成一个（C）。
A．函数 B．对象 C．类 D．抽象类
3。6类模板的模板参数（D)。
A．只能作为数据成员的类型 B．只可作为成员函数的返回类型
C．只可作为成员函数的参数类型 D．以上三种均可
3。7类模板的实例化(A)。
A．在编译时进行 B．属于动态联编
C．在运行时进行 D．在连接时进行
3。8以下类模板定义正确的为（A)。
A．template〈class T,int i=0> B．template〈class T，class int i〉
C．template〈class T，typename T〉 D．template〈class T1，T2>

4．编程题
4。1设计一个函数模板，其中包括数据成员T a［n］以及对其进行排序的成员函数 sort( ），模板参数T可实例化成字符串.
＃include 〈iostream>
#include <string〉
using namespace std；
template〈typename T〉void Sort（T＊ a,int n）{
int i,j；
T t；
for（i=0；i<n-1;i++)
for（j=0；j<n-i—1;j++）
if （a［j]〉a[j+1]）
{ t=a[j]；
a［j]=a［j+1];
a［j+1］=t；
}
｝
template<typename T〉void Print（T* a,int n）｛
int i;
for(i=0;i〈n；i++）
cout<〈a[i］<〈" "；
cout<<endl;
}

int main（）{
string Str[10]={”Zhang”，"Li"，"Wang”,”Qian”,"Zhao”,"Wu"，”Xu”，”Tang”，”Shen"，"Liang”｝;
int Int［8］={20，12，0，—5，9，-18,6，11｝;
double Dou［7］={3。07,8。12,—0。45,6,10，-9,7.29｝;
Sort〈string〉（Str，10）;
Sort<int〉(Int,8）；
Sort〈double〉（Dou,7）；
Print（Str，10);
Print（Int，8）；
Print（Dou,7）；
return 0；
}
4.2设计一个类模板，其中包括数据成员T a［n]以及在其中进行查找数据元素的函数int search(T）模板参数 T可实例化成字符串。
＃include 〈iostream>
using namespace std；
template<typename T，int n〉class A｛
int size；
T* element；
public:
A(）；
～A（)；
int Search（T）;
void SetElement(int index,const T& value)；
｝;

template<typename T,int n〉A<T，n>:：A（)｛
size=n>1? n:1；
element=new T［size]；
}
template<typename T，int n〉A〈T，n〉::~A(）｛
delete ［] element;
}
template<typename T,int n〉int A<T，n〉:：Search(T t){
int i；
for（i=0；i<size;i++)
if（element［i］==t)
return i;
return —1；
｝
template<typename T,int n>void A<T，n>:：SetElement（int index,const T& value）｛
element[index］=value；
}
int main(){
A〈int，5> intAry; //用int实例化,建立模板类对象
A〈double,10> douAry;//用double实例化，建立模板类对象
int i;
for(i=0；i<5；i++）
intAry.SetElement（i,i+3）;
for(i=0；i〈10；i++)
douAry。SetElement(i，(i+i)＊0.35);
i=intAry.Search（7）;
if（i〉=0)cout〈〈i〈<endl;
i=douAry。Search（0.7）;
if(i>=0）cout〈<i〈<endl；
return 0;
｝
4。3设计一个单向链表类模板,节点数据域中数据从小到大排列，并设计插入、删除节点的成员函数.
#include〈iostream〉
using namespace std；
template〈typename T>class List;
template<typename T〉class Node{
T info; //数据域
Node〈T> ＊link； //指针域
public:
Node（）； //生成头结点的构造函数
Node(const T ＆ data)；//生成一般结点的构造函数
friend class List<T〉；
};
template 〈typename T> Node<T〉：：Node（)｛link=NULL；}
template 〈typename T〉 Node<T>:：Node（const T ＆ data)｛
info=data;
link=NULL；
｝
//定义链表类
template<typename T>class List{
Node<T> ＊head； //链表头指针和尾指针
public:
List(）； //构造函数，生成头结点(空链表）
~List（）; //析构函数
void MakeEmpty()； //清空一个链表，只余表头结点
Node〈T>＊ Find(T data)； //搜索数据域与data相同的结点，返回该结点的地址
void PrintList（）； //打印链表的数据域
void InsertOrder（Node〈T> ＊p）； //按升序生成链表
Node〈T>＊ CreatNode(T data）； //创建一个结点（孤立结点)
Node〈T〉＊ DeleteNode(Node〈T〉＊ p); //删除指定结点
}；
template〈typename T>List<T>:：List()｛
head=new Node<T〉(-9999)；//头结点，最小的数据从小到大插入
｝
template<typename T〉List〈T>:：～List（)｛
MakeEmpty()；
delete head;
}
template<typename T>void List<T〉::MakeEmpty(){
Node<T> *tempP;
while（head—>link!=NULL)｛
tempP=head-〉link;
head-〉link=tempP—〉link; //把头结点后的第一个节点从链中脱离
delete tempP； //删除（释放)脱离下来的结点
}
｝
template〈typename T> Node〈T>* List〈T>:：Find(T data){
Node〈T〉 ＊tempP=head->link；
while（tempP！=NULL && tempP->info！=data） tempP=tempP->link;
return tempP； //搜索成功返回该结点地址，不成功返回NULL
｝
template<typename T>void List<T>：：PrintList(){
Node〈T>* tempP=head->link；
while（tempP!=NULL）{
cout〈〈tempP-〉info〈〈'\t';
tempP=tempP—〉link;
}
cout〈<endl；
}
template〈typename T>void List〈T>：：InsertOrder（Node<T> *p){
Node〈T〉 *tempP=head，＊tempQ=head； //tempQ指向tempP前面的一个节点
while（tempP!=NULL){
if（p—〉info〈tempP-〉info)break; //找第一个比插入结点大的结点，由tempP指向
tempQ=tempP；
tempP=tempP-〉link；
}
p-〉link=tempP;
tempQ->link=p;
｝
template<typename T〉Node<T>* List〈T〉::CreatNode(T data){//建立新节点
Node〈T〉*tempP=new Node〈T>（data）;
return tempP；
}
template<typename T〉Node〈T>* List<T〉：：DeleteNode(Node〈T>＊ p){
Node〈T>＊ tempP=head—〉link，＊tempQ=head,＊tempC;
while(tempP！=NULL ＆＆ tempP！=p)｛
tempQ=tempP;
tempP=tempP—〉link;
}
tempC=tempP;
tempQ—>link=tempP—>link;
return tempC；
｝
int main（){
Node<int〉 ＊ P1；
List<int> list1；
int a[10］={20,12,0，—5，9，—18，6，11，5，3｝,i,j；
for（i=0;i〈10；i++){
P1=list1。CreatNode(a［i])；
list1。InsertOrder(P1）；
｝
list1.PrintList（)；
cout〈<"请输入一个要求删除的整数”<〈endl；
cin>>j；
P1=list1.Find(j）;
if（P1！=NULL){
P1=list1。DeleteNode(P1）;
delete P1；
list1。PrintList（）；
}
else cout<〈"未找到”<〈endl；
cout〈<"请输入一个要求插入的整数"<<endl;
cin>>j；
P1=list1。CreatNode（j）；
list1.InsertOrder（P1）；
list1.PrintList（）;
list1.MakeEmpty();//清空list1
list1.PrintList();
return 0；
}
4。4 为单链表类模板增加一个复制构造函数和赋值运算符(=）.
在上题基础上，List类增加一个复制构造函数和赋值运算符（=）
template〈typename T〉List〈T>::List（List＆ l）{
head=new Node〈T>(—9999）；//现建立头结点
Node〈T〉＊ tempP=l.head->link，＊tempC；
while(tempP！=NULL）｛
tempC=CreatNode(tempP->info）；
InsertAfter(tempC);
tempP=tempP-〉link;
｝
}
template〈typename T〉List〈T〉& List〈T〉：:operator=（List& l）｛
MakeEmpty();//先释放原来链表的数据结点
Node〈T>＊ tempP=l.head->link,*tempC；
while（tempP！=NULL){
tempC=CreatNode(tempP—>info);
InsertAfter（tempC）;
tempP=tempP-〉link；
｝
return *this；
｝

int main（）{
Node〈int> ＊ P1;
List<int> list1,list2；
int a［10]={20,12，0,-5，9，—18,6,11,5，3},i,j；
for（i=0;i〈10;i++){
P1=list1。CreatNode(a［i]）;
list1。InsertOrder（P1）;
}
list1.PrintList（）；
cout<〈"请输入一个要求删除的整数”<〈endl;
cin〉>j;
P1=list1.Find（j）;
if（P1！=NULL）｛
P1=list1。DeleteNode(P1);
delete P1;
list1。PrintList(）；
}
else cout〈<"未找到"<<endl；
cout<<"请输入一个要求插入的整数"〈〈endl;
cin〉〉j;
P1=list1。CreatNode(j)；
list1.InsertOrder（P1）；
list1。PrintList(）；
list2=list1;
list2.PrintList（)；
List〈int> list3=list1;
list3。PrintList（）;
cout<<"请输入一个要求删除的整数"<〈endl；
cin>>j；
P1=list1.Find（j）;
if（P1！=NULL）{
P1=list1。DeleteNode(P1);
delete P1;
list1。PrintList(）;
}
else cout<<”未找到”<<endl；
list2=list3=list1；
list2.PrintList（);
list3。PrintList()；
list1.MakeEmpty（）；//清空list1
list2.MakeEmpty()；//清空list1
list3。MakeEmpty（）;//清空list1
return 0；
｝