C面向对象程序设计教程--陈维兴-林小茶课后习题答案

C++面向对象程序设计教程课后题答案

什么是面向对象程序设计

面向对象程序设计是一种新的程序设计范型.这种范型的主要特征

是：

程序二对象+消息

面向对象程序的基本元素是对象。

主要结构特点是：

第一，程序一般由类的定义和类的使用两部分组成；

第二，程序中的一切操作都是通过向对象发送消息来实现的。

什么是对象什么是类对象与类之间的关系是什么

对象是描述其属性的数据以及对这些数据施加的一组操作封装在一

起构成的统一体。

类就是具有相同的数据和相同的操作的一组对象的集合，也就是说，

类是对具有相同数据结构和相同操作的一类对象的描述。

类和对象之间的关系是抽象和具体的关系。类是多个对象进行综合抽

象的结果，一个对象是类的一个实例。

现实世界中的对象有哪些特征请举例说明。

现实世界中的对象具有以下特征：

1)每一个对象必须有一个名字以区别于其他对

象；

2)用属性来描述对象的某些特征；

3)有一组操作，每组操作决定对象的一种行为；

4)对象的行为可以分为两类：一类是作用于自身

的行为，另一类是作用于其他对象的行为。

例如一个教师是一个对象。每个教师对象有自己的名字来和别的教师

区别。教师具有编号，姓名，年龄，职称，专业等属性。教师拥有走

路，吃饭，授课等行为操作。走路，吃饭是作用于自身的行为，授课

是作用于其他对象的行为。

什么是消息消息具有什么性质

一个对象向另一个对象发出的请求成为“消息”。

消息具有以下3个性质:

1)同一个对象可以接收不同形式的多个消息，做

出不同的相应；

2)相同形式的消息可以传递给不同的对象，所做

出的响应可以是不同的；

3)对消息的响应并不是必须的，对象可以响应消

息，也可以不响应。

什么是抽象和封装请举例说明。

抽象是将有关事物的共性归纳、集中的过程。

例如：把所有具有大学生学籍的人归为一类，成为“大学生”，这就

是一个抽象。

封装是指把数据和实现操作的代码集中起来放在对象内部，并尽可能

隐藏对象的内部细节。

例如：每一台洗衣机都有出厂日期、机器编号等属性，也有启动、暂

停、选择等操作。人们在使用洗衣机的时候只需要按下对应的按钮，

而不用关心具体的内部实现。这就是封装。

多继承是指多个基类派生出一个派生类的继承关系。比如玩具车同时

继承自玩具和车。

什么是多态请举例说明。

多态是指不同的对象收到相同的消息时执行不同的操作。

例如，有一个窗口类对象，还有一个棋子类对象。当我们发出“移动”

消息时，两个对象的行为不同。

面向对象程序设计的主要优点是什么

1.可提高程序的重用性；

2.可控制程序的复杂性；

3.可改善程序的可维护性；

4.能够更好地支持大型程序设计；

5.增强了计算机处理信息的范围；

能够很好地适应新的硬件环境。

简述C++的主要特点。

1)C++是C的超集，保持与C的兼容。

2)保持了C的简洁、高效和接近汇编语言等特点,

并对C的功能作了不少扩充。用C++编写的程序比C更安全，可读性

更好，代码结构更为合理。

3)程序质量高。

4)增加了面向对象机制。

电

#incIude<iostream>

usingnamespacestd;

intmain()

(

inta,b,d,min;

cout«"Entertwonumbers:";

cin»a»b;

min=a>bb:a;

for(d=2;d<min;d++)

if(((a%d)=二0)&&((b%d)=0))break;

)

if(d-min)

(

cout«"Nocommondenominators"«endI;

return0;

)

cout«"TheIowestcommondenominatoris"«d«endI;

return0;

有效

没有函数声明;

函数定义没有写返回值类型。

(1)等价，函数声明可以省略参数的名字。

(2)不等价，第二个的函数定义不能省略参数的

名字。

CDAAB

ACBDC

DC

101

1010

10

20

