C++程序设计第8章1

本周习题：

1.补充习题（在信息门户下载）（下周实验递交）

2.按章节要求认真复习，把这几周习题搞懂。周四下午答疑讲解习题。预习:第9章1~4节第8章要求：（1）理解C++的基本流类体系；（2）提高标准输入/输出的健壮性；（3）掌握提取与插入运算符的重载（4）掌握文件的输入/输出：文件的打开与关闭，文本文件与二进制文件。（5）掌握在构造函数中通过文件建立对象，在析构函数中由文件保存对象的技术。fruit类成员：1）深复制2）动态内存空间的开辟（构造函数）和释放（析构函数）3）带默认参数值的构造函数定义（含堆区空间开辟）4）在析构函数中，将对象内容保存至文件后释放对象请根据要求完成各成员函数，并设计测试程序main函数，该函数要求：（1）在主函数中，声明一个栈区的fruit对象，调用带参的构造函数，输出其内容；（2）声明一个堆区的对象，调用复制构造函数，输出对象内容（3）修改堆区的对象内容，输出对象内容。（4）在堆区开辟长度为3的fruit对象数组，对元素进行相关的操作后，输出所有元素。程序结束，注意结束前堆区空间的释放。

constintweekday=7;classfruit{ stringm_name;//水果名称

stringcolor;//颜色

doubleweight;//均重

stringshape;//基本外形

doublevolume;//该类水果的平均体积

double*historyprice;//存放最近一周内每日的平均成交价public:

fruit(stringa="\0",stringb="\0",doublec=0,stringd="\0",doublee=0,double*p=0); ~fruit();//将对象内容先保留至指定的文件中，动态内存空间的释放

fruit(fruit&);//拷贝构造函数，注意深复制

fruit&operator=(fruit&); friendostream&operator<<(ostream&,fruit&);//流插入运算符重载

friendistream&operator>>(istream&,fruit&);//流提取运算符重载

friendvoidmodify(fruit&);//调用重载函数“>>”实现从键盘输入水果的参数，改变已有的对象参数值};fruit::fruit(string

a,string

b,double

c,string

d,doublee,double*p){

m_name=a; color=b; weight=c; shape=d; volume=e;

if(p){//判断传进来的指针是否指向有效内存空间

if(historyprice=newdouble[weekday]){

for(intj=0;j<weekday;j++) *(historyprice+j)=*(p+j); } else{ cout<<"空间分配失败"; exit(0); } } elsehistoryprice=NULL;//若传进来的指针是空的，则把本对象的指针也指向空}fruit::fruit(fruit&f){//拷贝构造函数

m_name=f.m_name; color=f.color; weight=f.weight; shape=f.shape; volume=f.volume;

if(f.historyprice){//还需判别f.historyprice是否为NULL

if(historyprice=newdouble[weekday]){

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

historyprice[i]=f.historyprice[i]; } else{

cout<<"空间分配失败"; exit(0); } } elsehistoryprice=NULL;}fruit&fruit::operator=(fruit&f){

m_name=f.m_name; color=f.color; weight=f.weight; shape=f.shape; volume=f.volume;

if(historyprice)delete[]historyprice;

if(f.historyprice){//还需判别f.historyprice是否为NULL

if(historyprice=newdouble[weekday]){

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

historyprice[i]=f.historyprice[i]; } else{cout<<"空间分配失败"; exit(0);} } elsehistoryprice=NULL;

return*this;//返回当前对象}fruit::~fruit(){

ofstream

ofile; ofile.open("04011.txt");

ofile<<*this<<endl;//将当前对象写入文件

ofile.close();

if(historyprice)delete[]historyprice;}voidmodify(fruit&f)//非常简洁{

cin>>f;}//释放堆空间ostream&operator<<(ostream&s,fruit&f)//流插入运算符重载，见第九章

