4.（2003秋）设x为整数，C++中能正确地表达数学式0≤x<5的是。
A.0<=x<15B.x=0||x=1||x=2||x=3||x=4
C.x>=0||x<5D.!
（x<0||x>=5）
5.（2009年春）以下关于break语句的描述中，不正确的是。
A．break语句可用在循环语句中，其作用是结束本层循环的执行
B．break语句可用switch语句中，其作用是结束该switch语句的执行
C．break语句可用if语句中，其作用是结束该if语句的执行
D．break语句在同一循环体中可以多次使用
6.（2011秋）C++的break语句。
A．用在能出现语句的任意位置B．只能用在循环体内
C．只能用在循环体内或switch语句中D．能用在任一复合语句中
7.（2003秋）以下四组函数原型说明中,满足C++函数重载规则的是。
A.floatf（floatx）;voidf（floaty）;
B.floatf（floatx）;voidf2（floatx,floaty）;
C.floatf（floatx,inty）;voidf（floaty）;
D.floatf（floaty）;floatf（floaty）;
8.（2005秋）函数重载是指。
A．函数名相同，但函数的参数个数不同或参数的类型不同
B．函数名相同，但函数的参数个数不同或函数的返回值的类型不同
C．函数名不同，但函数的参数个数和参数的类型相同
D．函数名相同，但函数的参数类型不同或函数的返回值的类型不同
9.（2011春）下述关于函数重载的描述中，不正确的是。
A．两个或两个以上的函数取相同的函数名，但形参的个数不同
B．两个或两个以上的函数取相同的函数名，各函数的返回值的类型必须不同
C．两个或两个以上的函数取相同的函数名，形参的个数相同但类型不同
D．两个或两个以上的函数取相同的函数名，形参的个数不同或类型不同
10.（2012春）C++中，函数重载是指两个或两个以上的函数，其函数名。
A．不同，但形参的个数或类型相同B．相同，但返回值类型不同
C．相同，但形参的个数或类型不同D．相同，形参的个数相同，但其类型不同
11.（2002秋）下列关于类的构造函数和析构函数的叙述中，不正确的是。
A.类的析构函数可以重载B.类的构造函数可以重载
C.定义一个类时可以不显式定义构造函数
D.定义一个类可以不显式定义析构函数
12.（2003春）以下有关对象的叙述中,不正确的是。
A.产生对象时必定要调用构造函数B.撤消对象时必定要调用析构函数
C.对象被保护，其私有成员不能任意访问D.对象可以没有构造函数或析构函数
13.（2011春）以下有关this指针的叙述中，不正确的是。
A．当调用对象的非静态成员时，总存在一个this指针
B．非静态成员函数调用类中的成员时，可直接使用this指针
C．this指针隐含地指向要用到的当前对象
D．静态成员函数也存在this指针
14.（2010春）类的成员函数中，没有this指针的是。
A．构造函数B．析构函数C．虚函数D．静态成员函数
15.（2003秋）下面有关运算符重载的叙述中，正确的是。
A.非静态成员函数重载运算符时带有this指针
B.友元函数重载运算符时带有this指针
C.成员函数与友元函数重载运算符时都不带有this指针
D.用成员函数或友元函数重载同一运算符时，两者的参数类型与参数个数相同
16.（2004春）以下有关析构函数的叙述中,正确叙述的是。
A.析构函数可以有一个或多个参数B.可以重载析构函数
C.析构函数可以定义为虚函数D.必须显式地自定义析构函数
17.（2004春）下面有关基类与其派生类的的叙述中，正确的是。
A.派生类对象不能赋给基类对象B.派生类对象的地址不能赋给其基类的指针变量
C.基类对象不能赋给派生类对象D.基类对象的地址能赋给其派生类的指针变量
18.（2006秋）下列关于赋值兼容规则的叙述中，不正确的是。
A.派生类的对象可以赋值给基类的对象
B.基类的对象可以赋值给派生类的对象
C.派生类的对象可以初始化其基类的引用
D．可以将派生类对象的地址赋值给其基类的指针变量
19.（2011秋）在C++中，没有this指针的函数是。
A．静态成员函数B．构造函数C．析构函数D．非静态的内联成员函数
20.（2011秋）以下关于C++类的叙述中，不正确的是。
A.类可以动态地描述和动态地产生B.虚基类可以解决多重继承中的二义性
C.类是具有相同行为的若干对象的统一抽象D．类是创建对象的一个模板
二、填空题
1.（2006秋）当一个类的非静态成员函数被调用时，该成员函数的指向调用它的对象。
2.（2008春）在C++中，重载赋值运算符“=”和下标运算符“[]”等只能用实现，而重载插入运算符“<<”和提取运算符“>>”等只能用实现。
（成员函数，友元函数）
3.（2001年秋）多态性分为两种：
静态多态性和动态多态性。
函数重载属于二种多态性中的哪一种：
。
4.（2002秋）设有语句:
inta=6,b=3;floatx=8,y;y=b/a*x/2;则y的值为。
5.（2003春）设有语句：
chars[]="China\0Nanjin";intm=strlen（s）;则m的值为。
（引号，ASCII值，换行符）
6.（2003春）在C++中函数的参数传递方式有三种:
第一种是值传递,第二种是指针传递,第三种是传递。
7.（2004春）函数重载是指函数名相同,但函数的
（1）不同或函数的
（2）不同。
8.[程序]（2002年春）
#include
voids（inta,int&b）{intt=a;a=b;b=t;}
voidmain（void）
{intx=500,y=1000;
cout<cout<}
程序的第一行输出为
（1），第二行输出为
（2）。
9.[程序]（2004春）（全局变量通过指针传递）
#include
intz;
voidfun（intx,int&y）
{z=x;x=x+y;y=y+z;
cout<}
voidmain（void）
{intx=5,y=10;
z=15;
fun（x,y）;
cout<}
程序的第一行输出为
（1），第二行输出为
（2）。
10.[程序]（2004秋）（内部循环）
#include
voidfun（int*a,int*b）
{（*a）++;*b++;*a++;（*b）++;
cout<<*a<<'\t'<<*b<}
voidmain（void）
{intc1[3]={10,20,30},c2[3]={40,50,60};
fun（c1,c2）;
cout<cout<}
程序的第一行输出为
（1），第二行输出为
（2），第三行是（3）。
11.[程序]（2002秋）
#include
classA{
intx,n;
intmul;
public:
A（inta,intb）{x=a;n=b;mul=1;}
virtualintpower（void）
{mul=1;
for（inti=1;i<=n;i++）mul*=x;
returnmul;
}
voidshow（void）{cout<};
classB:
publicA{
inty,m;
intp;
public:
B（inti,intj,intk,inth）:
A（i,j）
{y=k;m=h;p=10;}
intpower（void）
{p=1;
for（inti=1;i<=m;i++）p*=y;
returnp;
}
voidshow（void）
{A:
:
show（）;cout<};
voidfun（A*f）
{cout<power（）<<'\n';}
voidmain（）
{Aa（5,3）;Bb（2,4,3,3）;
fun（&a）;fun（&b）;
b.show（）;
}
程序输出的第一行和第三行分别是
（1），
（2）。
12.[程序]（2003秋）
#include
ints（int（*f）（int）,intm,intn）
{intk,sum=0;
for（k=m;k<=n;k++）{
sum+=f（k）+f（k）;
cout<<"s="<}
returnsum;
}
intf1（intx）{returnx+=2;}
intf2（intx）{returnx-=2;}
voidmain（void）
{cout<<"result="<<（s（f1,1,2）+s（f2,1,2））<程序输出的第一行是
（1），第三行是
（2），第五行是（3）。
13.[程序]（2003年春）
#include
classShape{
public:
Shape（）{}
virtualfloatArea（）=0;
};
classCircle:
publicShape{
floatr;
public:
Circle（floatc）{r=c;}
floatArea（）{return3*r*r;}
};
classRectangle:
publicShape{
floath,w;
public:
Rectangle（floatc,floatd）{h=c;w=d;}
floatArea（）{returnh*w;}
};
voidfun（Shape*s）{cout<Area（）<<'\n';}
voidmain（void）
{Circlec（4）;
fun（&c）;
Rectangler（5,2）;
fun（&r）;
}
程序输出的第一行是
（1），第二行是
（2）。
14.（2003年春）以下程序的功能是求三角函数sinx的近似值。
求sinx近似值的计算公式为:
。
其中x的值为弧度。
当输入的x值为度数时，要求出sinx的近似值，必须将度数转换为弧度。
转换公式为:
y=3.1415926x/360
要求计算精度达到0.000001。
[程序]
#include
#include
doublesin（doublex,doubleeps）
{doubleterm,sum,y;
intn=1;
y=x*x;
term=
（1）;//x
sum=0;
while（fabs（term）>=eps）{
sum+=
（2）;//term
n++;
term=term*y/（3）;//（（2*n-2）*（2*n-1））
term*=-1;
}
return（4）;//sum+term或sum
}
voidmain（void）
{doublex,y;
cout<<"输入x的值（角度）:
";
cin>>x;
while（x>360）x-=360;
y=3.1415926*x/180;
cout<<"度数为:
"<cout<<"其sin值为:
"<}
15.（2005春）设已建立一条单向链表，指针head指向该链表的首结点。
结点的数据结构如下：
structNode{intdata;Node*next;};
以下函数sort（Node*head）的功能是：
将head所指向链表上各结点的数据按data值从小到大的顺序排序。
算法提示：
初始时，使p指向链表的首结点，从p之后的所有结点中找出data值最小的结点，让p1指向该结点。
将p指向的结点的data值与p1指向的结点的data值进行交换。
让p指向下一个结点，依此类推，直至p指向链表的最后一个结点为止。
[程序]（4分）
Node*sort（Node*head）
{Node*p=head,*p1,*p2;
if（p==NULL）returnhead;
while（p->next!
=NULL）{
p1=p;
p2=p->next;
while（p2!
=NULL）{
if（
（1））//p2->datadata
p1=p2;
p2=p2->next;
}
if（p!
=p1）{
intt;
t=p->data;
p->data=
（2）;//p1->data
（3）=t;//p1->data
}
（4）;//p=p->next}
returnhead;
}
16.（2008年春）在以下程序中，函数CreateLink（）根据键盘输入的数据建立一个单向无序链表，链表上的每一个结点包含一个整型数；函数SortLink（）通过改变结点在链表中的位置将链表调整为一条有序链表；函数PrintLink（）将链表上的数据输出；函数DeleteLink（）将链表删除。
[程序]
#include
structnode{intdata;node*next;};
node*CreateLink（void）//创建无序链表
{node*p1,*p2,*head=0;
inta;
cout<<"产生一条无序链，请输入数据，以-1结束:
";
cin>>a;
while（a!
=-1）{
p1=newnode;
p1->data=a;
if（head==0）{
head=p1;
p2=p1;
}
else{
（1）//p2->next=p1;
p2=p1;
}
cout<<"请输入数据，以-1结束:
";
cin>>a;
}
p2->next=0;
return（head）;
}
voidSortLink（node*&head）//通过移动每个节点的指针来完成链表排序
{node*q,*tq,*p,*tp;
intflag=0;
if（!
head）return;
for（q=head,tq=0;q;q=q->next）{
for（tp=q,p=q->next;p;tp=p,p=p->next）
if（q->data>=p->data）{//将p和q指向的两个节点所处位置互换
（2）//tp->next=p->next;
p->next=q;
q=p;
p=tp;
}
if（!
tq）head=q;
elsetq->next=q;
tq=q;
}
}
voidPrintLink（node*head）//打印链表
{node*p=head;
cout<<"链上各结点的数据为:
\n";
while（p!
=NULL）{
cout<data<<'\t';
（3）//p=p->next;
}
cout<<"\n";
}
voidDeleteLink（node*head）//删除链表
{node*p1;
while（head）{
p1=head;
head=head->next;
（4）//deletep1;
}
}
voidmain（void）
{node*head=0;
head=CreateLink（）;
PrintLink（head）;
SortLink（head）;
PrintLink（head）;
DeleteLink（head）;
}
17.（2011春）在以下程序中，函数create（）根据键盘输入的整数建立一条单向无序链表，链表上的每一个结点包含一个整数；函数sort（）根据链表结点的数据按从小到大的顺序将链表调整为一条有序链表；函数print（）将链表上的整数依次输出；函数del（）将链表删除。
排序算法提示：
（1）初始时，使p指向链表的首结点，
（2）从p之后的所有结点中找出data值最小的结点，（3）让p1指向该结点，并将p指向结点的data值与p1指向结点的data值进行交换，让p指向下一个结点，（4）重复步骤
（2）和（3），直至p指向链表的最后一个结点为止。
[程序]
#include
参考答案：
1.p2=p->next或p2=p1->next
2.p1=p2
3.p1->next=p;
4.h=h->next;
structNode{
intdata;
Node*next;
};
Node*sort（Node*head）
{Node*p=head,*p1,*p2;
if（p==NULL）returnhead;
while（p->next!
=NULL）{
p1=p;
（1）;
while（p2!
=NULL）{
if（p2->datadata）
（2）;
p2=p2->next;
}
if（p!
=p1）{
intt;
t=p->data;
p->data=p1->data;
p1->data=t;
}
p=p->next;
}
returnhead;
}
Node*creat（void）
{Node*h=NULL,*p,*p1;
intdata=1;
while（data）{
cout<<"输入一个整数,0表示输入结束:
";
cin>>data;
if（data）{
p=newNode;
p->data=data;
p->next=NULL;
if（h==NULL）
h=p1=p;
else{
（3）
p1=p;
}
}
}
returnh;
}
voidprint（Node*p）
{while（p）{
cout<data<<'\t';
p=p->next;
}
cout<<'\n';
}
voiddel（Node*h）
{Node*p;
while（h）{
p=h;
（4）
deletep;
}
}
voidmain（void）
{Node*head;
head=creat（）;
cout<<"链表上的数据为:
";
print（head）;
head=sort（head）;
cout<<"排序后链表上的数据为:
";
print（head）;
del（head）;
cout<}
升级会员 