举例说明可以使用const替代#define以消除#define的不安全性。

电

#incIude<iostream>

usingnamespacestd;

intmain0

f

inta=1;

#defineT1a+a

#defineT2T1-T1

cout«"T2is"«T2«endI;

return0;

)

上面这个程序，初看应该输出T2is0

但是实际上，得出T2is2

如果把#define换成const,则可以输出想要的结果。

用动态分配空间的方法，计算Fibonacci数列的前20项，并存储到

动态分配的空间中。

电

#incIude<iostream>

usingnamespacestd;

intmain()

(

int*pi=newint[20];

*pi=1;

pi[1]=1；

for(inti=2;i<20;i++)

pi[i]=pi[i-2]+pi[i-1];

)

return0;

)

电

重载sroot函数，输出一个数的二次方根。

电

#incIude<iostream>

usingnamespacestd;

doubIesroot(intnum)

return(double)sqrt((doubIe)num);

)

doublesroot(longnum)

return(double)sqrt((doubIe)num);

1

doublesroot(doublenum)

{

return(double)sqrt(num);

1

intmain()

(

return0;

)

电

解决百钱问题。将一元人民币换成1、2、5分的硬币，有多少种换

法

#incIude<iostream>

usingnamespacestd;

intmain0

(

intnum=0;Default

constructorcaIled.

DefaultconstructorcaIled.

Construcotor:a=1,b=2

Construcotor:a=3,b=4

Construcotor:a=5,b=6

Con.

Copycon.

default.

Copycon.

A二5

B二14

A二9

B=14

5,7

Constructing

Constructing

A=5

B=15

A=10

B二15

Destructing

Destructing

voidpintStu();函数只有声明,没有定义。

age是私有成员，不能用对象直接调用。

voidprintStu0和voidsetSno(ints)没有

加限定符Student::

voidsetAge(inta)在类中没有声明

构造函数不能定义为私有。否则无法创建对象。

下面是一个计算器类的定义，请完成该类成员函数的实现。

cIasscounter

publie：

counter(intnumber);

voidincrement0;电。0777ult()«"

)

)

电

修改，通过对象指针访问对象数组，使程序以相反的顺序显示每个

对象数组元素的qu*price值。

电

cIassbook

(

private:

intqu,price;

publie:

book(intqu);

intmu11();

)；

book::book(intq)

if(q<1IIq>5)

qu=1;

eIse

qu=q;

}

price=10*qu;

)

intbook::mu11()

{

returnqu*price;

)

intmain0

