c及应用习题答案.docx
《c及应用习题答案.docx》由会员分享，可在线阅读，更多相关《c及应用习题答案.docx（16页珍藏版）》请在冰点文库上搜索。
c及应用习题答案
1.概念填空题
1.1C++最重要的特性之一就是代码重用，为了实现代码重用，代码必须具有通用
性。
通用代码需要不受数据类型的影响，并且可以自动适应数据类型的变化。
这
种程序设计类型称为参数化程序设计。
模板是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
B.template
C.template
D.template
3.3函数模板定义如下:
template
Max（Ta,Tb,T&c）{c=a+b;}
下列选项正确的是（B）。
A.intx,y;charz;B.doublex,y,z;
Max（x,y,z）;Max（x,y,z）;
C.intx,y;floatz;D.floatx;doubley,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．templateB．template
D．template
C．template
4．编程题
4.1设计一个函数模板，其中包括数据成员Ta[n]以及对其进行排序的成员函数sort（），模板参数T可实例化成字符串。
#include
#include
usingnamespacestd;
templatevoidSort（T*a,intn）{
inti,j;
Tt;
for（i=0;ifor（j=0;jif（a[j]>a[j+1]）
{t=a[j];
a[j]=a[j+1];
a[j+1]=t;
}
}
templatevoidPrint（T*a,intn）{
inti;
for（i=0;icout<cout<}
intmain（）{
stringStr[10]={Zhang,Li,Wang,Qian,Zhao,Wu,Xu,Tang,S
hen,Liang};
intInt[8]={20,12,0,-5,9,-18,6,11};
doubleDou[7]={3.07,8.12,-0.45,6,10,-9,7.29};
Sort（Str,10）;
Sort（Int,8）;
Sort（Dou,7）;
Print（Str,10）;
Print（Int,8）;
Print（Dou,7）;
return0;
}
4.2设计一个类模板，其中包括数据成员Ta[n]以及在其中进行查找数据元素的函数intsearch（T）模板参数T可实例化成字符串。
#include
usingnamespacestd;
templateclassA{
intsize;
T*element;
public:
A（）;
~A（）;
intSearch（T）;
voidSetElement（intindex,constT&value）;
};
templateA:
:
A（）{
size=n>1n:
1;
element=newT[size];
}
templateA:
:
~A（）{
delete[]element;
}
templateintA:
:
Search（Tt）{
inti;
for（i=0;iif（element[i]==t）
returni;
return-1;
}
templatevoidA:
:
SetElement（intindex,constT&value）{
element[index]=value;
}
intmain（）{
intAintAry;
//用实例化，建立模板类对象AdouAry;//用double实例化，建立模板类对象
inti;
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=douAry.Search（0.7）;
if（i>=0）cout<return0;
}
4.3设计一个单向链表类模板，节点数据域中数据从小到大排列，并设计插入、删除节点的成员函数。
#include
usingnamespacestd;
templateclassList;
templateclassNode{
Tinfo;//数据域
Node*link;//指针域
public:
Node（）;//生成头结点的构造函数
Node（constT&data）;//生成一般结点的构造函数
friendclassList;
};
templateNode:
:
Node（）{link=NULL;}
templateNode:
:
Node（constT&data）{
info=data;
link=NULL;
}
//定义链表类templateclassList{
链表头指针和尾指针Node*head;//
public:
List（）;//构造函数，生成头结点（空链表）
~List（）;//析构函数
voidMakeEmpty（）;//清空一个链表，只余表头结点
Node*Find（Tdata）;//搜索数据域与data相同的结点，返回该结点的地址
voidPrintList（）;//打印链表的数据域
voidInsertOrder（Node*p）;//按升序生成链表
Node*CreatNode（Tdata）;//创建一个结点（孤立结点）
删除指定结点Node*DeleteNode（Node*p）;//};
templateList:
:
List（）{
头结点，最小的数据从小到大插入head=newNode（-9999）;//}
templateList:
:
~List（）{
MakeEmpty（）;
deletehead;
}
templatevoidList:
:
MakeEmpty（）{
Node*tempP;
while（head->link!
=NULL）{
tempP=head->link;
head->link=tempP->link;//把头结点后的第一个节点从链中脱离脱离下来的结点）释放（删除deletetempP;//
}
}
templateNode*List:
:
Find（Tdata）{
Node*tempP=head->link;
while（tempP!
=NULL&&tempP->info!
=data）tempP=tempP->link;
returntempP;//搜索成功返回该结点地址，不成功返回NULL
}
templatevoidList:
:
PrintList（）{
Node*tempP=head->link;
while（tempP!
=NULL）{
cout<info<<'\t';
tempP=tempP->link;
}
cout<}
templatevoidList:
:
InsertOrder（Node*p）{
前面的一个节点tempPNode*tempP=head,*tempQ=head;//tempQ指向
while（tempP!
=NULL）{
找第一个比插入结点大的结点，由if（p->infoinfo）break;//tempP指向
tempQ=tempP;
tempP=tempP->link;
}
p->link=tempP;
tempQ->link=p;
}
templateNode*List:
:
CreatNode（Tdata）{//建立新节点
Node*tempP=newNode（data）;
returntempP;
}
templateNode*List:
:
DeleteNode（Node*p）{
Node*tempP=head->link,*tempQ=head,*tempC;
while（tempP!
=NULL&&tempP!
=p）{
tempQ=tempP;
tempP=tempP->link;
}
tempC=tempP;
tempQ->link=tempP->link;
returntempC;
}
intmain（）{
Node*P1;
Listlist1;
inta[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（）;
潣瑵?
请输入一个要求删除的整数<cin>>j;
P1=list1.Find（j）;
if（P1!
=NULL）{
P1=list1.DeleteNode（P1）;
deleteP1;
list1.PrintList（）;
}
<汥敳潣瑵?
未找到<请输入一个要求插入的整数cin>>j;
P1=list1.CreatNode（j）;
list1.InsertOrder（P1）;
list1.PrintList（）;
list1list1.MakeEmpty（）;//清空
list1.PrintList（）;
return0;
}
4.4为单链表类模板增加一个复制构造函数和赋值运算符（=）。
（=）
类增加一个复制构造函数和赋值运算符List在上题基础上，
templateList:
:
List（List&l）{
head=newNode（-9999）;//现建立头结点
Node*tempP=l.head->link,*tempC;
while（tempP!
=NULL）{
tempC=CreatNode（tempP->info）;
InsertAfter（tempC）;
tempP=tempP->link;
}
}
templateList&List:
:
operator=（List&l）{
MakeEmpty（）;//先释放原来链表的数据结点
Node*tempP=l.head->link,*tempC;
while（tempP!
=NULL）{
tempC=CreatNode（tempP->info）;
InsertAfter（tempC）;
tempP=tempP->link;
}
return*this;
}
intmain（）{
Node*P1;
Listlist1,list2;
inta[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（）;
<cin>>j;
P1=list1.Find（j）;
if（P1!
=NULL）{
P1=list1.DeleteNode（P1）;
deleteP1;
list1.PrintList（）;
}
<未找到汥敳潣瑵?
<请输入一个要求插入的整数
cin>>j;
P1=list1.CreatNode（j）;
list1.InsertOrder（P1）;
list1.PrintList（）;
list2=list1;
list2.PrintList（）;
Listlist3=list1;
list3.PrintList（）;
潣瑵?
请输入一个要求删除的整数<cin>>j;
P1=list1.Find（j）;
if（P1!
=NULL）{
P1=list1.DeleteNode（P1）;
deleteP1;
list1.PrintList（）;
}
<list2=list3=list1;
list2.PrintList（）;
list3.PrintList（）;
list1list1.MakeEmpty（）;//清空list1清空list2.MakeEmpty（）;//list1list3.MakeEmpty（）;//清空return0;
}
升级会员 