面向对象第四次作业任务答案解析.docx

面向对象第四次作业任务答案解析.docx

《面向对象第四次作业任务答案解析.docx》由会员分享，可在线阅读，更多相关《面向对象第四次作业任务答案解析.docx（13页珍藏版）》请在冰豆网上搜索。

面向对象第四次作业任务答案解析

面向对象程序设计技术作业四

一、填空题

1、在定义类对象的语句执行时，系统在建立每个对象的过程中将自动调用该类的构造函数使其初始化。

2、当一个类对象被撤消时将自动调用该类的析构函数。

3、对基类数据成员的初始化是通过执行派生类构造函数中的初始化表来实现的。

4、对一个类中的数据成员的初始化可以通过构造函数中的初始化表实现，也可以通过构造函数中的赋值语句实现。

5、在一个派生类中，对基类成员、类对象成员和非类对象成员的初始化次序是先基类成

员，后类对象成员，最后为非对象成员。

6、当撤消一个含有基类和类对象成员的派生类对象时，将首先完成派生类本身的析构

函数定义体的执行，接着完成类对象成员的析构函数定义体的执行，最后完成基类成

员的析构函数定义体的执行。

7、设px是指向一个类动态对象的指针变量，则执行”deletepx；”语句时，将自动调用该类的

析构函数。

8、当一个类对象离开它的作用域时，系统将自动调用该类的析构函数。

9、假定一个类对象数组为A[N]，当离开它的作用域时，系统自动调用该类析构函数的次数为N次。

10、假定AB为一个类，则执行”ABa[10]；”语句时，系统自动调用该类构造函数的次数为

10次。

11、假定用户没有给一个名为AB的类定义构造函数，则系统为其隐含定义的构造函数为空

构造函数

12、假定用户没有给一个名为AB的类定义析构函数，则系统为其隐含定义的析构函数为空构造函数。

13、若需要把一个函数”voidF（）；”定义为一个类AB的友元函数，则应在类AB的定义中加入一条语句：

friendvoidF（）；。

14、若需要把一个类AB定义为一个类CD的友元类，则应在类CD的定义中加入一条语句：

feiendclassAB；。

15、假定一个类AB中有一个静态整型成员bb，在类外为它进行定义并初始化为0时，所使用的语句为AB：

bb=0；。

16、假定类AB中有一个公用属性的静态数据成员bb，在类外不通过对象名访问该成员bb

的写法为AB：

bb。

17、当类中一个字符指针成员指向具有n个字节的存储空间时，它所能存储字符串的最大长

度为n-1。

18、假定AB为一个类，则该类的拷贝构造函数的声明语句为AB：

完成

AB（AB&）

19、对类对象成员的初始化是通过执行构造函数中的初始化表

的。

20、对于类中定义的成员，其隐含访问权限为private，对于结构中定义的成员，其隐含访问权限为public。

21

、一个类的友元函数或友元类能够通过成员操作符访问该类的

员。

22、假定要对类AB定义加号操作符重载成员函数，实现两个

23、在C++流类库中，根基类为ios。

24、在C++流类库中，输入流类和输出流类的名称分别为istream和ostream

25、若要在程序文件中进行标准输入输出操作，则必须在开始的＃

include命令中使用

iosteam.h头文件。

26、若要在程序文件中进行文件输入输出操作，则必须在开始的＃

include命令中使用

fstream.h头文件。

27、当从字符文件中读取回车和换行两个字符时，被系统看作为一个换行符

28、当使用ifsream流类定义一个流对象并打开一个磁盘文件时，

文件的隐含打开方式为读

取的文本文件，当使用ofstream流类定义一个流对象并打开一个磁盘文件时，文件的隐含打开方式为写入的文本文件。

29、当需要使用istrstream流类定义一个流对象并联系一个字符串时，应在文件开始使用＃

include命令，使之包含strstrea.h文件。

二、写出下列程序运行后的输出结果

1．#include