(

bookbooks[5]={1,2,3,4,5);

book*p=books;

P十二4;

for(inti=0;i<5;i++)

(

cout«p->muIt()«"

一P；

return0;

)

电

构建一个类Stock,含字符数组stockcode□及整型数组成员quan、

双精度型数据成员price。构造函数含3个参数：字符数组na□及q、

Po当定义Stock的类对象时，将对象的第一个字符串参数赋给数据

成员stockcode,第2和第3个参数分别赋给quan、price。未设置

第2和第3个参数时,quan的值为1000,price的值为.成员函数print

没有形参，需使用this指针，显示对象数据成员的内容。编写程序

显示对象数据成员的值。

电

#incIude<iostream>

usingnamespacestd;

cIassStock

private:

charstockcode[25];

intquan;

doubIeprice;

pubIic:

Stock(charna[],intq=1000,doubIep=;

Stock(charna[]);

voidprint();

）；

Stock：:Stock(charna[],intq=1000,doubIep二

strcpy(stockcode,na);

quan=q;

price二p;

voidStock::print()

(

cout«"stockcode:"«this->stockcode«"quan:"«

this->quan«"price:"«this->price«endI;

}

intmain()

(

Stockstockl("600001",3000,;

Stockstock2("600002")；

0；

0;

return0;

)

编写一个程序，已有若干学生的数据，包括学号、姓名、成绩，要

求输出这些学生的数据并计算出学生人数和平均成绩（要求将学生人

数和总成绩用静态数据成员表示）。

电

#include<iostream>

usingnamespacestd;

cIassstudent

(

private:

charname[25],studentNo[10];

intscore;

staticintsum;

staticinttotalScore;

pubIic:

student(charna[],charstuNo[],intsc);

voidshow();

staticvoidshowTotaI();

）；

student::student(charna[],charstuNo[],intsc)

strcpy(name,na);

strcpy(studentNo,stuNo);

score=sc;

++sum;

totaIScore+二sc;

)

voidstudent::show()

cout«"姓名:«name«endI;

cout«"学号："«studentNo«endI;

cout«"成绩："«score«endI;

}

voidstudent::showTotaI()

cout«"总人数："«sum«endI;

cout«”平均成绩："«(doubIe;totaIScore/sum«endI;

)

intstudent::sum=0;

intstudent::totaIScore=0;

intmain()

students1(“张无忌”,"111254",75);

students2(“李莫愁"，"254114",60);

students3(“小龙女、"112587",88);

0；

0；

0;

student::showTotaI();

return0;

)

有哪几种继承方式每种方式的派生类对基类成员的继承性如何

公有继承，私有继承和保护继承。

基类的私有成员，无论哪种继承方式都不能访问。

公有继承不改变基类的公有和保护成员的访问限

制C

私有继承将基类的公有和保护成员都变成私有。

保护继承将基类的公有和保护成员都变成保护。

派生类能否直接访问基类的私有成员若否，应如何实现

不能。可以在基类里添加一个公有成员函数来访

问私有成员，派生类就能继承这个公有成员函数，实现对基类私有成

员的访问。

保护成员有哪些特性保护成员以公有方式或私有方式继承后的访问

特性如何

保护成员只能被本类或本类的派生类所访问，在

类或派生类外是不能被访问的。

后面一问见第一题的答案。

派生类构造函数和析构函数的执行顺序是怎样的

构造函数是先执行父类的构造函数，再执行类中

其他类对象的构造函数，再执行本类的构造函数。如果同级有多个构

造函数，则按声明顺序执行。

析构函数与构造函数的执行顺序刚好相反。

派生类构造函数和析构函数的构造规则是怎样的

派生类名（参数总表）：基类名（参数总表）

派生类新增数据成员的初

始化语句

）

派生类中的析构函数与基类无关。

什么是多继承多继承时，构造函数与析构函数的执行顺序是怎样的

多继承是指一个类同时继承自多个不同的基类。

执行顺序同

在类的派生中为何要引入虚基类虚基类构造函数的调用顺序是如何

规定的

如果一个类有多个直接基类，而这些直接基类又

有一个共同的基类，则在最底层的派生类中会保留这个简介的共同基

类数据成员的多份同名成员。在访问这些同名成员的时候，会产生二

义性。为了解决二义性，引入了虚基类。

1)如果虚基类中定义有带形参的构造函数，并且

没有定义默认形式的构造函数，则整个继承结构中，所有直接或间接

的派生类都必须在构造函数的成员初始化表中列出对虚基类构造函

数的调用，以初始化在虚基类中定义的数据成员。

2)建立一个对象时，如果这个对象中含有从虚基

类继承来的成员，则虚基类的成员是由最远派生类的构造函数通过调

用虚基类的构造函数进行初始化的。该派生类的其他基类对虚基类构

造函数的调用都自动被忽略。

3)若同一层次中同时包含虚基类和非虚基类，应

先调用虚基类的构造函数，再调用非虚基类的构造函数，最后调用派

生类的构造函数。

ACCB

ConstructorB1.

ConstructorB2.

ConstructorA.

3

2

主食二bread

副食二steak

0,0,0

0,1,0

3,6,9

ConstructorB1.

ConstructorB2.

ConstructorB3.

ConstructorA.

1

2

4,3

4

(1,2)

5,6

(6,9)

classbasel

classbase2

classIeve12

classbase2

cIasslevel1

classtopIeveI

#inoIude<iostream>

usingnamespacestd;

#incIude<iomanip>

cIasstabIe

publie:

table(intp,intq)

i二P；

j=q；

}

