C++习题册.docx
《C++习题册.docx》由会员分享，可在线阅读，更多相关《C++习题册.docx（36页珍藏版）》请在冰豆网上搜索。
C++习题册
《面向对象程序设计》学习辅导资料之
习题册
班级：
姓名：
学号：
江苏·淮阴工学院·计算机工程系
二○○八年九月一日
习题1绪论
查阅资料，回答下列问题：
1.什么是面向对象程序设计？
简述其基本思想。
解：
所谓面向对象是指以对象为中心，分析、设计及构造应用程序的机制。
面向对象程序设计可以被视作一种在程序中包含各种独立而又互相调用的单位和对象的思想，这与传统的思想刚好相反：
传统的面向过程程序设计主张将程序看作一系列函数的集合，或者直接就是一系列对电脑下达的指令，面向对象程序设计方法是指用面向对象的方法指导程序设计的整个过程。
2.什么是软件危机？
为什么说面向对象程序设计是软件设计方法的一场划时代革命？
解：
落后的软件生产方式无法满足迅速增长的计算机软件需求，从而导致软件开发与维护过程中出现一系列严重问题的现象。
随着信息系统的加速发展，应用程序日趋复杂化和大型化。
传统的软件开发技术难以满足发展的新要求。
20世纪80年代后，面向对象的程序设计（ObjectOrientProgramming，OOP）技术日趋成熟并逐渐地为计算机界所理解和接受。
面向对象的程序设计方法和技术是目前软件研究和应用开发中最活跃的一个领域。
3.目前都有哪些程序设计语言支持面向对象的设计理念与方法？
至少举三种语言，并作简要比较与分析。
解：
BASIC语言：
易学、易懂、易记、易用,是初学者的入门语言,也可以作为学习其他高级语言的基础。
BASIC有解释方式和编译方式两种翻译程序。
PASCAL语言：
具有大量的控制结构,充分反映了结构化程序设计的思想和要求,直观易懂,使用灵活,既可用于科学计算,又能用来编写系统软件,应用范围日益广泛。
通用编程语言C：
使用C语言编写程序,既感觉到使用高级语言的自然,也体会到利用计算机硬件指令的直接,程序员无需卷入汇编语言的繁琐。
4.简述下列各种传统软件开发方法存在的主要问题：
（1）面向过程程序设计方法；
（2）“瀑布”模型的过程设计方法；
（3）结构化设计方法；
（4）抽象数据类型方法；
（5）快速原型方法。
解：
1.不易于大系统的开发
2.在项目各个阶段之间极少有反馈。
只有在项目生命周期的后期才能看到结果。
通过过多的强制完成日期和里程碑来跟踪各个项目阶段。
3.用户素质或系统分析员和管理者之间的沟通问题；开发周期长，难于适应环境变化；结构化程度较低的系统，在开发初期难以锁定功能要求
5.一般不考虑运行效率，也不考虑系统的健壮性，出错处理也考虑不多，它的目的只是为了实际描述概念中的结构，使用户能够检测与其概念的一致性和概念的可用性
习题2类与对象
1.什么是类作用域？
什么是对象作用域？
有何区别？
解：
类的作用域是指类成员的有效范围，他是指在类的定义中由一对花括号所括起来的部分。
对象作用域指对象的有效作用范围。
2.类成员的三种访问控制属性（公有、私有、保护）各有什么特点?
解：
Public：
不但可以被类中成员函数访问，还可以在类的外部，通过类的对象进行访问。
Protected：
除了类中成员函数可以访问，该类的派生类的成员也可访问，但不能在类的
外部，通过类的对象进行访问。
Private：
只能被该类的成员函数访问，不能在类的外部，通过类的对象进行访问。
3.类的构造函数与析构函数的功能是什么？
有何特征？
解：
构造函数：
用来在创建对象时初始化对象；构造函数与析构函数的名字必须与类同名;构造函数不指定类型说明，它有隐含的返回值，该值由系统内部使用。
可以有一个参数，也可以有多个参数，即构造函数可以重载。
函数体可以写在类体内，也可以写在类体外。
程序不能直接调用构造函数，在创建对象时系统自动调用构造函数
析构函数：
在对象的生存期即将结束的时刻，由编译系统自动调用来完成一些清理工作。
它的调用完成之后，对象也就消失了，相应的内存空间也被释放。
析构函数不指定数据类型，也没有参数。
一个类中只能定义一个析构函数。
析构函数是成员函数，函数体可写在类体内，也可写在类体外。
析构函数可以被调用，也可以被系统调用。
析构函数加前缀‘~’。
4.仔细阅读下面的程序段，若有错误，则请找出错误，说明原因，并给出修改方案。
（1）
解：
一、a1,a2默认是私有的，所以在类外不能访问。
将其设为public
二、构造函数不对，
one（intx1=0,intx2=0）
{
a1=x1;
a2=x2;
}
#include
classone
{
inta1,a2;
public:
one（intx1=0,x2=0）;
};
voidmain（）
{
onedata（2,3）;
cout<cout<}
（2）#include
classAmplifier
{
解：
一、gain（）的定义不对
floatAmplifier:
:
gain（）
二、gain（）的调用不对
cout<<"\n\nThegainis=>"<floatinvol,outvol;
public:
Amplifier（floatvin,floatvout）
{
invol=vin;
outvol=vout;
}
floatgain（）;
};
Amplifier:
:
floatgain（）
{returnoutvol/invol;}
voidmain（）
{
Amplifieramp（5.0,10.0）;
cout<<"\n\nThegainis=>"<}
（3）
解：
一、构造函数不需要函数类型的说明
Point（inta）{x=a;}
二、成员函数voidShow（）的定义不对，
不需要函数类型
Show（）
{
cout<}
#include
classPoint
{
intx;
public:
voidPoint（inta）{x=a;}
intGetx（）{returnx;}
voidShow（）
{
cout<}
};
voidmain（）
{
PointA（76）;
cout<}
（4）#include
#include
classpart
{
public:
Part（char*pname=”noname”）
{
strncpy（name,pname）;
noofpart++;
no=noofpart;
cout<<”createtheno:
”<}
~Part（）
{
noofpart--;
cout<<”destroytheno:
”<}
解：
一、静态成员函数只能访问类中的静态数据成员
intnumber（）
{returnno;}
二、类对象在定义时不能初始化。
在类体外初始化：
staticintnoofpart;
intpart:
:
noofpart=0;
strncpy函数不对：
strcpy（name,pname）;
staticintnumber（）
{returnno;}
protected:
staticintnoofpart=0;
intno;
charname[40];
};
voidmain（）
{
Partp1;
Partp2;
}
5.阅读下面的程序段，若无错误，写出运行结果。
（1）#include
classtest
{
public:
test（）;
解：
Constructingnormally
Constructingwithanumber:
59
Displayanumber:
-858993460
Displayanumber:
59
Destructing
Destructing
test（int）;
~test（）;
voiddisplay（）;
protected:
intn;
};
test:
:
test（）
{cout<<”Constructingnormally\n”;}
test:
:
test（intnum）
{
n=num;
cout<<”Constructingwithanumber:
”<}
voidtest:
:
display（）
{
cout<<”Displayanumber:
”<}
test:
:
~test（）
{
cout<<”Destructing”<}
voidmain（）
{
testobj1;
testobj2（59）;
obj1.display（）;
obj2.display（）;
}
（2）#include
classCount
解：
104
{
public:
Count（）{count++;}
staticintgetn（）{returncount;}
~Count（）{count--;}
private:
staticintcount;
};
intCount:
:
count=100;
voidmain（）
{
Countc1,c2,c3,c4;
cout<:
getn（）<}
6.设计一个整型数组类，可以实现数组元素的插入/删除、求最大/最小元素、求和等功能。
解：
代码：
#include
#include
classA
{
public:
intc;
A（）{};
staticints[10];
shanchu（inta[]）;
charu（inta[]）;
sum（inta[]）;
dx（inta[]）;
};
intA:
:
s[]={1,12,23,36,45,57,69,78,85,99};
A:
:
charu（inta[]）//插入一个数
{
inti;
cout<<"插入前：
"<for（i=0;i<=8;i++）
{
cout<}
cout<<"\n"<<"输入要插入的数：
";cin>>c;
for（i=0;i<=8;i++）//查找插入位置
{
if（a[i]>c）break;
}
for（intk=9;k>i;k--）a[k]=a[k-1];//插入数字
a[i]=c;
cout<<"插入后：
"<for（i=0;i<=9;i++）
{
cout<}
}
A:
:
shanchu（inta[]）//删除数字
{
inti;
cout<<"\n"<<"输入要删除的数：
";
p:
cin>>c;
for（i=0;i<=9;i++）//查找要删除的数字
{
if（a[i]==c）break;
}
if（i==10）{cout<<"要删除的数不存在！
从新输入：
";gotop;}//要删除数不存在重输
for（intk=i;k<9;k++）a[k]=a[k+1];//删除
cout<<"\n"<<"删除后：
"<for（i=0;i<=8;i++）
{
cout<}
}
A:
:
sum（inta[]）
{
for（inti=0,sum=0;i<=8;i++）sum+=a[i];
cout<<"\n"<<"和为：
"<A:
:
dx（inta[]）//求最大数最小数
{
intmax=a[0];
intmin=a[0];
for（inti=0;i<=8;i++）//查找最大数最小数
{
if（a[i]if（a[i]>max）max=a[i];
}
cout<<"最大数：
"<"<}
voidmain（）
{
Ap;
p.charu（p.s）;
p.shanchu（p.s）;
p.sum（p.s）;
p.dx（p.s）;
}
运行结果：
插入前：
11223364557697885
输入要插入的数：
99
插入后：
1122336455769788599
输入要删除的数：
88
要删除的数不存在！
从新输入：
85
删除后：
11223364557697899
和为：
420
最大数：
99最小数：
1
Pressanykeytocontinue
7.设计一个包含一个整型数据域的链表类，可以实现链表节点的插入/删除、求最大/最小节点、统计节点数等功能。
解：
习题3继承与派生
1.仔细阅读下面的程序段，检查有无错误，若有错误，分析原因，并给出修改方案。
（1）
解：
一、x,y在Point类中为私有成员，不可以被Rectangle类继承，
public:
intx,y;
二、Point类的继承方式为保护，所以Move函数不可外调用，
classRectangle:
publicPoint
#include
classPoint
{
intx,y;
public:
Point（inta=0,intb=0）
{x=a;y=b;}
voidmove（intxoffset,intyoffset）
{x+=xoffset;y+=yoffset;}
intgetx（）{returnx;}
intgety（）{returny;}
};
classRectangle:
protectedPoint
{
intlength,width;
public:
Rectangle（intx,inty,intl,intw）:
Point（x,y）
{
length=l;width=w;
}
intgetlength（）{returnlength;}
intgetwidth（）{returnwidth;}
};
voidmain（）
{
Rectangler（0,0,8,4）;
r.move（23,56）;
cout<<}
（2）
解：
一、X、voiddisplay（）同时存在于A类B类中，所以在C类中无法区别，
myc.A:
:
x=10;
myc.A:
:
display（）;
或
myc.B:
:
x=10;
myc.B:
:
display（）;
#include
classA
{
public:
intx;
A（inta=0）{x=a;}
voiddisplay（）
{cout<<"A.x="<};
classB
{
public:
intx;
B（inta=0）{x=a;}
voiddisplay（）
{cout<<"B.x="<};
classC:
publicA,publicB
{
inty;
public:
C（inta,intb,intc）:
A（a）,B（b）
{y=c;}
intgety（）{returny;}
};
voidmain（）
{
Cmyc（1,2,3）;
myc.x=10;
myc.display（）;
}
（3）
解：
无错
ConstuctingbaseclassConstuctingbaseclassConstructingderivedclass
13,8,24
Destructingderivedclass
DestructingbaseclassDestructingbaseclassPressanykeytocontinue
#include
classBase
{
inti;
public:
Base（intn）
{
cout<<"Constuctingbaseclass";
i=n;
}
~Base（）
{cout<<"Destructingbaseclass";}
voidshowi（）{cout<intGeti（）{returni;}
};
classDerived:
publicBase
{
intj;
Baseaa;
public:
Derived（intn,intm,intp）:
Base（m）,aa（p）
{
cout<<"Constructingderivedclass"<j=n;
}
~Derived（）
{cout<<"Destructingderivedclass"<voidshow（）
{
Base:
:
showi（）;
cout<}
};
voidmain（）
{
Derivedobj（8,13,24）;
obj.show（）;
}
2.阅读下面的代码，若无错误，请写出运行结果。
（1）
解：
classA
classB
classC
classD
Pressanykeytocontinue
#include
classA
{
public:
A（char*s）{cout<~A（）{}
};
classB:
virtualpublicA
{
public:
B（char*s1,char*s2）:
A（s1）{cout<};
classC:
virtualpublicA
{
public:
C（char*s1,char*s2）:
A（s1）
{
cout<}
};
classD:
publicB,publicC
{
public:
D（char*s1,char*s2,char*s3,char*s4）:
B（s1,s2）,C（s1,s3）,A（s1）
{
cout<}
};
voidmain（）
{
D*p=newD（"classA","classB","classC","classD"）;
deletep;
}
（2）
解：
DisplayderivedclassobjectA:
x=0
x=1
x=2
DisplaybaseclassobjectB:
x=1
Pressanykeytocontinue
#include
classparent
{
inti;
protected:
intx;
public:
parent（）{x=0;i=0;}
voidchange（）{x++;i++;}
voiddisplay（）;
};
classson:
publicparent
{
public:
voidmodify（）;
};
voidparent:
:
display（）{cout<<"x="<voidson:
:
modify（）{x++;}
voidmain（）
{
sonA;parentB;
cout<<"DisplayderivedclassobjectA:
\n";
A.display（）;
A.change（）;
A.display（）;
A.modify（）;
A.display（）;
cout<<"DisplaybaseclassobjectB:
\n";
B.change（）;
B.display（）;
}
（3）#include
classbase
{
public:
voidshow（）{cout<<"classbaseshow（）iscalled.\n";}
};
classderived:
publicbase
{
public:
voidshow（）{cout<<"classderivedshow（）iscalled.\n";}
解：
classbaseshow（）iscalled.
classderivedshow（）iscalled.
classbaseshow（）iscalled.
Pressanykeytocontinue
};
voidmain（）
{
basedemo1;
deriveddemo2;
demo1.show（）;
demo2.show（）;
demo2.base:
:
show（）;
}
（4）#include
classB1
{
public:
intnV;
voidfun（）{cout<<"MemberofB1"<};
classB2
{
public:
intnV;
voidfun（）{cout<<"MemberofB2"<};
classD1:
publicB1,publicB2
{
public:
intnV;
voidfun（）
{
cout<<"MemberofD1"<}
};
voidmain（）
解：
MemberofD1
MemberofB1
MemberofB2
Pressanykeytocontinue
{
D1d1;
d1.nV=1;
d1.fun（）;
d1.B1:
:
nV=2;
d1.B1:
:
fun（）;
d1.B2:
:
nV=3
升级会员 