classA{

inta,b;

public:

A（）{a=b=0;}

A（intaa,intbb）{a=aa;b=bb;cout<

};

voidmain（）{

Ax,y（6,3）,z（8,10）;

}输出结果：

2．

#include

classA{

inta,b;

public:

A（intaa=0,intbb=0）:

a（aa）,b（bb）{

cout<<"Constructor!

"<

}

};

voidmain（）{

Ax,y（2,5）,z（y）;

}输出结果：

3．

#include

classA{

int*a;

public:

A（intaa=0）{

a=newint（aa）;

cout<<"Constructor!

"<<*a<

};

voidmain（）{

Ax[2];

A*p=newA（5）;

deletep;

}输出结果：

4．

#include

classA{

inta;

public:

A（intaa=0）:

a（aa）{}

~A（）{cout<<"Destructor!

"<

};

voidmain（）{

Ax（5）;

A*p=newA（10）;

deletep;

}输出结果：

#include

classA{

int*a;

public:

A（intx）{

a=newint（x）;

cout<<"Constructor!

"<<*a<

}

~A（）{deletea;cout<<"Destructor!

"<

};

voidmain（）{

Ax（9）,*p;

p=newA（12）;

deletep;

}输出结果：

6．

#include

classA{

inta;

public:

A（intaa=0）:

a（aa）{

};

classB:

publicA{

intb;

public:

B（intaa,intbb）:

A（aa）,b（bb）{

cout<<"ConstructorB!

"<

voidmain（）{

Bx（2,3）,y（4,5）;

}输出结果：

7．

#include

classA{

inta;

public:

A（intaa=0）{a=aa;}

~A（）{cout<<"DestructorA!

"<

};

classB:

publicA{

intb;

public:

B（intaa=0,intbb=0）:

A（aa）{b=bb;}

~B（）{cout<<"DestructorB!

"<

voidmain（）{

Bx（5）,y（6,7）;

}

输出结果：

8．

#include

#include

classA{

inta,b;charop;

public:

A（intaa,intbb,charch）{a=aa;b=bb;op=ch;}

intComp（）{

switch（op）{

case'+':

returna+b;

case'-':

returna-b;

case'*':

returna*b;

case'/':

if（b!

=0）returna/b;elseexit

（1）;

case'%':

if（b!

=0）returna%b;elseexit

（1）;

default:

exit

（1）;}

}

voidSetA（intaa,intbb,charch）{

a=aa;b=bb;op=ch;}

};

voidmain（void）{

Ax（3,5,'*'）;

inta=x.Comp（）;

x.SetA（4,9,'+'）;

a+=x.Comp（）;

x.SetA（13,8,'%'）;

a+=x.Comp（）;

cout<<"a="<

}输出结果：

9．

#include

classB{

inta,b;

public:

B（）{a=b=0;}

B（intaa,intbb）{a=aa;b=bb;}

Boperator+（B&x）{

Br;

r.a=a+x.a;

r.b=b+x.b;

returnr;

}

Boperator-（B&x）{

Br;

r.a=a-x.a;

r.b=b-x.b;

returnr;

}

voidOutB（）{

cout<

}

};

voidmain（）{

Bx（6,5）,y（13,3）,z1,z2;

z1=x+y;z2=x-y;

z1.OutB（）;z2.OutB（）;

}

输出结果：

10．

#includetemplateclassFF{

TTa1,a2,a3;

public:

FF（TTb1,TTb2,TTb3）{

a1=b1;a2=b2;a3=b3;

TTSum（）{returna1+a2+a3;}

};

voidmain（）{

FFx（8,3,4）,y（5,9,11）;

cout<

}

输出结果：

三、写出下列每个函数的功能

1.#include

#include

#include

voidJA（char*fname）

{

ofstreamfout（fname）;

chara[20];

cin>>a;

while（strcmp（a,"end"）!

=0）{

fout<

cin>>a;

}

fout.close（）;

voidJB（char*fname）

{

ifstreamfin（fname）;

chara[20];

inti=0;

while（fin>>a）{

cout<

}

fin.close（）;

cout<<"i="<

}

voidmain（）{

JA（"c:

\gm.dat"）;

JB（"c:

\gm.dat"）;

}

2．

#include

#include

ifstreamfin（fname）;

chara[20];

inti=0;

while（fin>>a）{

cout<

i++;

}

fin.close（）;

cout<<"i="<

}

3．

#include

#include

voidJC（char*fname,intn）

{

ofstreamfout（fname,ios:

:

out|ios:

:

binary）;

intx;

for（inti=0;i

cin>>x;

}

fout.close（）;

voidJD（char*fname）{

ifstreamfin（fname,ios:

:

in|ios:

:

nocreate|ios:

:

binary）;

intx,s=0,n=0;

while（fin.read（（char*）&x,sizeof（x）））{

s+=x;n++;

}

cout<

fin.close;

}

voidmain（）{

JC（"c:

\gm.bat",5）;

JD（"c:

\gm.bat"）;

}

4．

#include

#include

voidJD（char*fname）{

ifstreamfin（fname,ios:

:

in|ios:

:

nocreate|ios:

:

binary）;

intx,s=0,n=0;

s+=x;n++;

}

cout<

fin.close;

}