*bb=NULL):a(aa),b(bb){}”，则该类中至少包含有__________个成员变量。

（21）假定用户为类AB定义了一个构造函数“AB(int aa) {a=aa;}”，该构造函数实现对成员变量_________的初始化。

（22）假定用户为类AB定义了一个构造函数“AB(int aa=0):a(aa){}”，则创建该类的对象时，可以有________种不同的格式。

（23）假定用户只为类AB定义了一个构造函数“AB(int aa, int bb=0) {a=aa; b=bb;}”，则创建该类的对象时，其实参表中至多带有_________个实参。

（24）假定用户只为类AB定义了一个构造函数“AB(int aa, int bb=0) {a=aa; b=bb;}”，则创建该类的对象时，其实参表中至少带有_________个实参。

（25）假定用户为类AB定义了一个构造函数“AB(int aa=0, int bb=0) {a=aa; b=bb;}”，则创建该类的对象时，可以有________种不同的格式。

（26）假定用户只为类AB定义了一个构造函数“AB():a(0),b(0){}”，则创建该类对象x的语句“AB x();”是_________(正确/错误)的。

（27）假定用户只为类AB定义了一个构造函数“AB():a(0),b(0){}”，则创建该类对象x的语句“AB x;”是_________(正确/错误)的。

（28）假定用户只为类AB定义了一个构造函数“AB():a(0),b(0){}”，则创建该类对象x的语句“AB x(5);”是_________(正确/错误)的。

（29）假定AB为一个类，则该类的拷贝构造函数的函数头为_____________。 （30）假定AB为一个类，该类中含有一个指向动态数组空间的指针成员pa，则在该类的析构函数中应该包含有一条______________语句。

（31） 静态成员函数 ____访问类的静态成员变量， ____ 访问类的非静态成员变量。

（32）静态成员变量必须在所有函数的定义体外进行__________。 9.2 选择题：

（1）在类作用域中能够通过直接使用该类的（ ）成员名进行访问。 A. 私有 B. 公有 C. 保护 D. 任何 （2）在关键字public后面定义的成员为类的（ ）成员。 A. 私有 B. 公有 C. 保护 D. 任何 （3）在关键字private后面定义的成员为类的（ ）成员。 A. 私有 B. 公有 C. 保护 D. 任何

（4）假定AA为一个类，a为该类公有的成员变量，x为该类的一个对象，则访问x对象中成员变量a的格式为（ ）。

A. x(a) B. x[a] C. x->a D. x.a

（5）假定AA为一个类，a()为该类公有的成员函数，x为该类的一个对象，则访问x对象中成员函数a()的格式为（ ）。

A. x.a B. x.a() C. x->a D. x->a()

（6）假定AA为一个类，a为该类公有的成员变量，px为指向该类对象的一个指针，则访问px所指对象中成员变量a的格式为（ ）。

11

A. px(a) B. px[a] C. px->a D. px.a

（7）假定AA为一个类，a为该类私有的成员变量，GetValue()为该类公有成员函数，它返回a的值，x为该类的一个对象，则访问x对象中成员变量a的格式为（ ）。

A. x.a B. x.a() C. x->GetValue() D. x.GetValue() （8）假定AA为一个类，int a()为该类的一个成员函数，若该成员函数在类定义体外定义，则函数头为（ ）。

A. int AA::a() B. int AA:a() C. AA::a() D. AA::int a()

（9）假定AA为一个类，a为该类公有的成员变量，若要在该类的一个成员函数中访问它，则书写格式为（ ）。

A. a B. AA::a C. a() D. AA::a() （10）假定AA是一个类，“AA* abc()const;”是该类中一个成员函数的原型，若该函数返回this值，当用x.abc()调用该成员函数后，x的值（ ）。

A. 已经被改变 B. 可能被改变

C. 不变 D. 受到函数调用的影响 （11）类中定义的成员默认为（ ）访问属性。

A. public B. private C. protected D. friend （12）结构体中定义的成员默认为（ ）访问属性。

A. public B. private C. protected D. friend （13）对于一个类的构造函数，其函数名与类名( )。