voidascii(void);

protected:

inti,j;

)；

voidtable::ascii()

(

intk=1;

for(;i<=j;i++)

(

cout«setw(4)«i«"«(char)i;

if((k)%12二二0)

(

cout«"\n";

)

k++；

cout«"\nu;

)

cIassder_table:publictabIe

(

pubIic:

der_table(intp,intq,char*m)：tabIe(p,q)

(

c=m;

)

voidprint();

protected:

char*c;

)；

voidder_tabIe::print()

cout«c«"\n";

tabIe::ascii();

1

intmain()

(

der_tabIeob(*a','z',"ASCIIvaIue-----char");

0;

return0;

)

#incIude<iostream>

usingnamespacestd;

#incIude<iomanip>

cIassarea_c1

protected:

doubleheight;

doubIewidth;

publie:

area_c1(doubler,doubIes)

height=r;

width二s;

)

virtuaIdoublearea()=0;

）；

cIassrectangle:pubIicarea_c1

publie:

rectangIe(doubler,doubles):area_c1(r,s){}

virtuaIdoublearea0;

)；

doublerectangle::area()

(

returnheight*width;

)

cIassisosceIes:pubIicarea_c1

(

publie:

isosceles(doubler,doubles):area_c1(r,s){}

virtuaIdoublearea0;

);

doubIeisosceles::area()

(

return(height*width)/2;

)

intmain()

(

rectangler(10,5);

isosceIesi(4,6)；

area_c1*a;

a=&r;

cout«"矩形的面积是:"«a->area()«endI;

a=&i;

cout«"三角形的面积是："«a->area()«endI;

return0;

)

#incIude<iostream>

usingnamespacestd;

#incIude<iomanip>

cIassTime

publie:

Time(inth,intm,ints)

hours二h;

minutes=m;

seconds=s

voiddispIay()

cout«”出生时间："«hours«"时"«minutes«

分"«seconds«"秒"«endI;

)

protected:

inthours,minutes,seconds;

)；

cIassDate

(

publie:

Date(intm,intd,inty)

month-m;

day二d;

year=y;

)

voiddisplay()

{

cout«"出生年月:"«year«"年"«month«"月"

«day«"日"«endl;

}

protected:

intmonth,day,year;

)；

cIassBirthtime:pubIicTime,pubIicDate

publie:

Birthtime(charname[],intm,intd,inty,inth,intmi,

ints):Time(h,mi,s),Date(m,d,y：

strcpy(ChiIdname,name);

voidshowName()

cout«"我的名字是："«ChiIdname«endI;

private:

charChiIdname[25];

）；

intmain()

Birthtimeb("xiaoming",3,6,2012,11,12,42);

0；

::display();

::dispIay();

return0;

}

#incIude<iostream>

usingnamespacestd;

#incIude<iomanip>

cIassperson

protected:

charnumber[25];

charname[25];

publie:

person(charnum[],charna[])

(

strepy(number,num);

strepy(name,na);

)

voidshowName()

(

cout«"编号："«number«"姓名："«name;

)

)；

cIassstudent:pubIicperson

private:

intcIassNumber,score;

publie:

student(charnum[],charna[],inteNumber,int

sc):person(num,na)

{

cIassNumber=eNumber;

score=sc;

}

voidshow()

(

showName();

cout«班号："<<cIassNumber«成绩：«score

«endI;

}

）；

cIassteacher:pubIicperson

private:

chartitle[25],department[25];

publie:

teacher(charnum[],charna[],chartit[],char

depart[]);person(num,na)

{

strepy(title,tit);

strepy(department,depart);

)

voidshow()

(

showName();

cout«职称：«title«部门："<<department

«endI;

C++第五章习题

1.什么是静态联编什么是动态联编

静态联编是指系统在编译时就决定如何实现某一

动作。

动态联编是指系统在运行时动态实现某一动作。

1.编译时的多态性与运行时的多态性有什么区别他们的实现方式

有什么不同

静态联编支持的多态性称为编译时多态性，也称静态多态性。编译时

多态性是通过函数重载和模板实现的。

动态联编所支持的多态性称为运行时多态性，也称动态多态性。是通

过虚函数来实现的。

1.简述运算符重载规则。

a)C++中绝大部分的运算符允许重载。