{ s<<"name:"<<f.m_name<<'\t' <<"color:"<<f.color<<'\t' <<"weight:"<<f.weight<<'\t' <<"shape:"<<f.shape<<'\t' <<"volume:"<<f.volume<<'\t' <<"historyprice:";

if(f.historyprice) {

for(inti=0;i<weekday;i++) s<<f.historyprice[i]<<""; } elses<<"historyprice为空！\n"; s<<endl; returns; }istream&operator>>(istream&s,fruit&f){//流提取运算符重载

cout<<"name(string):"<<endl; s>>f.m_name;

cout<<"color(string):"<<endl;s>>f.color;

cout<<"weight(double):"<<endl;s>>f.weight;

cout<<"shape(string):"<<endl; s>>f.shape;

cout<<"volume(double):"<<endl;s>>f.volume;

if(!f.historyprice)

f.historyprice=newdouble[weekday];

if(f.historyprice){

cout<<"最近一周内的交易价格(7double):\n";

for(inti=0;i<weekday;i++)s>>f.historyprice[i]; } else cout<<"无存储空间，无法输入一周价格!\n";

cout<<endl; returns; }intmain(){ constintn=3; doublep1[7]={7,5.5,6,5,5,4.5,4}; fruitredapple("redapples","red",7.0,"round",3,p1);

cout<<"redapple:\n"<<redapple;

fruit*greenapple=newfruit(redapple);

cout<<"greenapple\n"<<*greenapple; modify(*greenapple);

cout<<"modifiedgreenapple:\n"<<*greenapple; fruit*myfruits=newfruit[n]; myfruits[2]=redapple;

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

cout<<myfruits[i]; deletegreenapple; delete[]myfruits; return0;}（1）（2）（3）（4）//释放堆空间//释放堆空间多层派生时的构造函数一个类不仅可以派生出一个派生类，派生类还可以继续派生，形成派生的层次结构。基类和两个派生类的构造函数的写法(只要写出函数头）基类的构造函数首部:

Student(intn,stringnam)派生类Student1的构造函数首部:Student1(intn,stringnam,int

a):Student(n,nam)

派生类Student2的构造函数首部:Student2(intn,stringnam,int

a,ints):Student1(n,nam,a)classPoint{//二维点坐标

doublex,y;public:

Point(doublexv=0,doubleyv=0){x=xv;y=yv; } doubleGetx(){returnx;} doubleGety(){returny;}

voidShow(){ cout<<"x="<<x<<"y="<<y; }};classSquare:publicPoint{//带颜色的矩形类

doublehx,hy;//矩形右上角坐标

char*color;//矩形的颜色public:Square(){hx=0;hy=0; }Square(doublexv,double

yv,double

hxv,double

hyv,char*s):

{

hx=hxv;hy=hyv; color=newchar[9];

strcpy(color,s); } Point(xv,yv)

Square():Point(rr){

hx=rr.hx;hy=rr.hy; =newchar[strlen()+7];

strcat(strcpy(),“

");}voidShow(){//输出矩形的左下角坐标、宽度、高度和颜色

Point::;

cout<<"\twidth="<<<<','<<"high="<<

;

cout<<",color="<<color<<endl;}};intmain(){Squares1(1,3,6,9,"red"),s2(s1);

cout<<"矩形s1:"<<'\t';s1.Show();

cout<<"矩形s2:"<<'\t';s2.Show();return0;}矩形s1:x=1y=3width=5,high=6,color=red

矩形s2:x=1y=3width=5,high=6,color=redYellow矩形s1:x=1y=3width=5,high=6,color=red

矩形s2:x=0y=0width=0,high=0,color=redYellowSquare&rr

color

rr.color