A. 完全相同 B. 基本相同 C. 不相同 D. 无关系 （14）对于一个类的析构函数，其函数名与类名( )。

A. 完全相同 B. 完全不同 C. 只相差一个字符 D. 无关系 （15）类的构造函数是在定义该类的一个( )时被自动调用执行的。 A. 成员函数 B. 成员变量 C. 对象 D. 友元函数 （16）类的析构函数是一个对象被( )时自动调用的。 A. 建立 B. 撤消 C. 赋值 D. 引用 （17）一个类的构造函数通常被定义为该类的( )成员。 A. 公有 B. 保护 C. 私有 D. 友元 （18） 一个类的析构函数通常被定义为该类的( )成员。 A. 私有 B. 保护 C. 公有 D. 友元

（19）假定AB为一个类，则执行 “AB x;”语句时将自动调用该类的( )。 A. 带参构造函数 B. 无参构造函数

C. 拷贝构造函数 D. 赋值重载函数

（20）假定AB为一个类，则执行 “AB x(a,5);”语句时将自动调用该类的( )。 A. 带参构造函数 B. 无参构造函数 C. 拷贝构造函数 D. 赋值重载函数

（21）假定AB为一个类，则执行 “AB *s=new AB(a,5);”语句时得到的一个动态

12

对象为_______。

A. s B. s->a C. s.a D. *s

（22）假定AB为一个类，则执行 “AB r1=r2;”语句时将自动调用该类的( )。 A. 无参构造函数 B. 带参构造函数 C. 赋值重载函数 D. 拷贝构造函数 （23）若需要使类中的一个指针成员变量指向一块动态存储空间，则通常在( )函数中完成。

A. 析构 B. 构造 C. 任一成员 D. 友元

（24）当类中的一个整型指针成员指向一块具有n*sizeof(int)大小的存储空间时，它最多能够存储( )个整数。

A. n B. n+1 C. n-1 D. 1

（25）假定一个类的构造函数为 “A(int aa, int bb) {a=aa; b=aa*bb;}”，则执行 “A x(4,5);”语句后，x.a和x.b的值分别为( )。

A. 4和5 B. 5和4 C. 4和20 D. 20和5

（26）假定一个类的构造函数为 “A(int aa=1, int bb=0) {a=aa; b=bb;}”，则执行 “A x(4);”语句后，x.a和x.b的值分别为( )。

A. 1和0 B. 1和4 C. 4和1 D. 4和0

（27）假定AB为一个类，则( )为该类的拷贝构造函数的原型说明。 A. AB(AB x); B. AB(AB& x); C. void AB(AB& x); D. AB(int x); （28）假定一个类的构造函数为 “B(int ax, int bx): a(ax), b(bx) {}”，执行 “B x(1,2),y(3,4);x=y;”语句序列后x.a的值为( )。

A. 1 B. 2 C. 3 D. 4 （29）假定一个类AB只含有一个整型成员变量a，当用户不定义任何构造函数时，系统为该类定义的无参构造函数为( )。

A. AB() {a=0;} B. AB(int aa=0): a(aa) {} C. AB(int aa): a(aa) {} D. AB() {}

（30）假定一个类AB只含有一个整型成员变量a，用户为该类定义的带参构造函数可以为( )。

A. AB() {} B. AB(): a(0){} C. AB(int aa=0) {a=aa;} D. AB(int aa) {}

（31）对于任一个类，用户所能定义的构造函数的个数至多为( )。 A. 0 B. 1 C. 2 D. 任意个

（32）对于任一个类，用户所能定义的析构函数的个数至多为( )。 A. 0 B. 1 C. 2 D. 任意个

（33）假定AB为一个类，则执行 “AB *px=new AB[n];”语句时将( )。 A. 动态分配一个对象数组 B. 动态分配一个对象 C. 静态分配一个数组 D. 静态分配一个对象

（34）设px是指向一个类对象的指针变量，则执行 “delete px;”语句时，将自动调用该类的( )。

13

A. 无参构造函数 B. 带参构造函数 C. 析构函数 D. 拷贝构造函数

（35）当一个类对象离开它的作用域时，系统自动调用该类的( )。

