ly新标准C++程序设计教材1120章课后题答案.docx
《ly新标准C++程序设计教材1120章课后题答案.docx》由会员分享，可在线阅读，更多相关《ly新标准C++程序设计教材1120章课后题答案.docx（56页珍藏版）》请在冰豆网上搜索。
ly新标准C++程序设计教材1120章课后题答案
ly-新标准C++程序设计教材11-20章课后题答案
新标准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
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
usingnamespacestd;
classSample{
public:
intv;
Sample（）{}
Sample（intn）:
v（n）{};
Sample（constSample&x）{v=2+x.v;}
};
Sample&PrintAndDouble（Sampleo）
{
cout<o.v=2*o.v;
returno;
}
intmain（）
{
Samplea（5）;
Sampleb=a;
Samplec=PrintAndDouble（b）;
cout<cout<//cout<Sampled;
d=a;
cout<return0;
}
答案：
9
20
5
8．请写出下面程序的运行结果:
4,6
请填空：
#include
usingnamespacestd;
classA{
intval;
public:
A（intn）{
val=n;
}
intGetVal（）{
returnval;
}
};
classB:
publicA{
private:
intval;
public:
B（intn）:
__________{
};
intGetVal（）{
returnval;
}
};
intmain（）{
Bb1
（2）;
cout<:
GetVal（）<<"\n";
return0;
}
答案：
Val（4）,A（6）
9．下面程序的输出结果是
0
5
请填空：
#include
usingnamespacestd;
classA{
public:
intval;
A（_______）{
val=n;
}
______GetObj（）{
return_________;
}
};
intmain（）{
Aa;
cout<a.GetObj（）=5;
cout<}
答案：
intn=0
A&
*this
10．下面程序的输出结果是：
10
请补充Sample类的成员函数，不能增加成员变量
#include
usingnamespacestd;
classSample{
public:
intv;
Sample（intn）:
v（n）{
};
______________________
Sample（Sample&obj）{
this->v=2*obj.v;
};
};
intmain（）{
Samplea（5）;
Sampleb=a;
cout<return0;
}
答案：
Sample（Sample&obj）{
This->v=2*obj.v;
};
11.下面程序的输出结构是：
5，5
5，5
请填空：
#include
usingnamespacestd;
classBase{
public:
intk;
Base（intn）:
k（n）{
}
};
classBig{
public:
intv;
Baseb;
Big__________{
};
Big___________{
};
};
intmain（）{
Biga1（5）;
Biga2=a1;
cout<cout<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
#include
usingnamespacestd;
classComplex{
private:
doubler,i;
public:
voidPrint（）{
cout<}
//在这里补充
//在这里补充
};
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<cout<<",";
objInt-2-1;
cout<return0;
}
答案：
MyInt&operator-（inti）{
nVal-=i;
return*this;
}
5．下面的程序输出结果是
（4,5）
（7,8）
请填空：
#include
usingnamespacestd;
classPoint{
private:
intx;
inty;
public:
Point（intx_,inty_）:
x（x_）,y（y_）{
};
//
___________________________
};
___________operator<<（________,constPoint&p）{
__________________________;
Return_____;
}
intmain（）{
cout<return0;
}
答案：
friendostream&operator<<（ostream&o,constPoint&p）;
friendostream&
ostream&o
o<<"（"<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<}
cout<}
cout<<"next"<Array2b;b=a;
for（i=0;i<3;++i）{
for（j=0;j<4;j++）{
cout<}
cout<}
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
#include
#include
#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."<s4=s3;
s3=s1+s3;
cout<<"2."<cout<<"3."<cout<<"4."<cout<<"5."<cout<<"6."<s2=s1;
s1="ijkl-";
s1[2]='A';
cout<<"7."<cout<<"8."<s1+="mnop";
cout<<"9."<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的从下标5开始长度为10的子串
cout<return0;
}
第14章
1．以下说法不正确的是（假设在公有派生情况下）（）。
A．可以将基类对象赋值给派生类对象
B．可以将派生类对象的地址赋值给基类指针
c．可以将派生类对象赋值给基类的引用
D．可以将派生类对象赋值给基类对象
答案：
A
2．写出下面程序的输出结果。
#include
usingnamespacestd;
classB{
public:
B（）{
cout<<"B_Con"<}
~B（）{
cout<<"B_Des"<}
};
classC:
publicB{
public:
C（）{
cout<<"C_Con"<}
~C（）{
cout<<"C_Des"<}
};
intmain（）{
C*pc=newC;
deletepc;
return0;
}
答案：
B_Con
C_Con
C_Des
B_Des
3．写出下面程序的输出结果。
#include
usingnamespacestd;
classBase{
public:
intval;
Base（）{
cout<<"BaseConstructor"<}
~Base（）{
cout<<"BaseDestructor"<}
};
classBase1:
virtualpublicBase{
};
classBase2:
virtualpublicBase{
};
classDerived:
publicBase1,publicBase2{
};
intmain（）{
Derivedd;
return0;
}
答案：
BaseConstructor
BaseDestructor
4．按照第13章的第7题的要求编写MyString类，但MyString类必须是从stnng类派生而来。
提示1：
如果将程序中所有”MyString”用“string“替换，那么题目的程序除了最后两条语句无法编译通过外，其他语句都没有问题，而且输出和前面的结果吻合。
也就是说，MyString类对string类的功能扩充只能体现在最后两条语句上面。
提示2：
string类有一个成员函数stringsubstr（intstart,intlength）,能够求从start开始位置，长度为length的字串
答案（疑惑）
classMyString:
publicstring{
public:
MyString（）:
string（）{};
MyString（constchar*s）:
string（s）{};
MyString（conststring&s）:
string（s）{};
MyStringoperator（）（ints,intl）{
returnthis->substr（s,l）;
}
};
5.完成附魔兽世界作业中的的二阶段。
（省略）
第15章
1．以下说法正确的是（）
A.在虚函数中不能使用this指针
B.在构造甬数中调用虚函数，不是动态联编
C.抽象类的成员函数都是纯虚函数
D.构造函数和析构函数都不是虚构函数
答案：
B
2．写出下面程序的输出结果
#include
usingnamespacestd;
classA{
public:
A（）{
}
virtualvoidfunc（）{
cout<<"A:
:
func"<}
~A（）{
}
virtualvoidfund（）{
cout<<"A:
:
fund"<}
};
classB:
publicA{
public:
B（）{
func（）;
}
voidfun（）{
func（）;
}
~B（）{
fund（）;
}
};
classC:
publicB{
public:
C（）{}
voidfunc（）{
cout<<"C:
:
func"<}
~C（）{
fund（）;
}
voidfund（）{
cout<<"C:
:
fund"<}
};
intmain（）{
Cc;
retur
升级会员 