b)C++只能对已有的C++运算符进行重载。

c)运算符重载是针对新类型数据的实际需要，对

原有运算符进行适当的改造完成。应与原有的功能相类似。

d)重载不能改变运算符的操作对象的个数。

e)重载不能改变运算符原有的优先级。

f)不能改变原有的结合特性。

g)参数至少应有一个是类对象。

h)重载函数可以是普通函数，也可以是类的成员

函数，也可以是类的友元函数。

i)一般用于类对象的运算符除了赋值运算符

都要重载。

1.友元运算符函数和成员运算符函数有什么不同

a)对于双目运算符，成员运算符重载含有一个参

数，友元重载含有两个参数；对于单目运算符，成员重载没有参数，

友元重载有一个参数。

b)双目运算符一般可以被重载为友元或成员。但

是如果将一个对象和一个普通类型运算，必须重载为友元。

c)调用方式不同。

d)一般，双目运算符用友元，单目运算符用成员。

如果操作数有隐式类型转换，则必须用友元。

1.什么是虚函数虚函数与函数重载有哪些相同点与不同点

虚函数就是在基类中被关键字virtuaI说明，并在派生类中重新定义

的函数。

函数名都相同。

重载函数的参数个数或参数类型必须有所不同。虚函数要求函数名，

返回类型，参数个数，参数的类型和顺序与基类中的虚函数原型完全

相同。

1.什么是纯虚函数什么是抽象类

纯虚函数是一个在基类中说明的虚函数，它在该基类中没有定义，但

要求在它的派生类中根据需要对它进行定义，或仍说明为纯虚函数。

如果一个类至少有一个纯虚函数，那么就称这个类为抽象类。

7-12DAADCC

13.

不对，参数个数必须一样。

14.

7

6

15.

Thisisc++book.

第一个字符：T

第16个字符：.

第26个字符：数组下标超界！

16.

m二千米

17.

#incIude<iostream>

usingnamespacestd;

cIasstwoDArray

(

inta[2][3];

publie:

twoDArray()

{

for(inti=0;i<2;i++)

for(intj=0;j<3;j++)

a[i][j]=5;

)

twoDArray(intb[][3])

for(inti=0;i<2;i++)

for(intj=0;j<3;j++)

a[i][j]=b[i][j];

)

voidshow();

twoDArrayoperator+(twoDArrayn);

twoDArrayoperator-(twoDArrayn);

)；

voidtwoDArray::show()

(

for(inti=0;i<2;i++)

(

for(intj=0;j<3;j++)

cout«a[i][j];

cout«endI;

)

)

twoDArraytwoDArray::operator+(twoDArrayn)

{

twoDArraytemp;

for(inti=0;i<2;i++)

for(intj=0;j<3;j++)

[i][j]=a[i][j]+

returntemp;

)

twoDArraytwoDArray::operator-(twoDArrayn)

(

twoDArraytemp;

for(inti=0;i<2;i++)

for(intj=0;j<3;j++)

[i][j]=a[i][j]-

returntemp;

1

intmain()

(

inta[2][3];

for(inti=0;i<2;i++)

for(intj=0;j<3;j++)

cin»a[i][j];

twoDArraya1,a2(a),totaI,sub;

totaI=a1+a2;

sub-a1-a2;

0；

0；

return0;

}

18.

#incIude<iostream>

usingnamespacestd;

cIasstwoDArray

inta[2][3];

publie:

twoDArray()

for(inti=0;i<2;i++)

for(intj=0;j<3;j++)

a[i][j]=5;

)

twoDArray(intb[][3])

(

for(inti=0;i<2;i++)

for(intj=0;j<3;j++)

a[i][j]=b[i][j];

)

voidshow();

friendtwoDArrayoperator+(twoDArraym,twoDArrayn);

