ly新标准C++程序设计教材1120章课后题答案.docx
《ly新标准C++程序设计教材1120章课后题答案.docx》由会员分享，可在线阅读，更多相关《ly新标准C++程序设计教材1120章课后题答案.docx（69页珍藏版）》请在冰豆网上搜索。
ly新标准C++程序设计教材1120章课后题答案
新标准C++程序设计教材11—20章课后题答案
第11章:
1．简述结构化程序设计有什么不足，面向对象的程序如何改进这些不足.
答案:
结构化程序设计的缺点：
（1）用户要求难以在系统分析阶段准确定义,致使系统在交付使用时产生许多问题。
（2）用系统开发每个阶段的成果来进行控制，不适应事物变化的要求.
（3）系统的开发周期长.
面向对象的程序设计如何改进这些不足：
面向对象程序设计技术汲取了结构忧程序设计中好的思想,并将这些思想与一些新的、强大的理念相结台，从而蛤程序设计工作提供了一种全新的方法。
通常，在面向对象的程序设计风格中,会将一个问题分解为一些相互关联的子集，每个子集内部都包含了相关的数据和函数.同时会以某种方式将这些子集分为不同等级，而一个对象就是已定义的某个类型的变量。
2．以下说怯正确的是（）。
A.每个对象内部都有成员函数的实现代码
B.一个类的私有成员函数内部不能访问本类的私有成员变量
C。
类的成员函数之间可以互相调用
D.编写一个类时,至少要编写一个成员函数
答案：
C
3．以下对类A的定义正确的是（）。
A．classA｛B．classA{
private：
intv;intv;A＊next;
public：
voidFunc（）｛｝voidFunc（）{}
｝｝；
C．classA｛D.classA{
intv；intv;
public：
public：
voidFunc（）;Anext；
};voidFunc（）{}
A:
：
voidFunc（）{｝｝；
答案：
B
4．假设有以下类A：
classA{
public：
intfunc（inta）｛returna＊a;}
｝;
以下程序段不正确的是（）.
A．Aa；a。
func（5）；
B．A＊p=newA；p—〉func（5）;
C．Aa；A＆r=a;r.func（5）;
D．Aa,b;if（a！
=b）a.func（5）；
答案：
D
5．以下程序段不正确的是（A）.
A．intmain（）｛
classA｛intv;}
Aa;a.v=3;return0；
B．intmain（）｛
classA{public:
intv;A＊p；｝；
Aa；a。
p=＆a;return0；
C．intmain（）｛
classA｛public:
intv；};
A*p=newA;
p->v=4;deletep;
return0；
D.immain（）｛
classA{public:
intv;A*p;｝；
Aa:
a.p=newA;deletea.p;
return0;
答案：
A
6．实现一个学生信息处理程序。
输入：
姓名,年龄，学号（整数）.第一学年平均成绩·
第二学年平均成绩，第三学年平均成绩，第四学年平均成绩。
输出：
姓名,年龄，学号,
4年平均成绩。
例如：
输入：
Tom18781780809070
输出：
Tom，18,7817,80
要求实现一个代表学生的类，并非所有成员变量都是私有的。
答案:
＃include〈iostream>
＃include〈cstring〉
＃include//#includeusingnamespacestd；
classStudent｛
private:
intage,score1,score2,score3,score4；
charname［100]，num[100]；
doubleaverage;
public:
Student（charaname［］,intaage，charanum［］，intascore1，intascore2,intascore3,intascore4）｛
strcpy（name,aname）;
age=aage;
strcpy（num,anum）；
score1=ascore1;
score2=ascore2；
score3=ascore3；
score4=ascore4;
}
doublegetAverage（）{
return（score1+score2+score3+score4）/4;
｝
char*getName（）｛
returnname；
}
intgetAge（）{
returnage；
｝
char＊getNum（）{
returnnum；
｝
｝；
intmain（）｛
charname[100]，a，num[100］;
intage,score1，score2，score3，score4；
cin.getline（name，100，’’）;
cin>〉age;
//a=getchar（）;
cin。
getline（num，100，’'）；
cin>〉score1〉〉score2〉〉score3>〉score4;
Students（name,age,num,score1,score2,score3，score4）;
cout<〈s.getName（）〈〈”,"<〈s.getAge（）〈〈",”〈〈s。
getNum（）〈<"，”〈getAverage（）;
return0;
｝
第12章
1．以下说法中正确的是（）.
A．一个类一定会有无参构造函数
B．构造函数的返回值类型是void
C．一个类只能定义一个析构函数，但可以定义多个构造函数
D．一个类只能定义一个构造函数，但可以定义多个析构函数
答案：
C
2．对于强过new运算符牛成的对象（）。
A．程程序结束时自动析构
B．执行delete操作时才能析构
C．在包含new语句的函数返回时自动析构
D．在执行delete操作时会析构,如果没有执行delete操作，则在程序结束时自动析构
答案：
D
3．如果某函数的返回值是个对象，则该函数被调用时，返回的对象（）。
A．是通过复制构造函数初始化的
B．是通过无参构造函数初始化的
C．用哪个构造函数初始化取决于函数的return语句是怎么写的
D．不需要初始化
答案：
C
4．以下说法LE确的是（）。
A．在静态成员函数中可以调用同类的其他任何成员函数
B．const成员函数不能作用于非const对象
C．在静态成员函数中不能使用this指针
D．静态成员变量每个对象有各自的一份
答案：
C
5以下关于this指针的说法中不正确的是（）。
A．const成员函数内部不可以使用this指针
B．成员函数内的this指针，指向成员函数所作用的对象
C．在构造函数内部可以使用this指针
D．在析构函数内部可以使用this指针
答案：
A
6．请写出下面程序的输出结果.
classCSample{
intx；
public：
CSample（）｛cout<〈"C1"〈CSample（intn）｛
x=n;
cout〈<"C2，x=”<｝
};
intmain（）{
CSamplearray1［2］;
CSamplearray2[2]=｛6，8}；
CSamplearray3［2]=｛12｝；
CSample*array4=newCsample[3］;
Return0；
}
答案:
C1
C1
C2，x=6
C2，x=8;
C2,x=12
C1
C1
C1
C1
7．下面程序的输出结果是。
＃include〈iostream〉
usingnamespacestd;
classSample｛
public：
intv;
Sample（）｛}
Sample（intn）：
v（n）｛｝；
Sample（constSample＆x）｛v=2+x。
v；}
｝；
Sample&PrintAndDouble（Sampleo）
｛
cout<〈o。
v；
o。
v=2*o。
v；
returno;
}
intmain（）
{
Samplea（5）;
Sampleb=a;
Samplec=PrintAndDouble（b）；
cout<cout〈〈c。
v<//cout<〈hex〈Sampled；
d=a；
cout〈v;
return0；
}
答案：
9
20
5
8．请写出下面程序的运行结果:
4,6
请填空：
#includeusingnamespacestd;
classA{
intval；
public:
A（intn）｛
val=n；
}
intGetVal（）｛
returnval;
｝
};
classB:
publicA{
private:
intval；
public：
B（intn）：
__________｛
};
intGetVal（）{
returnval;
}
};
intmain（）{
Bb1
（2）；
cout<〈b1。
GetVal（）〈<","<〈b1.A:
：
GetVal（）<<"\n”;
return0；
｝
答案：
Val（4），A（6）
9．下面程序的输出结果是
0
5
请填空：
＃includeusingnamespacestd；
classA{
public:
intval；
A（_______）{
val=n；
｝
______GetObj（）｛
return_________;
｝
｝;
intmain（）{
Aa;
cout〈〈a.val<〈endl；
a.GetObj（）=5；
cout〈〈a.val〈〈endl;
｝
答案：
intn=0
A＆
*this
10．下面程序的输出结果是：
10
请补充Sample类的成员函数，不能增加成员变量
#includeusingnamespacestd；
classSample{
public:
intv；
Sample（intn）：
v（n）｛
｝；
______________________
Sample（Sample＆obj）｛
this->v=2＊obj。
v；
｝；
};
intmain（）{
Samplea（5）；
Sampleb=a;
cout<v;
return0；
}
答案：
Sample（Sample＆obj）{
This->v=2*obj。
v;
};
11.下面程序的输出结构是：
5，5
5，5
请填空：
#include〈iostream〉
usingnamespacestd；
classBase{
public:
intk;
Base（intn）：
k（n）｛
}
｝;
classBig｛
public:
intv;
Baseb;
Big__________{
}；
Big___________｛
}；
｝；
intmain（）{
Biga1（5）；
Biga2=a1;
cout〈〈a1。
v〈〈”，”<〈a1.b。
k<〈endl；
cout〈〈a2。
v<〈”,”〈return0；
}
答案：
（intn）:
v（n）,b（n）
（Big＆x）：
v（x.v），b（x.b。
k）
12．完成附录“魔静世界大作业”中提到的第一阶段作业
（省略）
第13章
1如果将运算符“［]”重载为某个类的成员运算符（也即成员函数）,则该成员函数的
参数个数是（）。
A．0个B。
1个C.2个D．3个
答案：
B
2．如果将运算符“*”重载为菜个类的成员运算符（也即成员函数），则该成员函数的
参数个数是（）。
A．0个B.1个C。
2个D.0个或1个均可
答案:
D
3．下面程序的输出是
3+4i
5+6i
请补充Complex类的成员函数，不能加成员变量。
#include〈iostream〉
＃include〈cstring〉
usingnamespacestd;
classComplex{
private:
doubler,i；
public:
voidPrint（）｛
cout〈〈r〈<"+"<}
//在这里补充
//在这里补充
｝；
intmain（）｛
Complexa；
a=”3+4i”；
a。
Print（）；
a=”5+6i";
a。
Print（）;
return0；
}
答案：
Complex＆operator=（constchart［］）｛
if（!
t）{
r=0.0;i=0.0;
}else｛
r=t［0］—'0'；
i=t［2］-'0';
｝return＊this;
}
4．下面的Mylnt类只有一个成员变量。
Mylnt类内部的部分代码被隐藏了。
假设下
面的程序能编译通过，且输出结果是：
4,1
请写出被隐藏的部分（要求编写的内容必须是能全部救进Mylnt类内部的，Mylnt的
成员函数不允许使用静态变量）。
#include
usingnamespacestd；
classMyInt｛
intnVal;
public：
MyInt（intn）｛
nVal=n；
}
intReturnVal（）｛
returnnVal;
｝
//在这里补充
//在这里补充
};
intmain（）{
MyIntobjInt（10）;
objInt-2—1-3；
cout〈ReturnVal（）;
cout<〈”,"；
objInt-2—1;
cout<〈objInt。
ReturnVal（）;
return0;
}
答案：
MyInt&operator-（inti）{
nVal-=i；
return*this；
}
5．下面的程序输出结果是
（4,5）
（7,8）
请填空：
＃include〈iostream〉
usingnamespacestd;
classPoint｛
private:
intx;
inty;
public：
Point（intx_，inty_）：
x（x_），y（y_）{
};
//
___________________________
}；
___________operator〈<（________,constPoint&p）{
__________________________;
Return_____;
｝
intmain（）｛
cout<〈Point（4,5）<return0;
｝
答案：
friendostream&operator〈<（ostream&o，constPoint&p）;
friendostream&
ostream＆o
o〈〈”（”<〈p。
x〈〈”，"〈〈p.y〈<"）”<〈endl
o
6．编写一个二维数组类Array2,使得程序的输出结果是
0，1,2，3,
4，5，6,7,
8,9，10，11,
next
0,1，2，3,
4，5，6,7,
8，9,10，11,
答案:
＃include#include
usingnamespacestd；
classArray2
{
private：
introw;//数组行数
intcolumn;//数组列数
int*ptr;//指向二维数组的指针
public:
Array2（）
{
ptr=NULL；
｝
Array2（intparaRow,intparaColumn）:
row（paraRow），column（paraColumn）
｛
ptr=newint［row＊column]；
}
Array2（Array2＆a）：
row（a.row）,column（a.column）
｛
ptr=newint[row*column];
memcpy（ptr,a.ptr，sizeof（int）＊row*column）；
}
Array2&operator=（constArray2&a）
｛
if（ptr）delete[］ptr；
row=a.row；
column=a。
column;
ptr=newint[row＊column］；
memcpy（ptr，a。
ptr，sizeof（int）*row*column）;
return＊this；
}
～Array2（）
｛
if（ptr）delete[］ptr;
｝
int＊operator[]（inti）
｛
returnptr+i＊column;
}
int&operator（）（inti，intj）
｛
returnptr［i*column+j];
｝
}；
intmain（）
{
Array2a（3，4）；
inti,j;
for（i=0；i〈3;++i）
for（j=0；j〈4；j++）
a［i］［j]=i*4+j;
for（i=0；i<3；++i）{
for（j=0；j<4；j++）｛
cout〈〈a（i,j）<〈",”；
｝
cout〈｝
cout〈〈”next”<〈endl;
Array2b；b=a;
for（i=0；i〈3；++i）{
for（j=0；j<4；j++）｛
cout〈}
cout〈〈endl；
}
return0；
}
7．编写一个Mystring类，使得程序的输出结果是
1.abcd—efgh—abcd-
2。
abcd—
3.
4.abcd—efgh-
5.efgh-
6.c
7.abcd—
8.ijAl—
9。
ijAl-mnop
10.qrst-abcd—
11。
abcd-qrst—abcd-uvwxyz
about
big
me
take
abcd
qrst-abcd-
答案：
#include〈cstdlib>
＃include〈iostream〉
#include〈string〉
#include
usingnamespacestd；
classMyString：
publicstring{
public：
MyString（）:
string（）{｝;
MyString（constchar*s）：
string（s）{｝；
MyString（conststring&s）：
string（s）{｝;
MyStringoperator（）（ints,intl）｛
returnthis-〉substr（s，l）；
}
｝;
intmain（）
｛
MyStrings1（"abcd-”）,s2，s3（”efgh—"），s4（s1）;
MyStringSArray[4］=｛”big”，"me”，”about","take"};
cout〈<"1。
"〈〈s1<〈s2<〈s3〈〈s4<〈endl；
s4=s3；
s3=s1+s3；
cout〈<”2."<〈s1〈〈endl；
cout<〈"3."〈〈s2<〈endl;
cout〈〈"4."〈cout〈<”5。
"<cout〈<”6。
"<〈s1［2］<〈endl；
s2=s1;
s1=”ijkl-”；
s1［2］='A’;
cout<〈"7."<cout<〈"8.”<s1+=”mnop";
cout<〈”9."<〈s1<〈endl；
s4="qrst-"+s2;
cout〈〈”10.”〈s1=s2+s4+”uvw”+”xyz"；
cout〈〈”11。
”<sort（SArray，SArray+4）;
for（inti=0;i〈4;i++）
cout<//s1的从下标0开始长度为4的子串
cout<〈s1（0，4）〈//s1的从下标5开始长度为10的子串
cout<〈s1（5，10）〈〈endl；
return0;
｝
第14章
1．以下说法不正确的是（假设在公有派生情况下）（）。
A．可以将基类对象赋值给派生类对象
B．可以
升级会员 