color,rr.colorYellowShow()Getx()Gety()多继承且有内嵌对象时的构造函数基类和派生类的构造函数的写法(只要写出函数头）A(inti){…}A11(inti,int

j):A(i),a(j){…}Aintxvoidshow()A11intxvoidshow()Aaintfun()例：classA{public:intx;……};classB:virtual

publicA{public:inty;……};classC:virtual

publicA{public:intz;……};classD:public

B,publicC{public:intm;……};

虚基类基类A基类C基类B

类

D基类和派生类的构造函数的写法(只要写出函数头）

虚基类的初始化调用虚基类的构造函数的方法与调用一般基类的构造函数的方法不同。由虚基类经过一次或多次派生出来的派生类，在其每一个派生类的构造函数的成员初始化列表中必须给出对虚基类的构造函数的调用；如果未列出，则调用虚基类的缺省的构造函数。在这种情况下，在虚基类的定义中必须有缺省的构造函数。虚基类举例classA{private:intx;public:A(inti){…}};classB:virtualpublicA{private:inty;public:B(int

n):A(n){…}};classC:

virtualpublicA{private:intz;public:C(int

n):A(n){…}};classD:publicB,publicC{private:floatm;public:D(int

n):A(n),B(n),C(n){…}};由虚基类经过一次或多次派生出来的派生类，在其每一个派生类的构造函数的成员初始化列表中必须给出对虚基类的构造函数的调用；如果未列出，则调用虚基类的缺省的构造函数。类似用实型变量描述整数，这条规则称赋值兼容规则。赋值兼容包括以下三种情况：1派生类与基类（赋值兼容）8.5派生类应用讨论(1)派生类对象可以向基类对象赋值。可以用子类(公用派生类)对象对其基类对象赋值。如

Aa1;//定义基类A对象a1Bb1;//定义类A的公用派生类B的对象b1a1=b1;//用派生类B对象b1对基类对象a1赋值在赋值时舍弃派生类自己的成员。AB子类型关系是单向的、不可逆的。基类对象不包含派生类的成员，无法对派生类的成员赋值。同一基类的不同派生类对象之间也不能赋值。(2)派生类对象可以替代基类对象向基类对象的引用进行赋值或初始化。如已定义了基类A对象a1，可以定义a1的引用变量:Aa1;//定义基类A对象a1Bb1;//定义公用派生类B对象b1A&r=a1;//定义基类A对象的引用变量r，并用a1对其初始化引用变量r是a1的别名，r和a1共享同一段存储单元。可以用子类对象初始化引用变量r:A&r=b1;

//定义基类A对象的引用变量r，并用派生类B对象b1对其初始化或保留A&r=a1;

，对r重新赋值：

r=b1;

//用派生类B对象b1对a1的引用变量r赋值注意:r不是b1的别名，也不与b1共享同一段存储单元。它只是b1中基类部分的别名，r与b1中基类部分共享同一段存储单元，r与b1有相同的起始地址。(3)若函数的参数是基类对象或基类对象的引用，其实参可以用子类对象。如有一函数：

voidfun(A&r)//形参是类A的对象的引用变量

{cout<<r.num<<endl;}//输出该引用变量的数据成员numfun函数时可用派生类B的对象b1作实参:

fun(b1);

//输出类B的对象b1的基类数据成员num的值。(4)派生类对象的地址可以赋给指向基类对象的指针变量，也就是说，指向基类对象的指针变量也可以指向派生类对象。

A*a;//定义基类A对象aBb;//定义公用派生类B对象ba=&b;classBase{//例

int

a,b;

public:

Base(intx,inty){a=x;b=y;}

voidshow(){cout<<a<<’,’<<b<<endl;}};classDerived:publicBase{

intc,d;

public:

Derived(int

x,int

y,int

z,int

m):Base(x,y){c=z;d=m;}

voidshow(){cout<<c<<’,’<<d<<endl;}};intmain(){

BaseB1(50,50),*pb;

DerivedD1(10,20,30,40);

pb

=＆D1;

pb->show();

return0;}通过基类的指针只能访问从基类继承的成员结果：

10，20例

赋值兼容规则举例#include<iostream>usingnamespacestd;classA{ //基类A声明public: voiddisplay(){//公有成员函数

cout<<“A::display()"<<endl;} };classB:publicA{ public: voiddisplay(){

cout<<"B::display()"<<endl;} };classC:publicB{public: voiddisplay(){

cout<<“C::display()"<<endl;} };voidfun(A*ptr

) {

ptr->display();

//"对象指针->成员名"}

intmain(){ //主函数

Aa; //声明A类对象

Bb; //声明B类对象

Cc; //声明C类对象

A*p; //声明A类指针

p=&a; //A类指针指向a类对象

fun(p); p=&b; //A类指针指向B类对象

fun(p); p=&c; //A类指针指向C类对象

fun(p);}输出：A::display()A::display()A::display()在基类对象出现的场合使用派生类对象进行替代，替代之后派生类仅仅发挥出基类的作用。多态的设计方法可以保证在类型兼容的前提下，基类、派生类分别以不同的方式来响应相同的消息。

将在8.6节中介绍2

继承与聚合（组合）在一个类中以另一个类的对象作为数据成员的，称为类的聚合（组合）。例：//教师类classTeacher{public:┆private:

intnum;stringname;charsex;};//生日类classBirthDate{public:┆private:intyear;intmonth;intday;};//教授类classProfessor:publicTeacher{public:┆private:

BirthDatebirthday;

//BirthDate类的对象作为数据成员

};classson{//继承与聚合例

intage;public:son(){age=1;}

son(inti){age=i;} voidprint(){cout<<"儿子的年龄是:"<<age<<endl;}};classfather{

intage; sons1,s2;public:father(inta1,inta2,inta3):s2(a2),s1(a1){ age=a3;} voidprint(){cout<<"父亲的年龄是:"<<age<<endl;}son&gets1(){cout<<"第一个";returns1;}son&gets2(){cout<<"第二个";returns2;}};intmain(){ fatherf(10,5,38);f.print();f.gets1().print();f.gets2().print(); return0;}运行结果：父亲的年龄是:38

