C++第四版习题解答 下.docx
《C++第四版习题解答 下.docx》由会员分享，可在线阅读，更多相关《C++第四版习题解答 下.docx（106页珍藏版）》请在冰点文库上搜索。
C++第四版习题解答下
《C++程序设计基础》（第4版）（下）
习题与解答
第6章类与对象
6.1选择题
1．若有以下说明，则在类外使用对象objX成员的正确语句是（C）。
classX
{
inta;
voidfun1（）;
public:
voidfun2（）;
};
XobjX;
（A）objX.a=0;（B）objX.fun1（）;（C）objX.fun2（）;（D）X:
:
fun1（）;
2．若有以下说明，则对n的正确访问语句是（B）。
classY
{
//…;
public:
staticintn;
};
intY:
:
n;
YobjY;
（A）n=1;（B）Y:
:
n=1;（C）objY:
:
n=1;（D）Y?
>n
3．若有以下类Z说明，则函数fStatic中访问数据a错误的是（C）。
classZ
{
staticinta;
public:
staticvoidfStatic（Z&）;
};
intZ:
:
a=0;
ZobjZ;
（A）voidZ:
:
fStatic（）{objZ.a=1;}
（B）voidZ:
:
fStatic（）{a=1;}
（C）voidZ:
:
fStatic（）{this?
?
a=0;}
（D）voidZ:
:
fStatic（）{Z:
:
a=0;}
4．若有以下类W说明，则函数fConst的正确定义是（A）。
classW
{
inta;
public:
voidfConst（int&）const;
};
（A）voidW:
:
fConst（int&k）const{k=a;}
（B）voidW:
:
fConst（int&k）const{k=a++;}
（C）voidW:
:
fConst（int&k）const{cin>>a;}
（D）voidW:
:
fConst（int&k）const{a=k;}
5．若有以下类T说明，则函数fFriend的错误定义是（C）。
classT
{
inti;
friendvoidfFriend（T&,int）;
};
（A）voidfFriend（T&objT,intk）{objT.i=k;}
（B）voidfFriend（T&objT,intk）{k=objT.i;}
（C）voidT:
:
fFriend（T&objT,intk）{k+=objT.i;}
（D）voidfFriend（T&objT,intk）{objT.i+=k;}
6．在类定义的外部，可以被访问的成员有（C）。
（A）所有类成员（B）private或protected的类成员
（C）public的类成员（D）public或private的类成员
7．关于this指针的说法正确的是（C）。
（A）this指针必须显式说明（B）定义一个类后，this指针就指向该类
（C）成员函数拥有this指针（D）静态成员函数拥有this指针
8．说明一个类的对象时，系统自动调用（B）；撤销对象时，系统自动调用（C）。
（A）成员函数（B）构造函数（C）析构函数（D）友元函数
9．下面对构造函数的不正确描述是（C）。
（A）用户定义的构造函数不是必须的（B）构造函数可以重载
（C）构造函数可以有参数，也可以有返回值（D）构造函数可以设置默认参数
10．下面对析构函数的正确描述是（C）。
（A）系统在任何情况下都能正确析构对象（B）用户必须定义类的析构函数
（C）析构函数没有参数，也没有返回值（D）析构函数可以设置默认参数
11．关于类的静态成员的不正确描述是（D）。
（A）静态成员不属于对象，是类的共享成员
（B）静态数据成员要在类外定义和初始化
（C）静态成员函数不拥有this指针，需要通过类参数访问对象成员
（D）只有静态成员函数可以操作静态数据成员
12．在下列选项中，（C）不是类的成员函数。
（A）构造函数（B）析构函数（C）友元函数（D）复制构造函数
13．下面对友元的错误描述是（D）。
（A）关键字friend用于声明友元
（B）一个类中的成员函数可以是另一个类的友元
（C）友元函数访问对象的成员不受访问特性影响
（D）友元函数通过this指针访问对象成员
14．若classB中定义了一个classA的类成员Aa，则关于类成员的正确描述是（C）。
（A）在类B的成员函数中可以访问A类的私有数据成员
（B）在类B的成员函数中可以访问A类的保护数据成员
（C）类B的构造函数可以调用类A的构造函数做数据成员初始化
（D）类A的构造函数可以调用类B的构造函数做数据成员初始化
6.2阅读下列程序，写出运行结果
1．
#include
usingnamespacestd;
classA
{
public:
intf1（）;
intf2（）;
voidsetx（intm）{x=m;cout<voidsety（intn）{y=n;cout<intgetx（）{returnx;}
intgety（）{returny;}
private:
intx,y;
};
intA:
:
f1（）
{returnx+y;}
intA:
:
f2（）
{returnx-y;}
intmain（）
{
Aa;
a.setx（10）;a.sety（5）;
cout<cout<}
【解答】
10
5
105
155
2．
#include
usingnamespacestd;
classT
{
public:
T（intx,inty）
{
a=x;b=y;
cout<<"调用构造函数1."<cout<}
T（T&d）
{
cout<<"调用构造函数2."<cout<}
~T（）{cout<<"调用析构函数."<intadd（intx,inty=10）{returnx+y;}
private:
inta,b;
};
intmain（）
{
Td1（4,8）;
Td2（d1）;
cout<}
【解答】
调用构造函数1.
48
调用构造函数2.
48
20
调用析构函数.
调用析构函数.
3．
#include
usingnamespacestd;
classT
{
public:
T（intx）{a=x;b+=x;};
staticvoiddisplay（Tc）{cout<<"a="<private:
inta;
staticintb;
};
intT:
:
b=5;
intmain（）
{
TA（3）,B（5）;
T:
:
display（A）;
T:
:
display（B）;
}
【解答】
a=3b=13
a=5b=13
4．
#include
usingnamespacestd;
#include
classPoint
{
public:
Point（floatx,floaty）
{a=x;b=y;cout<<"点（"<frienddoubled（Point&A,Point&B）
{returnsqrt（（A.a-B.a）?
（A.a-B.a）+（A.b-B.b）?
（A.b-B.b））;}
private:
doublea,b;
};
intmain（）
{
Pointp1（2,3）;
cout<<"到";
Pointp2（4,5）;
cout<<"的距离是：
"<}
【解答】
点（3，4）到点（4，5）的距离是：
2.82843
5．
#include
usingnamespacestd;
classA
{
public:
A（）{a=5;}
voidprinta（）{cout<<"A:
a="<private:
inta;
friendclassB;
};
classB
{
public:
voiddisplay1（At）
{t.a++;cout<<"display1:
a="<voiddisplay2（At）
{t.a--;cout<<"display2:
a="<};
intmain（）
{
Aobj1;
Bobj2;
obj1.printa（）;
obj2.display1（obj1）;
obj2.display2（obj1）;
obj1.printa（）;
}
【解答】
A:
a=5
display1:
a=6
display2:
a=4
A:
a=5
6．
#include
usingnamespacestd;
classA
{
public:
A（intx）:
a（x=0）{}
voidgetA（int&A）{A=a;}
voidprintA（）{cout<<"a="<private:
inta;
};
classB
{
public:
B（intx,inty）:
aa（x=0）{b=y;}
voidgetAB（int&A,int&outB）{aa.getA（A）;outB=b;}
voidprintAB（）{aa.printA（）;cout<<"b="<private:
Aaa;
intb;
};
intmain（）
{
AobjA;
intm=5;
objA.getA（m）;
cout<<"objA.a="<cout<<"objB:
\n";
BobjB;
objB.getAB（12,56）;
objB.printAB（）;
}
【解答】
objA:
a=5
objB:
a=12
b=56
6.3思考题
1．结构与类有什么区别？
如果把程序中定义结构的关键字struct直接改成class，会有什么问题？
用教材中的一个例程试试看，想一想做什么修改能使程序正确运行？
【解答】
结构是数据的封装，类是数据和操作的封装。
可以把结构看成是类的特例。
结构和类都可以用关键字struct或class定义。
区别是，struct定义的结构或类的全部成员都是公有的，用class定义的结构或类不做声明的成员是私有的。
若把struct改成class，只需要把全部成员定义为public就可以了。
2．有说明：
classA
{
inta;
doublex;
public:
funMember（）;
};
Aa1,a2,a3;
编译器为对象a1、a2和a3开辟了什么内存空间？
它们有各自的funMember函数的副本吗？
C++通过什么机制调用类的成员函数？
【解答】
开辟的存储空间有a1.a,a1.x,a2.a,a2.x,a3.a,a3.x。
各对象没有funMember函数的副本，C++通过this指针调用成员函数。
3．C++提供了系统版本的构造函数，为什么还需要用户自定义构造函数？
编写一个验证程序，说明自定义构造函数的必要性。
【解答】
类的默认构造函数可以建立基本类型数据成员的存储空间。
基于以下两个原因，需要用户定义构造函数：
（1）对数据成员的值做指定初始化；
（2）类的数据是由指针管理的堆。
程序略。
4．试从定义方式、访问方式、存储性质和作用域4个方面来分析类的一般数据成员和静态数据成员的区别，并编写一个简单程序验证它。
【解答】
定义方式
访问方式
存储性质
作用域
一般数据成员
类中定义
对象.数据成员
局部数据
由访问属性public,protected,private决定
静态数据成员
类中声明，类外定义
对象.数据成员
类:
:
数据成员
全局数据
程序略。
5．试从定义方式、调用方式两个方面来分析常成员函数、静态成员函数和友元函数的区别。
考察例6-15，若classGoods的指针域：
Goods?
next;
被声明为私有（private）成员，程序会出现什么错误？
做什么最小修改能使程序正确运行？
【解答】
定义方式
调用方式
常成员函数
函数原型以const做后缀
this指针被约束为指向常量的常指针
与一般成员函数调用形式相同
对数据成员只读
静态成员函数
以static做函数原型前缀
没有this指针
通过类或对象调用
用于操作静态数据成员
友员函数
以friend做函数原型前缀
没有this指针
通过参数访问对象
可以访问对象的不同属性的成员
在例6-15中，若把next声明为私有数据成员，只须把有关指针操作的函数定义为友员函数就可以了：
friendvoidpurchase（Goods*&f,Goods*&r,intw）;
friendvoidsale（Goods*&f,Goods*&r）;
6．设有：
classM
{
public:
inta;
};
classN
{
public:
Mm;
intb;
voidfun（）
{/?
…?
/}
};
intmain（）
{
Nn;
N?
p=&n;
/?
…?
/
}
描述在N:
:
fun中如何访问M类的数据成员a？
在main函数中又如何访问对象n的全部数据成员？
【解答】
在N:
:
fun中访问M类的数据成员a的形式是：
m.a
在main函数中访问M类的数据成员的形式是：
n.b，n.m.a
6.4编程题
1．定义一个Book（图书）类，在该类定义中包括以下数据成员和成员函数。
数据成员：
bookname（书名）、price（价格）和number（存书数量）。
成员函数：
display（）显示图书的情况；borrow（）将存书数量减1，并显示当前存书数量；restore（）将存书数量加1，并显示当前存书数量。
在main函数中，要求创建某一种图书对象，并对该图书进行简单的显示、借阅和归还管理。
【解答】
#include
usingnamespacestd;
classBook
{
public:
voidsetBook（char*,double,int）;
voidborrow（）;
voidrestore（）;
voiddisplay（）;
private:
charbookname[40];
doubleprice;
intnumber;
};
//在类外定义Book类的成员函数
voidBook:
:
setBook（char*name,doublepri,intnum）
{
strcpy（bookname,name）;
price=pri;
number=num;
}
voidBook:
:
borrow（）
{
if（number==0）
{
cout<<"已没存书，退出！
"<abort（）;
}
number=number-1;
cout<<"借一次，现存书量为：
"<}
voidBook:
:
restore（）
{
number=number+1;
cout<<"还一次，现存书量为：
"<}
voidBook:
:
display（）
{
cout<<"存书情况：
"<<<"bookname:
"<<<"price:
"<<<"number:
"<}
intmain（）
{
charflag,ch;
Bookcomputer;
computer.setBook（"c++程序设计基础",32,1000）;
computer.display（）;
ch='y';
while（ch=='y'）
{
cout<<"请输入借阅或归还标志（b/r）：
";
cin>>flag;
switch（flag）
{
case'b':
computer.borrow（）;break;
case'r':
computer.restore（）;
}
cout<<"是否继续？
（y/n）";
cin>>ch;
}
computer.display（）;
}
2．定义一个Box（盒子）类，在该类定义中包括以下数据成员和成员函数。
数据成员：
length（长）、width（宽）和height（高）。
成员函数：
构造函数Box，设置盒子的长、宽和高3个初始数据；成员函数setBox对数据成员置值；成员函数volume计算盒子的体积。
在main函数中，要求创建Box对象，输入长、宽、高，输出盒子的体积。
【解答】
#include
usingnamespacestd;
classBOX
{
public:
BOX（doublel,doublew,doubleh）
{length=l;
width=w;
height=h;
}
voidvolume（）
{cout<<"volume="<}
private:
doublelength,width,height;
};
intmain（）
{
BOXbox1（1,3,5）;
box1.volume（）;
BOXbox2（2,4,6）;
box2.volume（）;
}
3．定义一个Student类，在该类定义中包括：
一个数据成员（分数score）及两个静态数据成员（总分total和学生人数count）；成员函数scoretotalcount（doubles）用于设置分数、求总分和累计学生人数；静态成员函数sum（）用于返回总分；静态成员函数average（）用于求平均值。
在main函数中，输入某班同学的成绩，并调用上述函数求全班学生的总分和平均分。
【解答】
#include
usingnamespacestd;
classstudent
{
public:
voidscoretotalcount（doubles）
{
score=s;
total=total+score;
count++;
}
staticdoublesum（）
{
returntotal;
}
staticdoubleaverage（）
{
returntotal/count;
}
private:
doublescore;
staticdoubletotal;
staticdoublecount;
};
doublestudent:
:
total=0;
doublestudent:
:
count=0;
intmain（）
{
inti,n;doubles;
cout<<"请输入学生人数：
";
cin>>n;
studentstu;
for（i=1;i<=n;i++）
{
cout<<"请输入第"<";
cin>>s;
stu.scoretotalcount（s）;}
cout<<"总分：
"<:
sum（）<cout<<"平均分：
"<:
average（）<}
4．定义一个表示点的结构类型Point和一个由直线方程y=ax+b确定的直线类Line。
结构类型Point有两个成员x和y，分别表示点的横坐标和纵坐标。
Line类有两个数据成员a和b，分别表示直线方程中的系数。
Line类有一个成员函数print用于显示直线方程。
友元函数setPoint（Line&l1,Line&l2）用于求两条直线的交点。
在main函数中，建立两个直线对象，分别调用print函数显示两条直线的方程，并调用函数setPoint求这两条直线的交点。
【解答】
#include
usingnamespacestd;
structpoint
{
doublex;doubley;
};
classline
{
public:
line（doubleu,doublev）
{
a=u;b=v;
}
voidprint（）
{
cout<<"y="<}
friendpointsetpoint（line
升级会员 