c++类与对象作业题 挺重要.docx
- 文档编号:26278682
- 上传时间:2023-06-17
- 格式:DOCX
- 页数:49
- 大小:26.67KB
c++类与对象作业题 挺重要.docx
《c++类与对象作业题 挺重要.docx》由会员分享,可在线阅读,更多相关《c++类与对象作业题 挺重要.docx(49页珍藏版)》请在冰豆网上搜索。
c++类与对象作业题挺重要
做你想做的,但你首先要知道你想做的是什么
一、选择与填空
1.下列有关类的说法不正确的是()。
A.对象是类的一个实例
B.任何一个对象只能属于一个具体的类
C.一个类只能有一个对象
D.类与对象的关系和数据类型与变量的关系相似
答案:
C
分析:
对象是类的一个实例,类与对象的关系和数据与变量的关系相似,所以一个类可以有多个对象。
2.下面()项是对构造函数和析构函数的正确定义。
A.voidX:
:
X(),voidX:
:
~X()
B.X:
:
X(参数),X:
:
~X()
C.X:
:
X(参数),X:
:
~X(参数)
D.voidX:
:
X(参数),voidX:
:
~X(参数)
答案:
B
分析构造函数无返回类型、可带参数、可重载;析构函数无返回类型、不可带参数、不可重载。
3.()的功能是对象进行初始化。
A.析构函数B.数据成员C.构造函数D.静态成员函数
答案:
C
分析:
当一个对象定义时,C++编译系统自动调用构造函数建立该对象并进行初始化;当一个对象的生命周期结束时,C++编译系统自动调用析构函数注销该对象并进行善后工作;
4.下列表达方式正确的是()。
A.classP{B.classP{
public:
public:
intx=15;intx;
voidshow(){cout< };} C.classP{D.classP{ intf;public: };inta; f=25;voidSeta(intx){a=x;} 答案: D 分析: 在类体不可对数据成员进行初始化;类定义结束时需用分号;只有类中的成员函数才能存取类中的私有数据。 5.拷贝构造函数具有的下列特点中,()是错误的。 A.如果一个类中没有定义拷贝构造函数时,系统将自动生成一个默认的 B.拷贝构造函数只有一个参数,并且是该类对象的引用 C.拷贝构造函数是一种成员函数 D.拷贝构造函数的名字不能用类名 答案: D 分析: 如果一个类中没有定义拷贝构造函数时,系统将自动生成一个默认的;拷贝构造函数只有一个参数,并且是该类对象的引用;拷贝构造函数的名字与类同名,并且不被指定返回类型;拷贝构造函数是一种成员函数。 6.关于静态成员的描述中,()是错误的。 A.静态成员可分为静态数据成员和静态成员函数 B.静态数据成员定义后必须在类体进行初始化 C.静态数据成员初始化不使用其构造函数 D.静态数据成员函数中不能直接引用非静态成员 答案: B 静态成员的初始化位置在哪怎么初始化的 分析: 静态成员可分为静态数据成员和静态成员函数;静态数据成员被定义后,必须对它进行初始化,初始化在类体外进行,一般放在该类的实现部分最合适,也可以放在其他位置,例如,放在主函数前面等;静态数据成员初始化与该类的构造函数和析构函数无关;在静态成员函数的实现中,可以直接引用静态成员,但不能直接引用非静态成员。 7.关于友元的描述中,()是错误的。 A.友元函数是成员函数,它被说明在类体 B.友元函数可直接访问类中的私有成员 C.友元函数破坏封装性,使用时尽量少用 D.友元类中的所有成员函数都是友元函数 答案: A 分析: 友元函数是非成员函数,在类体说明了,在类体外定义,定义和调用等同于一般的普通函数;由于它可以直接访问类的私有成员,因此破坏了类的封装性和隐藏性,尽量少用。 8.设有如下程序结构: classBox {…}; voidmain() {BoxA,B,C;} 该程序运行时调用 (1)次构造函数;调用 (2)次析构函数。 答案: (1)3 (2)3 分析: 每创建一个对象自动调用一次构造函数,在这里创建了A、B、C三个对象,所以共调用了三次构造函数;每释放一个对象,系统自动调用一次析构函数,A、B、C对象释放时,分别调用析构函数,所以析构函数共调用了三次。 9.设A为test类的对象且赋有初值,则语句testB(A);表示。 答案: 将对象A复制给对象B。 分析: 执行testB(A);语句相当于调用了默认复制构造函数,将A对象的属性复制给B对象。 10.利用“对象名.成员变量”形式访问的对象成员仅限于被声明为 (1)的成员;若要访问其他成员变量,需要通过 (2)函数或(3)函数。 答案: (1)public (2)成员函数(3)友元函数 分析: 类体的数据成员可声明为公有的、私有的和保护的,公有的数据成员可利用“对象名.成员变量”形式来进行访问;私有的数据成员能被类中的其他成员函数或友元函数所调用;保护的数据成员可以在类体中使用,也可以在派生类中使用,但不能在其他类外通过对象使用。 11.对类的构造函数和析构函数描述正确的是()。 A.构造函数可以重载,析构函数不能重载 B.构造函数不能重载,析构函数可以重载 C.构造函数可以重载,析构函数也可以重载 D.构造函数不能重载,析构函数也不能重载 答案: A 12.类的析构函数的作用是(D)。 A.一般成员函数B.类的初始化C.对象初始化D.删除对象 答案: D 13.假设OneClass为一个类,则该类的拷贝初始化构造函数的声明语句为()。 A.OneClass(OneClassp);B.OneClass&(OneClassp); C.OneClass(OneClass&p);D.OneClass(OneClass*p); 答案: C 14.下面对于友元函数描述正确的是()。 A.友元函数的实现必须在类的部定义 B.友元函数是类的成员 C.友元函数破坏了类的封装性和隐藏性 D.友元函数不能访问类的私有成员 答案: C 15.对于结构中定义的成员,其默认的访问权限为()。 A.publicB.protectedC.privateD.static 答案: C 16.为了使类中的某个成员不能被类的对象通过成员操作符访问,则不能把该成员的访问权限定义为()。 A.publicB.protectedC.privateD.static 答案: A 17.下面对静态数据成员的描述中,正确的是()。 A.静态数据成员可以在类体进行初始化 B.静态数据成员不可以在类体进行初始化 C.静态数据成员不能受private控制符的作用 D.静态数据成员可以直接用类名调用 答案: B 18.下面对静态数据成员的描述中,正确的是()。 A.静态数据成员是类的所有对象共享的数据 B.类的每一个对象都有自己的静态数据成员 C.类的不同对象有不同的静态数据成员值 D.静态数据成员不能通过类的对象调用 答案: A 二、分析程序执行结果,如果出错则分析其出错结果 1.分析以下程序执行的结果 #include #include classSample { public: intx,y; Sample(){x=y=0;} Sample(inta,intb){x=a;y=b;} voiddisp() { cout<<"x="< } }; voidmain() { Samples1(2,3); s1.disp(); } 解: 本题说明了重载构造函数的定义方法。 首先定义了一个类Sample,在main()中定义了它的一个对象,定义s1对象时调用其重载构造函数(x=2,y=3),然后,调用其成员函数输出数据成员。 所以输出为: x=2,y=3。 注意: 构造函数是唯一不能被显式调用的成员函数,它在定义类的对象时自动调用,也称为隐式调用。 -------------------------------------------------------- 2.分析以下程序的执行结果 #include classSample { intx,y; public: Sample(){x=y=0;} Sample(inta,intb){x=a;y=b;} ~Sample() { if(x==y) cout<<"x=y"< else cout<<"x! =y"< } voiddisp() { cout<<"x="< } }; voidmain() { Samples1(2,3); s1.disp(); } 解: 本题说明了析构函数的定义方法。 首先定义了一个类Sample,在main()中定义了它的一个对象,定义s1对象时调用其重载构造函数(x=2,y=3),然后,调用其成员函数输出数据成员,最后在退出程序时自动调用析构函数。 所以输出为: x=2,y=3 x! =y 注意: 析构函数在对象的作用域结束时被自动隐式调用。 3.分析以下程序的输出结果 #include classSample { intx; public: Sample(inta) { x=a; cout<<"constructingobject: x="< } }; voidfunc(intn) { staticSampleobj(n); } voidmain() { func (1); func(10); } 解: 本题说明静态对象构造函数的调用情况,由于在func()函数中定义的对象obj是静态对象,故只被构造一次,所以输出为: counstructingobject: x=1 注意: 静态对象和静态变量一样,只被构造一次。 块作用域的静态变量,在首次进入到定义该静态对象的函数时,构造该静态对象,以后进入该函数时不再构造静态对象。 ------------------------------------------------------ 4.分析以下程序的执行结果 #include classSample { intx,y; public: Sample(){x=y=0;} Sample(inta,intb){x=a;y=b;} voiddisp() { cout<<"x="< } }; voidmain() { Samples(2,3),*p=&s; p->disp(); } 解: 本题说明了对象指针的使用方法。 这里通过指向对象的指针来调用对象的成员函数。 对象指针p指向对象s,p->disp()等价于s.disp()。 所以输出为: x=2,y=3. 5.分析以下程序的执行结果 #include classSample { public: intx; inty; voiddisp() { cout<<"x="< } }; voidmain() { intSample: : *pc; Samples; pc=&Sample: : x; s.*pc=10; pc=&Sample: : y; s.*pc=20; s.disp(); } 解: 本题说明了类数据成员指针的使用方法。 在main()中定义的pc是一个指向Sample类数据成员的指针。 执行pc=&Sample: : x时,pc指向数据成员x,语句s.*pc=10等价于s.x=10(为了保证该语句正确执行,Sample类中的x必须是公共成员);执行pc=&Sample: : y时,pc指向数据成员y,语句s.*pc=20等价于s.y=20(同样,Sample类中的y必须是公共成员)。 所以输出为: x=10,y=20。 ----------------------------------------------------- 6.分析以下程序的执行结果 #include classSample { intx,y; public: Sample(){x=y=0;} Sample(inta,intb){x=a;y=b;} voiddisp() { cout<<"x="< } }; voidmain() { Samples1,s2(2,3); s1.disp(); s2.disp(); } 解: 本题说明了构造函数的调用顺序。 首先定义了一个类Sample,在main()中定义了它的两个对象,定义s1对象时调用其默认构造函数(x=0,y=0),定义s2对象时调用其重载构造函数(x=2,y=3),然后,调用各自的成员函数输出各自的数据成员。 所以输出为: x=0,y=0 x=2,y=3 ----------------------------------------------- 7.分析以下程序执行的结果 #include classSample { intx,y; public: Sample(){x=y=0;} Sample(inta,intb){x=a;y=b;} ~Sample() { if(x==y) cout<<"x=y"< else cout<<"x! =y"< } voiddisp() { cout<<"x="< } }; voidmain() { Samples1(2,3); s1.disp(); s1.~Sample(); } 解: 本题说明了可以显式调用析构函数。 首先定义了一个类Sample,在main()中定义了它的一个对象,定义s1对象时调用其重载构造函数(x=2,y=3),然后,调用其成员函数输出数据成员,然后调用一次析构函数,最后在退出程序时又自动调用析构函数,所以输出为: x=2,y=3 x! =y x! =y 注意: 析构函数不同于构造函数,析构函数既能被显式调用,也能被隐式调用。 ---------------------------------------------------- 8.分析以下程序的执行结果 #include classSample { intx,y; public: Sample(){x=y=0;} Sample(inta,intb){x=a;y=b;} ~Sample() { if(x==y) cout<<"x=y"< else cout<<"x! =y"< } voiddisp() { cout<<"x="< } }; voidmain() { Samples1,s2(2,3); s1.disp(); s2.disp(); } 解: 本题说明了析构函数的调用顺序,这里定义了两个对象,先顺序调用s1和s2对象的构造函数,再调用各自的成员函数disp(),最后顺序调用s2和s1的析构函数。 所以输出为: x=0,y=0 x=2,y=3 x! =y x=y 9.分析以下程序的执行结果 #include #include classSample { public: intx,y; Sample(){x=y=0;} Sample(inta,intb){x=a;y=b;} voiddisp() { cout<<"x="< } ~Sample() { if(x==y) cout<<"x=y"< else cout<<"x! =y"< } }; voidmain() { Samples1(2,3); s1.disp(); if(s1.x==2) exit(0); } 解: 本题说明了非正常退出程序时析构函数调用的情况。 定义了一个类Sample,在main()中定义了它的一个对象,定义s1对象时调用其重载构造函数(x=2,y=3),然后,调用其成员函数输出数据成员,由于if条件成立,执行exit非正常退出,不会隐式调用析构函数,所以输出为: x=2,y=3 注意: 如果程序使用exit、abort非正常退出,不会隐式调用析构函数,这样造成对象申请资源无法回收,从而导致操作系统的资源紧而使应用程序无法运行。 因此在通常情况下,应使用return语句正常退出。 ----------------------------------------------- 10.分析以下程序的执行结果(不用看了! ) #include classSample { intx,y; public: Sample(){x=y=0;} Sample(inta,intb){x=a,y=b;} ~Sample() { if(x==y) cout<<"x=y"< else cout<<"x! =y"< } voiddisp() { cout<<"x="< } }; voidmain() { Sample(2,3); } 解: 本题说明了常量对象的构造函数和析构函数的调用情况。 在main()中定义了一个常量对象,常量对象在构造之后立即析构。 所以输出为: x! =y 注意: 常量对象的作用域不是整个main()函数,而是仅限于包含该常量的值表达式,表达式一旦计算完成,其中的对象就按构造的逆序析构。 -------------------------------------------------------- 11.分析以下程序的执行结果 #include classSample { public: Sample(); Sample(int); ~Sample(); voiddisplay(); protected: intx; }; Sample: : Sample() { x=0; cout<<"constructingnormally\n"; } Sample: : Sample(intm) { x=m; cout<<"constructingwithanumber: "< } voidSample: : display() { cout<<"displayanumber: "< } Sample: : ~Sample() { cout<<"destructing\n"; } voidmain() { Sampleobj1; Sampleobj2(20); obj1.display(); obj2.display(); } 解: 本题构造函数与析构函数的调用顺序。 这里定义了两个对象,先顺序调用obj1和obj2对象的构造函数,再调用各自的成员函数disp(),最后顺序调用obj2和obj1的析构函数。 所以输出为: constructingnomally constructingwithanumber: 20 displayanumber: 0 displayanumber: 20 destructing destructing -------------------------------------------------------- ☺☺☺✌✌✌✌✌✌ #include classSample { intn; staticintsum; public: Sample(intx){n=x;} voidadd(){sum+=n;} voiddisp() { cout<<"n="< } }; intSample: : sum=0;//静态数据成员赋初值 voidmain() { 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 注意: 静态数据成员脱离具体的对象独立存在,其存储单元不是任何对象存储空间的一部分,但逻辑上所有对象都共享这一存储单元,对静态数据成员的任何操作都会访问这一存储单元,从而影响这一存储单元的所有对象。 所以说静态数据成员不是对象成员,在引用时不需要用对象名。 13.分析以下程序执行的结果 #include classSample { intA; staticintB; public: Sample(inta){A=a,B+=a;} staticvoidfunc(Samples); }; voidSample: : func(Samples) { cout<<"A="< } intSample: : B=0; voidmain() { Samples1 (2),s2(5); Sample: : func(s1); Sample: : func(s2); } 解: 本题说明了静态成员函数的使用方法。 其中的数据成员B是静态数据成员,求B之值是在构造函数中进行的。 所以输出为: A=2,B=7 A=5,B=7 注意: 静态成员函数与静态数据成员一样,也不是对象成员。 静态成员函数的调用不同于普通的成员函数。 在静态成员函数的实现中,引用类的非静态数据成员是通过对象进行的,如本题中s.A,引用类的静态数据成员是直接进行的,如本题中的B。 -------------------
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- c+类与对象作业题 挺重要 c+ 对象 作业题 重要