第一个儿子的年龄是：10

第二个儿子的年龄是：5说明：基类在派生类中只能继承一次，否则成员名及时使用域分辨符也会发生冲突，如：

classA{public:intk;……..};

calss

B:public

A,publicA{…….};

两个k无法区别。如要区别，可采用成员对象（嵌套）：

classB:publicA{Aa,b;……};

两个k的访问：a.k

b.k2.继承与组合

继承是“是”的关系：派生类是基类的具体化实现，是基类中的一种。

组合是“有”的关系：教授是一个生日说法不对，应该是，教授有一个生日。例：Birthdate

是成员类，Professor是组合类（在一个类中又包含了另一个类的对象成员8.6多态性与虚函数多态性是面向对象程序设计的关键技术之一。指的是调用同样的函数实现不同的功能。在C++中有两种多态编译时的多态性

（静态多态性）运行时的多态性

在程序执行前无法确定调用哪一个函数，必须在程序执行过程中，根据执行的具体情况来动态地确定。通过类继承关系和虚函数来实现的。目的：建立一种通用的程序。通过函数的重载和运算符的重载实现。多态性是“一个接口，多种方法”:

通过继承产生了相关的不同的派生类，和基类成员同名的成员在不同的派生类中有不同的含义。虚函数的作用:

允许在派生类中重新定义与基类同名的函数，并且可以通过基类指针或引用来访问基类和派生类中的同名函数。虚函数是一个类的成员函数，定义虚函数的格式如下：

virtual返回类型函数名（参数表）；

注：virtual仅用于类定义中，若虚函数在类外定义，不能加virtual(类中函数说明要加virtual)。

