类和对象Word文档下载推荐.docx

类和对象Word文档下载推荐.docx

《类和对象Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《类和对象Word文档下载推荐.docx（42页珍藏版）》请在冰豆网上搜索。

x=2,y=3。

注意：

构造函数是唯一不能被显式调用的成员函数，它在定义类的对象时自动调用，也称为隐式调用。

--------------------------------------------------------

题2.分析以下程序的执行结果

~Sample（）

if（x==y）

x=y"

else

x!

=y"

本题说明了析构函数的定义方法。

首先定义了一个类Sample,在main（）中定义了它的一个对象，定义s1对象时调用其重载构造函数（x=2,y=3），然后，调用其成员函数输出数据成员，最后在退出程序时自动调用析构函数。

x=2,y=3

=y

析构函数在对象的作用域结束时被自动隐式调用。

----------------------------------------------------

题3.分析以下程序的输出结果

intx;

Sample（inta）

x=a;

constructingobject:

voidfunc（intn）

staticSampleobj（n）;

func

（1）;

func（10）;

本题说明静态对象构造函数的调用情况，由于在func（）函数中定义的对象obj是静态对象，故只被构造一次，所以输出为：

counstructingobject:

x=1

静态对象和静态变量一样，只被构造一次。

块作用域的静态变量，在首次进入到定义该静态对象的函数时，构造该静态对象，以后进入该函数时不再构造静态对象。

------------------------------------------------------

题1.4分析以下程序的执行结果

