类和对象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
升级会员 