402096C++程序设计习题集.docx
《402096C++程序设计习题集.docx》由会员分享，可在线阅读，更多相关《402096C++程序设计习题集.docx（39页珍藏版）》请在冰豆网上搜索。
402096C++程序设计习题集
402-096-C++程序设计习题集
上机题:
先定义“高度”类Hight和“圆”类Circle，再由Hight和Circle多重派生出“圆柱体”类Cylinder。
在主函数中定义一个圆柱体对象，调用成员函数求出圆柱体的体积和表面积。
第一部分:
一（选择填空题
1（类成员缺省的访问特征是_C_,结构体缺省的访问权限是__B_.
A.protectedB.publicC.privateD.friend
2（下列关于类的成员的访问特征的描述中,正确的___
A.必须首先说明具有私有特征的成员
B.数据成员必须说明成私有的,成员函数必须说明成私有的
C.每个成员前都必须有标明访问特性的关键字
D.在同一类中,说明访问特性的关键字可以多次使用
3（关于类和对象,下列说法不正确的是___
A.类与对象的关系类似于数据类型与变量的关系
B.对象是类的一个实例
C.任何一个对象必定属于一个特定的类
D.一个类只能有一个对象
4（关于类的一个成员函数,下列说法中正确的是（）
A.必须在类内定义B.一定是内联函数
C.不可以重载D.可以设置参数的缺省植
5（以下不可以作为类的成员的是（）
A.自身类对象的指针B.自身类的对象
C.自身类对象的引用D.另一个类对象的引用6（已知一个类,类名为A,可以定义A类的对象或定义A类的指针,下列
一定不正确的形式为____
A.Aa1B.Aa2（16）
C.AA3（）D.A*P=newA
7.已知一个类COMPLEX,有下述两行:
Complexc;//A
Complexc（）//B
以下描述中错误的是___
A.A行定义了一个对象,并调用缺省的构造函数
B.B行定义了一个对象,并调用缺省的构造函数
C.B行是一个函数的原型说明,函数名为C,函数没有参数,返回值
类型是Complex
D.A行和B行两行的意义不一样
8.设有下列对象定义;
classA
{
public:
inta,b;
}a1={1,2},a2,a3;
class
{
public:
inta,b;
}a4;
则以下正确的定义或赋值形式是___
A.a3=a2=a1;B.a4=a1;C.A*p=&a4;D.A&re=a4
9.下列描述中,___不是构造函数的特征
A.构造函数可以重载
B.必须显示为类定义一个构造函数
C.无须为构造函数指定返回值类型
D.构造函数在产生对象时由系统自己调用
10.下列有关析构函数的描述中，正确的是___A.析构函数的定义只能在类体内
B.析构函数可以有一个或多个参数
C.析构函数是在撤消对象时,系统自动调用的D.析构函数可以重载
11.以下关于构造函数和析构函数的描述中错误的是___
A.用户不定义缺省的构造函数,则系统自动生成一个缺省的构造函数
B.若用户不定义拷贝的构造函数,则系统自动生成一个拷贝的构造函数
C.若用户不定义析构函数,则系统自动生成一个析构函数
D.以上A错误,而B,C正确
12.定义复数类如下;
classComplex
{doublereal,image;
public:
Complex（doubler=0,doublei=0）{real=r;image=i;}
Complex（Complex&c）{real=c.real;image=c.image;}
};
若有Complexc1;//A
Complexc2（3,5）;//B
Complexc3（c2）;//C
c2=c1;//D则下列描述中正确的是___
A.C行和D行均调用了拷贝构造函数
B.C行调用了拷贝构造函数
C.B行调用了拷贝构造函数
D.A行调用了拷贝构造函数
13.classA
{intx,inty;
public;
A（inta,intb）{x=a;y=b;}
voidshow（）{cout<?
<voidset（inta,intb）{x=a;y=b;}
};
voidmain（）
{Aobj;
obj.set（3,5）;
obj.show（）;
}
对上述过程段，以下说法中，正确的是___A.编译时报错，程序无法运行
B.编译时无错，运行正常，输出3，5C.编译无错，运行时报错
D.编译时报警告错，但运行正常，输出3，5
14（在下列程序中，C类的数据成员中有一个A类对象和一个B类对象。
#includeclassA
{inta;
public:
A（intx=10）{a=x;}
intGetA（）{returna;}
};
classB
{intb;
public:
B（intx）{b=x;}
intGetB（）{returnb;}
};
classC{
intc;
Aaobj;
Bbobj;
public:
C（intx,inty,intz）:
aobj（y）,bobj（z）//E
{c=x;}
voidPrint（）
{cout<\t?
<\t?
<};
voidmain（）
{
Ccobj（3,6,8）;
cobj.Print（）;
}
程序在E行定义了构造函数，如果将该行改为下列中______选项
时，便会出现编译错误。
A.C（intx,inty,intz）:
aobj（z）,bobj（y）
B.C（intx,inty,intz）:
bobj（z）
C.C（intx,inty,intz）:
aobj（y）
D.C（intx,inty,intz）:
aobj（x）,bobj（y+z）
二（找错，运行结果
1.指出下列程序的错误:
#include
classA
{intx,y;
public:
A（）{x=y=0;}
A（inti=0,intj=0）{x=i,y=j;}
voidshow（）{cout<?
<};
voidmain（）
{
Aa1,a2（6,8）;错误:
//该程序有两个默认的构造函数
a1.show（）;
a2.show（）;
}
2.写出下列程序的运行结果:
#include
classA
{intx,y;
public:
A（）{x=y=0;cout<<”Defaultconstructorcalled.\n;}
A（inti,intj）
{x=i,y=jcout<~A（）{show（）;cout<<”Destructorcalled.\n”;}
voidshow（）{cout<?
<};
voidmain（）
{Aa1,a2（6,8）;
a1.show（）;
a2.show（）;
}
Defaultconstructorcalled.
constructorcalled.
0,0
6,8
6,8
Destructorcalled.
0,0
Destructorcalled.
3.根据以下两个方框中的内容，写出两个版本的运行结果:
#include
classA
{intx,y;
public:
A（inti=0,intj=0）
{x=i;y=j;
show（）;
cout<<”Constructorcalled.\n”;
}
A（A&a）;
~A（）{show（）;cout<<”Destructorcalled.\n”;}
voidset（inti=0,intj=0）{x=i;y=j;}
voidshow（）{cout<?
<?
;}
};
A:
:
A（A&a）
{x=a.x;y=a.y;show（）;cout<<”Copyconstructorcalled.\n”;}
A&fun（A&a）Afun（Aa）
{a.show（）;{a.show（）;
cout<a.set（3,7）;a.set（3,7）;
returna;returna;
}}
voidmain（）
{Aa1,a2（6,8）,a3（a2）,a4;
a4=fun（a3）;
a4.Show（）;
a3.Show（）;
cout<}
左边的答案:
0,0,Constructorcalled.6,8,Constructorcalled.6,8,Copyconstructorcalled.0,0,Constructorcalled.6,8,Copyconstructorcalled.6,8,
3,7,Copyconstructorcalled.3,7,Destructorcalled.3,7,Destructorcalled.3,7,6,8,
3,7,Destructorcalled.6,8,Destructorcalled.6,8,Destructorcalled.0,0,Destructorcalled.右边的答案:
0,0,Constructorcalled.6,8,Constructorcalled.6,8,Copyconstructorcalled.0,0,Constructorcalled.6,8,
3,7,3,7,
3,7,Destructorcalled.3,7,Destructorcalled.6,8,Destructorcalled.0,0,Destructorcalled.4.写出下列程序的运行结果
includeclassA
{intx,y;
public:
A（inti=0,intj=0）
{x=i,y=j;Show（）;cout<<”constructorcalled.\n”}
~A（）{Show（）;cout<<”destructorcalled.\n”;}
voidSet（inti=0,intj=0）{x=i,y=j;}
voidShow（）{cout<?
<A&fun（A&a）{a.Show（）;
cout<a.Set（3,7）;
returna;}
voidmain（）{Aa1,a2（6,8）,a3（a2）,a4=a1;
a4=fun（a3）;
a4.show（）;
cout<}
0,0,constructorcalled.6,8,constructorcalled.6,8,
3,7,
3,7,destructorcalled.3,7,destructorcalled.6,8,destructorcalled.0,0,destructorcalled.5.写出下列程序的运行结果
#includeclassComplex
{intreal,image;public:
Complex（intx=0,inty=0）{real=x;image=y;
Show（）;
cout<<”construct\n”;
}
~Complex（）
{Show（）;cout<
destruct\n.”;}
voidShow（）
{cout<
（„<?
<）?
;}voidPrint（）
{Show（）;cout<voidmain（）
{Complexc[5]={3,Complex（4）,Complex（）,Complex（5,6）};
for（inti=0;i<5;i++）c[i].Print（）;
cout<<”exitmain（）\n”;
}
（3,0）construct
（4,0）construct
（0,0）construct
（5,6）construct
（0,0）construct
（3,0）
（4,0）
（0,0）
（5,6）
（0,0）
exitmain（）
（0,0）destruct
.（5,6）destruct
.（0,0）destruct
.（4,0）destruct
.（3,0）destruct
6（写出下列程序的运行结果
#include
classTest
{intx;
public:
Test（inti=0）{x=i;}voidprint（）
{cout<.?
<voidmain（）
{Testt1（8）,t2（9）;
cout<<&t1<
?
<<&t2<t1.print（）;//B
t2print（）;//C
}
若A行的输出是0x0012FF7C,0X0012FF78，则B行和C行的输出是_8.0012FF7C,9_.0X0012FF78_______________________
7.写出下列程序的运行结果
#includeclassList
{
inta[10],n;
public:
List（inta[10],intn）{
List:
:
n=n;//List:
:
n表示数据成员n,以便与参数n区别
for（inti=0;iList:
:
a[i]=a[i];}
voidCopy（ListL）{if（this==&L）
cout<<”same1notcopy!
\n”;
else
{n=L.n;
for（inti=0;ia[i]=L.a[i];
cout<<”different!
copied!
\n”;
}
}
voidShow（）
{for（inti=0;i.?
;
cout<}
};
voidmain（）
{inta1[10]={1,2,3,},a2[10]={4,5,6,7,8};
ListL1（a1,3）,L2（a2,5）;
L1.Show（）;L2.Show（）;
L2.Copy（L1）;
L1.Show（）;
L2.Show（）;
L1.Copy（L1）;
L2.Copy（L2）;
L1.Show（）;
L2.Show（）;
}
1.2.3
4.5.6.7.8
different!
copied!
1.2.3
1.2.3
different!
copied!
different!
copied!
1.2.3
1.2.3
第二部分:
1.下列各函数,_____不是类成员函数
A.构造函数B.析构函数
C.友员函数D.拷贝初始化函数2.下列有关静态数据成员的描述中.____是错误的
A.说明静态数据成员时,前面要加修饰符static
B.静态数据成员要在类体外进行初始化
C.引用静态数据成员时,要在静态数据成员名前加<类名>和作用域
运算符
D.静态数据成员不是所属类的所有对象共有的3.以下关于友员函数的描述错误的是___
A.友员函数不是成员函数
B.友员函数加强了类的封装性
C.友员函数可以访问所属类的私有成员
D.友员函数的作用是提高程序的运行效率4.关于成员函数特征的下列描述中错误的是___
A.成员函数一定是内联函数
B.成员函数可以重载
C.成员函数可以设置参数的缺省值
D.成员函数可以是静态的
5.写出以下程序的运行结果
#include
classCount
{
staticintcount;
public:
Count（）{count++;cout<staticintGetC（）{returncount;}
~Count（）{count--;cout<};
intCount:
:
count;
voidmain（）
{
Countc1,c2,c3,c4;
cout<:
Getc（）<cout<<”exitmain\n”;
}
1234
4
exitmain
3210
题8.分析以下程序执行的结果
#includeclassSample
{
intA;
staticintB;
public:
Sample（inta）{A=a,B+=a;}staticvoidfunc（Samples）;};
voidSample:
:
func（Samples）{
cout<<"A="<intSample:
:
B=0;
voidmain（）
{
Samples1
（2）,s2（5）;
Sample:
:
func（s1）;
Sample:
:
func（s2）;
}
解:
本题说明了静态成员函数的使用方法。
其中的数据成员B是静态数据成员，求B之值
是在构造函数中进行的。
所以输出为:
A=2,B=7
A=5,B=7
注意:
静态成员函数与静态数据成员一样，也不是对象成员。
静态成员函数的调用不同于普通的成员函数。
在静态成员函数的实现中，引用类的非静态数据成员是通过对象进行的，如本题中s.A，引用类的静态数据成员是直接进行的，如本题中的B。
#include
classSample
{
intx,y;
public:
Sample（）{x=y=0;}
Sample（inta,intb）{x=a;y=b;}voiddisp（）
{
cout<<"x="<};
voidmain（）
{
Samples1,s2（1,2）,s3（10,20）;Sample*pa[3]={&s1,&s2,&s3};for（inti=0;i<3;i++）
pa[i]->disp（）;
}
解:
本题说明对象指针数组赋初值方法。
定义三个对象和一个对象指针数组，通过赋初值使后者的元素分别指向前面三个对象，然后使用for语句循环调用各个对象的disp（）成员函数。
所以输出为:
x=0,y=0
x=1,y=2
x=10,y=20
题7.分析以下程序的执行结果
#include
classSample
{
intn;
staticintsum;
public:
Sample（intx）{n=x;}
voidadd（）{sum+=n;}
voiddisp（）
{
cout<<"n="<};
intSample:
:
sum=0;//静态数据成员赋初值
voidmain（）
{
Samplea
（2）,b（3）,c（5）;
a.add（）;
a.disp（）;
b.add（）;
b.disp（）;
c.add（）;
c.disp（）;
}
解:
本题说明静态数据成员的使用方法。
在类中定义了一个静态数据成员sum，在main（）之前给它赋初值0，然后在main（）中定义了三个对象，并执行各自的add（）和disp（）方法。
所以输出为:
n=2,sum=2
n=3,sum=5
n=5,sum=10
注意:
静态数据成员脱离具体的对象独立存在，其存储单元不是任何对象存储空间的一部分，但逻辑上所有对象都共享这一存储单元，对静态数据成员的任何操作都会访问这一存储单元，从而影响这一存储单元的所有对象。
所以说静态数据成员不是对
象成员，在引用时不需要用对象名。
03.编写程序，调用传递引用的参数，实现两个字符串变量的交换。
例如开始:
char*ap="hello";
char*bp="howareyou?
";交换的结果使得ap和bp指向的内容分别为:
ap:
"howareyou?
"bp:
"hello"
解:
本题使用引用调用（实现由于字符串指针本身就是地址，这里可不使用引用参数，效果是一样的）。
程序如下:
#include#includevoidswap（char*&x,char*&y）//引用作为参数{
char*temp;
temp=x;x=y;y=temp;}
voidmain（）
{
char*ap="hello";
char*bp="howareyou?
";cout<<"ap:
"<"<cout<<"swapap,bp"<"<"<本程序的执行结果如下:
ap
升级会员 