friendtwoDArrayoperator-(twoDArraym,twoDArrayn);

)；

voidtwoDArray::show()

for(inti=0;i<2;i++)

for(intj=0;j<3;j++)

cout«a[i][j];

cout«endI;

)

)

twoDArrayoperator+(twoDArraym,twoDArrayn)

(

twoDArraytemp;

for(inti=0;i<2；i++)

for(intj=0;j<3;j++)

[i][j]=+⑴口];

returntemp;

)

twoDArrayoperator-(twoDArraym,twoDArrayn)

twoDArraytemp;

for(inti=0;i<2；i++)

for(intj=0;j<3;j++)

returntemp;

)

intmain()

(

inta[2][3];

for(inti=0;i<2;i++)

for(intj=0;j<3;j++)

cin»a[i][j];

twoDArraya1,a2(a),totaI,sub;

totaI=a1+a2;

sub=a1-a2;

0;

0;

return0;

)

电

19.

电

#incIude<iostream>

usingnamespacestd;

cIasscompIex

(

doublereaI,imag;

publie:

compIex(doublere,doubIeim)

reaIre;

imag=im;

)

friendcomplexoperator+(compIexa,compIexb);

voidprint();

)；

compIexoperator+(compIexa,compIexb)

(

returncompIex+,+;

)

voidcomplex::print()

cout«"("«reaI«","«imag«")"«endI;

)

intmain()

compIexc1,;

complexc2,;

complextotaI=d+c2;

0;

return0;

1

电

20.

电

#incIude<iostream>

usingnamespacestd;

constdoubIePI

cIassContainer

protected:

doubler,d;如果是圆柱体，r为底面半径，d为高。如果是正

方体，r为边长，d为0。

publie:

Container(doubIea,doubIeb=0)

{

r二a;

d二b;

)

virtualdoubleserface()=0;cerr和clog间的区别是

cerr不经过缓冲区直接显示错误信息。而cIog

存放在缓冲区，缓冲区满或遇上endl时再输出。

C++提供哪两种控制输入输出格式的方法

一种是使用ios类中的有关格式控制的流成员函

数进行格式控制，另一种是使用称为操纵符的特殊类型的函数控制。

C++进行文件输入输出的基本过程是什么

首先创建一个流对象，然后将这个流对象与文件

相关联，即打开文件，此时才能进行读写操作，读写操作完成后再关

闭这个文件。

BCA

电

#include<iostream>

#incIude<iomanip>

usingnamespacestd;

intfactoriaI(intn)

if(n==0||n=1)

returnn;

returnfactoriaI(n-1)*n;

1

intmain()

(

for(inti=1;i<=9;i++)

(

cout«setw(5)«factoriaI(i);

if(i%3=0)

(

cout«endI;

)

}

return0;

)

#incIude<iostream>

#incIude<iomanip>

usingnamespacestd;

intmain()

(

for(inti=1;i<=7；i++)

(

cout«setw(16-i);

for(intj=1;j<=(2*i-1);j++)

cout«'A';

cout«endI;

}

return0;

}

#incIude<iostream>

#incIude<iomanip>

usingnamespacestd;

cIassmatrix

private:

intdata[2][3];

publie:

matrix(){}

ostream&operator«(ostream&,matrix&);

istream&operator»(istream&,matrix&);

friendmatrixoperator+(matrix&,matrix&);

）；

ostream&operator«(ostream&os,matrix&a)

for(inti=0;i<2;i++)

for(intj=0;j<3;j++)

os«[i][j]«"

)

os«endI;

returnos;

)

istream&operator»(istream&in,matrix&a)

(

cout«"请输入一个2行3列矩阵:"«endI;

for(inti=0;i<2；i++)

{

for(intj=0;j<3;j++)

(

in»[i][j];

)

)

returnin;

}

matrixoperator+(matrix&a,matrix&b)

matrixtemp；

for(inti=0;i<2;i++)

{

for(intj=0;j<3;j++)

(

)

)

returntemp;

)

intmain()

matrixml,m2,totaI;

cin»ml»m2;

totaI=ml+m