当某一个类的一个类成员函数被定义为虚函数，则由该类派生出来的所有派生类中，该函数始终保持虚函数的特征。8.6.1虚函数的定义在派生类中重新定义虚函数(称超载或覆盖)时，不必再加关键字virtual，但函数头一定要完全相同。虚函数的使用:(1)在基类用virtual声明成员函数为虚函数。(2)在派生类中重新定义此函数，要求函数名、函数类型、函数参数个数和类型全部与基类的虚函数相同，并根据派生类的需要重新定义函数体。(3)定义一个指向基类对象的指针变量，并使它指向同一类族中需要调用该函数的对象。(4)通过该指针变量调用此虚函数，此时调用的就是指针变量指向的对象的同名函数。例：classA{public:

virtualvoidshow();

};voidA::show(){cout<<"A::show()"<<endl;}classB:publicA{public: voidshow(){cout<<"B::show()"<<endl;}};classC:publicB{public: voidshow(){cout<<"C::show()"<<endl;}};classAshow()classBshow()show()classCshow()show()show()intmain(){Aa1,*p; Bb1; Cc1; p=&a1; p->show();//动态调用

p=&b1; p->show();//动态调用

p=&c1; p->show();//动态调用}运行结果:

A::show()

B::show()

C::show()intmain(){Cc;

c.A::show();//静态调用

c.B::show();//静态调用

c.show();//静态调用}【例8.6】计算学分。

由本科生类派生出研究生类GradeStudent，但它们各自的从课程学时数折算为学分数的算法是不同的，本科生是16个学时一学分，而研究生是20个学时一学分。classStudent{ charcoursename[20]; //课程名

int

classhour; //学时

intcredit; //学分,未考虑0.5学分public: Student()；//构造函数，将类成员赋值为0 voidCalculate()；//计算学分（考虑该函数的设置）

voidSetCourse(char*str,inthour)；//设置课程和学时

int

GetHour()；//获取学时数

voidSetCredit(int

cred)；//获取学分

voidPrint()；//显示学时和学分};classStudent{charcoursename[20]; //课程名

int

classhour; //学时

intcredit; //学分public:Student(){coursename[0]='\0';

classhour=0;credit=0;}

virtualvoidCalculate(){credit=classhour/16;}voidSetCourse(char*str,inthour){//设置课程和学时

strcpy(coursename,str);

classhour=hour;}

int

GetHour(){returnclasshour;}//获取学时数

voidSetCredit(int

cred){credit=cred;}//获取学分

voidPrint(){//显示学时和学分

cout<<coursename<<'\t'<<classhour<<"学时"

<<'\t'<<credit<<"学分"<<endl;}};classGradeStudent:publicStudent{public:

GradeStudent(){};//基类缺省构造函数调用可省

voidCalculate(){SetCredit(GetHour()/20);}};intmain(){

Students,*ps;

GradeStudentg;

s.SetCourse("物理",80);s.Calculate();

g.SetCourse("物理",80);g.Calculate();

cout<<"本科生："<<'\t';s.Print();

cout<<“研究生："<<'\t';g.Print();

s.SetCourse(“数学",160);

g.SetCourse("数学",160);

ps=&s;

ps->Calculate();

cout<<"本科生："<<'\t';

ps->Print();

ps=&g;

ps->Calculate();

cout<<"研究生："<<'\t';

ps->Print();}输出结果为:本科生：物理80学时5学分研究生：物理80学时4学分本科生：数学160学时10学分研究生：数学160学时8学分使用基类引用去指向不同对象，同样可实现运行时多态性。voidCalfun(Student

&ps,char*str,inthour){

ps.SetCourse(str,hour);

ps.Calculate();

ps.Print();}intmain(){ Students;

GradeStudentg;

cout<<"本科生:";

Calfun(s,"物理",80);

cout<<"研究生:";

Calfun(g,“物理”,80);}【例8.7】计算学分，基类与派生类定义同【例8.6】（基类派生类函数不变），增加函数：几点提示：5.虚函数重构不同于重载。派生类中定义虚函数必须与基类中的虚函数同名外，还必须同参数表，同返回类型。否则被认为是重载，而不是虚函数。

1.实现动态多态性需要三个条件：派生类体系、虚函数、指针或引用。2.析构函数可定义为虚函数，构造函数不能定义虚函数。在基类及其派生类都有动态分配的内存空间时，应当考虑把析构函数定义为虚函数，以便能够用基类指针实现撤消对象的多态性。3.虚函数执行速度稍慢。为了实现多态性，每一个派生类中均要保存相应虚函数的入口地址表，函数的调用机制也与一般函数不同。这是多态性为实现通用性付出的代价。4.静态成员函数不能作为虚函数，因为它不属于某个对象，而是为所有同类对象共有。内联函数也不能作为虚函数。声明虚函数的成员函数主要考虑以下几点:首先看成员函数所在的类是否会作为基类。然后看成员函数在类的继承后有无可能被更改功能，如果希望更改其功能的，一般应该将它声明为虚函数。(2)如果成员函数在类被继承后功能不需修改，或派生类用不到该函数，则不要把它声明为虚函数。(3)应考虑对成员函数的调用是通过对象名还是通过基类指针或引用去访问，如果是通过基类指针或引用去访问的，则应当声明为虚函数。虚析构函数如果用new运算符建立了临时对象，若基类中有析构函数，并且定义了一个指向该基类的指针变量。在程序用带指针参数的delete运算符撤销对象时，会出现:系统只执行基类的析构函数，而不执行派生类的析构函数。解决办法：把析构函数定义为虚函数，实现撤消对象时的多态性。当程序使用多态性并且为不同的类分配内存时，应该使用虚析构函数来保证内存按照需要被释放。虚析构函数声明：

virtual~类名();classA{public:~A(){

cout<<"A析构\n";}};classB:publicA{public:B();~B();private:

int*p;};B::B(){p=newint();}B::~B(){

cout<<"B析构\n";deletep;}voidfun(A*a){deletea;}intmain(){A*a=newB;

//a是指向基类的指针变量指向new开辟的动态存储空间

fun(a);return0;}输出：A析构virtual输出：B析构

A析构把基类的析构函数声明为虚函数。可使所有派生类的析构函数自动成为虚函数（即使函数名不同）。若程序中显式地用了delete运算符准备删除一个对象，而delete运算符的操作对象用了指向派生类对象的基类指针，系统会调用相应类的析构函数。1.虚函数是动态关联的基础。2.虚函数是非静态的成员函数。

3.virtual

只用来说明类声明中的原型，不能用在函数实现时。4.具有继承性，基类中声明了虚函数，派生类中无论是否说明，同原型函数都自动为虚函数。5.不是重载声明而是覆盖。6.通过基类指针或引用，执行时会根据指针指向的对象的类，决定调用哪个函数。classshape{public:

shape(char*name,int

x,inty); virtualvoiddraw();~shape();protected: charname[64];

int

x,y;};classcircle:publicshape{public:

circle(char*name,int

x,int

y,intradius); voiddraw(); ~circle();private: charname[64];

intradius;};virtualshape::shape(char*name,int

x,inty){

strcpy(shape::name,name);

shape::x=x;shape::y=y;}voidshape::draw(){cout<<“shape::draw():"<<name<<endl;}shape::~shape(){cout<<“shape析构"<<endl;}circle::circle(char*name,int

x,int

y,intradius):

shape(name,x,y){

circle::radius=radius;}voidcircle::draw(){

cout<<“circles::draw():";

cout<<"x="<<x<<"\ty="<<y<<"\tradius="<<radius<<endl;}circle::~circle(){cout<<“circle析构"<<endl;}intmain(){ shape*graphic=newcircle("Circle",10,20,30); graphic->draw(); deletegraphic;}输出：circle::draw():x=10y=20radius=30shape析构输出：(将基类析构函数说明成虚析构函数）circle::draw():x=10y=20radius=30circle析构shape析构draw()函数为虚函数,但~shape（）不是例：

PointArea()Show()doublex,y;

CircleArea()Show()doublradius;classPoint{public:…….doubleArea(){return0;}…..};classCircle:publicPoint{public:……doubleArea(){returnPI*radius*radius;}……};基类函数为空或可以不要，在实现部分仍然要写出函数体，纯虚函数可以解决－－接口8.6.2纯虚函数1.纯虚函数不同于空函数，纯虚函数不能调用。2.派生类中必须重新定义纯虚函数的函数体。3.含有纯虚函数的基类不能用来定义对象，称为抽象类。纯虚函数（purevirtualfunction）当基类中某虚函数无法具体实现，可定义为纯虚函数，具体实现依赖于派生类。定义格式为：定义纯虚函数要注意：virtual返回类型函数名（参数表）=0；注：①纯虚函数没有函数体；②最后面的“=0”并不表示函数返回值为0，它只起形式上的作用，告诉编译系统“这是纯虚函数”;③这是一个声明语句，最后应有分号。抽象类带有纯虚函数的类称为抽象类:class类名

{

virtual

类型函数名(参数表)=0;//纯虚函数

...}抽象类作用：通过它为一个类族建立一个公共接口，使它们能够有效发挥多态特性。目的，通过它多态地使用各类中的成员函数。对于暂时无法实现的函数，可以声明为纯虚函数，留给派生类去实现。注意抽象类只能作为基类来使用。不能声明抽象类的对象。构造函数不能是虚函数，析构函数可以是虚函数。#include<iostream.h>classB0{//抽象基类B0声明public://外部接口

virtual

voiddisplay()=0;//纯虚函数成员};classB1:publicB0{//公