{

Samples（2,3）,*p=&

s;

p->

disp（）;

本题说明了对象指针的使用方法。

这里通过指向对象的指针来调用对象的成员函数。

对象指针p指向对象s，p->

disp（）等价于s.disp（）。

x=2,y=3.

题1.5分析以下程序的执行结果

inty;

intSample:

:

*pc;

Samples;

pc=&

Sample:

x;

s.*pc=10;

y;

s.*pc=20;

s.disp（）;

本题说明了类数据成员指针的使用方法。

在main（）中定义的pc是一个指向Sample类数据成员的指针。

执行pc=&

x时，pc指向数据成员x，语句s.*pc=10等价于s.x=10（为了保证该语句正确执行，Sample类中的x必须是公共成员）；

y时，pc指向数据成员y，语句s.*pc=20等价于s.y=20（同样，Sample类中的y必须是公共成员）。

x=10,y=20。

-----------------------------------------------------

题1.6下面是一个类的测试程序，设计出能使用如下测试程序的类。

Testa;

a.init（68,55）;

a.print（）;

其执行结果为：

测试结果：

68-55=13

本题是要设计Test类，其设计方法很多，这里给出一种解法。

Test类包含两个私有数据成员x、y，以及两个公共成员函数init（）和print（），前者用于给数据成员赋值，后者用于x,y的减法运算和输出相应的结果。

classTest

voidinit（int,int）;

voidprint（）;

voidTest:

init（inti,intj）

x=i;

y=j;

print（）

-"

="

x-y<

类是一个外壳，它包含了类实例化时数据和代码的使用方法，它是一种模板，只有在定义类的对象时，才为对象分配空间，而不会为类分配空间。

题1.7设计一个Bank类，实现银行某账号的资金往来账目管理，包括建账号、存入、取出等。

Bank类包括私有数据成员top（当前账指针），date（日期），money（金额），rest（余额）和sum（累计余额）。

另有一个构造函数和三个成员函数bankin（）（处理存入账），bankout（）处理取出账）和disp（）（输出明细账）。

本题程序如下：

stdio.h>

string.h>

#defineMax100

classBank

inttop;

chardate[Max][10];

//日期

intmoney[Max];

//金额

intrest[Max];

//余额

staticintsum;

//累计余额

Bank（）{top=0;

voidbankin（chard[],intm）

strcpy（date[top],d）;

money[top]=m;

sum=sum+m;

rest[top]=sum;

top++;

voidbankout（chard[],intm）

money[top]=-m;

sum=sum-m;

voiddisp（）;

intBank:

sum=0;

voidBank:

disp（）

inti;

printf（"

日期存入取出余额\n"

）;

for（i=0;

i<

top;

i++）

%8s"

date[i]）;

if（money[i]<

0）

%6d"

-money[i]）;

%6d"

money[i]）;

%6d\n"

rest[i]）;

Bankobj;

obj.bankin（"

2001.2.5"

1000）;

2001.3.2"

2000）;

obj.bankout（"

2001.4.1"

500）;

2001.4.5"

800）;

obj.disp（）;

本程序的执行结果如下：

日期存入取出余额

2001.2.510001000

2001.3.220003000

2001.4.15002500

2001.4.58001700

题1分析以下程序的执行结果

Samples1,s2（2,3）;

s2.disp（）;

本题说明了构造函数的调用顺序。

首先定义了一个类Sample,在main（）中定义了它的两个对象，定义s1对象时调用其默认构造函数（x=0,y=0），定义s2对象时调用其重载构造函数（x=2,y=3），然后，调用各自的成员函数输出各自的数据成员。

x=0,y=0

-----------------------------------------------

题2分析以下程序执行的结果

Sample（）{x=y=0;

Sample（inta,intb）{x=a;

s1.~Sample（）;

本题说明了可以显式调用析构函数。

首先定义了一个类Sample,在main（）中定义了它的一个对象，定义s1对象时调用其重载构造函数（x=2,y=3）,然后，调用其成员函数输出数据成员，然后调用一次析构函数，最后在退出程序时又自动调用析构函数，所以输出为：

析构函数不同于构造函数，析构函数既能被显式调用，也能被隐式调用。

题3分析以下程序的执行结果

本题说明了析构函数的调用顺序，这里定义了两个对象，先顺序调用s1和s2对象的构造函数，再调用各自的成员函数disp（），最后顺序调用s2和s1的析构函数。

x=y

题4.分析以下程序的执行结果

if（s1.x==2）

exit（0）;

本题说明了非正常退出程序时析构函数调用的情况。

定义了一个类Sample,在main（）中定义了它的一个对象，定义s1对象时调用其重载构造函数（x=2,y=3）,然后，调用其成员函数输出数据成员，由于if条件成立，执行exit非正常退出，不会隐式调用析构函数，所以输出为：

如果程序使用exit、abort非正常退出，不会隐式调用析构函数，这样造成对象申请资源无法回收，从而导致操作系统的资源紧张而使应用程序无法运行。

因此在通常情况下，应使用return语句正常退出。

题5.分析以下程序的执行结果

Sample（inta,intb）{x=a,y=b;

Sample（2,3）;

本题说明了常量对象的构造函数和析构函数的调用情况。

在main（）中定义了一个常量对象，常量对象在构造之后立即析构。

常量对象的作用域不是整个main（）函数，而是仅限于包含该常量的值表达式，表达式一旦计算完成，其中的对象就按构造的逆序析构。

题6.分析以下程序的执行结果

Sample（）;

Sample（int）;

~Sample（）;

voiddisplay（）;

protected:

Sample（）

x=0;

constructingnormally\n"

;

Sample（intm）

x=m;

constructingwithanumber:

voidSample:

display（）

displayanumber:

destructing\n"

Sampleobj1;

Sampleobj2（20）;

obj1.display（）;

obj2.display（）;

本题构造函数与析构函数的调用顺序。

这里定义了两个对象，先顺序调用obj1和obj2对象的构造函数，再调用各自的成员函数disp（），最后顺序调用obj2和obj1的析构函数。

constructingnomally

20

0

destructing

题7.分析以下程序的执行结果

intn;

Sample（intx）{n=x;

voidadd（）{sum+=n;

n="

n<

sum="

sum<

//静态数据成员赋初值

Samplea

（2）,b（3）,c（5）;

a.add（）;

a.disp（）;

b.add（）;

b.disp（）;

c.add（）;

c.disp（）;

本题说明静态数据成员的使用方法。

在类中定义了一个静态数据成员sum，在main（）之前给它赋初值0，然后在main（）中定义了三个对象，并执行各自的add（）和disp（）方法。

n=2,sum=2

n=3,sum=5

n=5,sum=10

静态数据成员脱离具体的对象独立存在，其存储单元不是任何对象存储空间的一部分，但逻辑上所有对象都共享这一存储单元，对静态数据成员的任何操作都会访问这一存储单元，从而影响这一存储单元的所有对象。

所以说静态数据成员不是对象成员，在引用时不需要用对象名。

-题8.分析以下程序执行的结果

intA;

staticintB;

Sample（inta）{A=a,B+=a;

staticvoidfunc（Samples）;

func（Samples）

A="

s.A<

B="

B<

B=0;

Samples1

（2）,s2（5）;

func（s1）;

func（s2）;

本题说明了静态成员函数的使用方法。

其中的数据成员B是静态数据成员，求B之值是在构造函数中进行的。

A=2,B=7

A=5,B=7

静态成员函数与静态数据成员一样，也不是对象成员。

静态成员函数的调用不同于普通的成员函数。

在静态成员函数的实现中，引用类的非静态数据成员是通过对象进行的，如本题中s.A，引用类的静态数据成员是直接进行的，如本题中的B。

-----------------------------------------------------------

题9.分析以下程序的执行结果

charc1,c2;

Sample（chara）{c2=（c1=a）-32;

c1<

转换为"

c2<

Samplea（'

a'

）,b（'

b'

本题说明了构造函数的调用方法。

对于对象定义<

对象名>

（c），构造函数执行c1=c,c2=c-32（小写转大写）。

a转换为A

b转换为B

------------------------------------------------------------

题10.分析以下程序执行的结果

Samples1,s2（1,2）,s3（10,20）;

Sample*pa[3]={&

s1,&

s2,&

s3};

for（inti=0;

3;

pa[i]->

本题说明对象指针数组赋初值方法。

定义三个对象和一个对象指针数组，通过赋初值使后者的元素分别指向前面三个对象，然后使用for语句循环调用各个对象的disp（）成员函数。

x=1,y=2

x=10,y=20

----------------------------------------------------------

题11.分析以下程序的执行结果

end