A. 无参构造函数 B. 带参构造函数 C. 拷贝构造函数 D. 析构函数 （36）假定一个类对象数组为A[n]，当离开它定义的作用域时，系统自动调用该类析构函数的次数为( )。

A. 0 B. 1 C. n D. n-1

（37）假定AB为一个类，则执行 “AB a[10];”语句时调用该类无参构造函数的次数为( )。

A. 0 B. 1 C. 9 D. 10

（38）假定AB为一个类，则执行 “AB *px=new AB[n];”语句时调用该类无参构造函数的次数为( )。

A. n B. n-1 C. 1 D. 0

（39）一个类的静态成员变量所表示属性 ( )。

A. 是类的或对象的属性 B. 只是对象的属性 C. 只是类的属性 D. 类和友元的属性 （40）类的静态成员的访问控制（ ）。 A. 只允许被定义为private

B. 只允许被定义为private或protected C. 只允许被定义为public

D. 可允许被定义为private、protected或public （41）静态成员函数对类的成员变量访问（ ）。

A. 是不允许的 B. 只允许是静态成员变量

C. 只允许是非静态成员变量 D. 可允许是静态成员变量或非静态成员变量 （42）被非静态成员函数访问的类的成员变量( )。

A. 可以是非静态成员变量或静态成员变量 B. 不可能是类的静态成员变量

C. 只能是类的非静态成员变量 D. 只能是类的静态成员变量 （43）静态成员变量的初始化是在（ ）中进行的。 A. 构造函数 B. 任何成员函数 C. 所属类 D. 全局区

9.3 怎样定义私有成员？怎样定义公有成员？私有成员和公有成员有什么差别？

9.4 C++语言的类定义中，类的成员变量和成员函数分别描述了对象模型中的什么成分？

9.5 成员变量在定义时是否允许给出初始值？为什么？

9.6 构造函数的功能是什么？系统是在什么时候、以什么方式调用构造函数的？ 9.7 析构函数的功能是什么？系统是在什么时候、以什么方式调用析构函数的？

14

9.8 构造函数是否可以重载？重载构造函数有什么意义？析构函数是否可以重载？

9.9 构造函数设计时应注意哪些事项？

9.10 什么样的类的析构函数可以设计为空？什么样的类的析构函数不可以设计为空？为什么？

9.11 C++语言中的构造函数和析构函数有返回值吗？你能解释其原因吗？

9.12 当在类定义体外实现成员函数时，为什么要在成员函数的返回类型后、成员函数名前加上“<类名>：：”？ 9.13 在编译完例3.1程序后，系统是否为各成员函数的参数分配了内存空间？为什么？

9.14 创建对象和定义变量有什么差别？ 9.15 什么叫const对象？ 9.16 怎样创建动态对象？

9.17 一个外部程序中的对象可以访问类中的私有成员吗？可以访问类中的公有成员吗？

9.18 写出对象调用其成员的语句形式。写出指向对象的指针调用其成员的语句形式。

9.19 一个非const成员函数可以修改类中的const成员变量吗？一个const成员函数可以修改类中的const成员变量吗？ 9.20 什么叫重载？重载有什么意义？

9.21 什么叫子对象？整体——部分对象模式是怎样实现的？

9.22 什么叫外部类？什么叫内部类？什么样的类可以设计成内部类？

9.23 static成员变量和非static成员变量有什么差别？static成员函数和非static成员函数有什么差别？

9.24 若一个类的某个成员函数修饰为const，表示什么含义？若一个成员函数的某个参数修饰为const，表示什么含义？

9.25 在一个应用程序中，怎样进行static成员变量的初始化赋值？

9.26 类是创建对象的模板，一个程序中创建了许多对象，当这些对象都调用一个相同的成员函数时，系统是怎样区分当前是哪个对象调用的？

9.27 在开发一个应用系统时，应该用怎样的分析方法从现实世界中抽象出类？ 9.28 类怎样体现了封装性？

9.29 以例3.16为例说明，类中的一个成员变量，是否可因为要求承担的任务太多而应该单独设计成一个类？

程序阅读和设计题：

9.30 阅读程序，给出运行结果：

（1）

#include \

15