国家二级C++机试(类和对象)模拟试卷14(题后含答案及解析)

国家二级C++机试（类和对象）模拟试卷14 (题后含答案及解析)

题型有：1. 选择题

选择题

1． 下列关于this指针的描述中，正确的是( )。 A．类的成员函数都有this指针 B．类的友元函数都有this指针

C．任何与类相关的函数都有this指针 D．类的非静态成员函数都有this指针

正确答案：D

解析：this是成员函数所属对象的指针，它指向类对象的地址。成员函数通过这个指针可以知道自己属于哪一个对象，它隐藏于每个类的非静态成员函数中。 知识模块：类和对象

2． 有如下程序： #include＜iostream＞ using namespace std； class Test { public： Test( ) {n+=2；} ～Test( ){n-=3；} static int getNum0{return n；} private： static int n； }； int Test：：n=1； int main( ) { Test*p=new”rest； delete p； tout＜＜’’n=‘‘＜＜Test：：getNum( )＜＜end1； return 0； } 执行后的输出结果是( )。

A．n=0 B．n=1 C．n=2 D．n=3

正确答案：A 解析：此题考查的是静态数据成员和静态成员函数。静态数据成员是类中所有对象共享的成员，而不是某个对象的成员。题目中的静态数据成员n的运算具有叠加性，执行“n+=2”和“n-=3”后n的值为0。 知识模块：类和对象

3． 有如下程序： #include＜iostream＞ using namespace std； class Obj{ static int i； public： Obj( ){i++；} ～Obj( ){i--；} static hat getVal( ){return i；} }； int Obj：：i=0； void f( ){Obj ob2；cout＜＜ob2．getVal( )；} int main( ){ Obj ob1； f( )； Obj*ob3=new Obj；cout＜＜ob3-＞getVal q( )； delete ob3；cout＜＜Obj：：getVal( )； return 0； } 程序的输出结果是( )。

A．232 B．231 C．222 D．221

正确答案：D

解析：此题考查的是静态成员。本题中，Obj类定义了一个静态数据成员i，并初始化为0在主函数中，首先定义了1个该类对象ob1，所以构造函数被调用1次，i加1；然后调用函数f( )，该函数中又定义了一个对象ob2，此时i再次加1变为2，然后通过函数getVal( )揄出i的值2。f( )函数结束，ob2变量被释放，故析构函数被调用了1次，i变成1；回到主函数中，又动态创建了1个对象并让ob3指向它，此后i变成2并输出。最后释放动态创建的对象i变为1，输出1。故最终的输出结果是221。 知识模块：类和对象

4． 有如下程序： #include＜iostream＞ using namespace std； class MyClass{ public： MyClass( ){++count；} ～MyClass( ){--count；} static int getCount( ){return count；} private： static int count； }； int MyClass：：count=0； int main( ) { MyClass obj； cout＜＜obj．getCount( )； MyClass*ptr=new MyClass； cout＜＜MyClass：：getCount( )； delete ptr； cout＜＜MyClass：：getCount( )； return 0； } 程序的输出结果是( )。

A．121 B．232 C．221 D．122

正确答案：A 解析：此题考查的是静态成员。静态成员的特性是不管这个类创建了多少对象，它的静态成员都只有一个拷贝副本，这个副本被所有属于这个类的对象共享。题目中，首先定义了obj对象，其构造函数使静态数据成员cout增1，故输出“1”；然后通过指针动态创建了Myclass类的对象，构造函数被再次调用，count变为2，输出“2”；接着删除创建的MyClass类的对象，调用析构函数，count减1变为1，输出“1”。故最终输出结果是121。 知识模块：类和对象

5． 有如下类定义： class Point{ private； static int how_many； }； __how_many=0； 要初始化Point类的静态成员how_many，下划线处应填入的内容是( )。

A．ing

B．static int C．int Point：： D．static int Point：：

正确答案：C 解析：此题考查的是静态数据成员的初始化。静态数据成员应在类体外进行初始化，且初始化的一般格式为：数据类型类名：：静态数据成员名=初始值。 知识模块：类和对象

6． 有如下类和对象的定义： class Constants { public； static

double getPl( ){return 3．1416；} }； Constants constants； 下列各组语句中，能输出3．1416的是( )。

A．cout＜＜constants-＞getPI( )；和cout＜＜Constants：：gerPI( )； B．cout＜＜constants．getPI( )；和cout＜＜Constants．getPI( )； C．cout＜＜constants-＞getaI( )；和cout＜＜Constants-＞getPI( )； D．cout＜＜constants．getPI( )；和cout＜＜Constants：：getPI( )；

正确答案：D

解析：此题考查的是静态成员函数的引用。getPI( )是类C0nstants的静态成员函数。引用静态成员函数可以有两种形式：一是通过类名直接进行调用，例如类名：：静态成员函数名；另一种是用类的任何对象名进行调用其作用仅是通过对象名间接的指出类名，例如constants．getPI( )选项D即是这种调用方式。 知识模块：类和对象

7． 若AA为一个类，a为该类的非静态数据成员，在该类的一个成员函数定义中访问a时，其书写格式为( )。

A．a

B．AA．a C．a{} D．AA：：a{}

正确答案：A

解析：类AA的成员函数直接引用类AA的非静态数据成员。 知识模块：类和对象

8． 有如下类定义： class Sample{ public； Sample(int x)：ref(x){} ／／① private：Sample( )：ref(0){} ／／② static int val=5； ／／③ const int ref； ／／④}；上述程序段中，错误的语句是( )。

A．① B．② C．③ D．④

正确答案：C

解析：静态整型数据不能定义为类的数据成员。 知识模块：类和对象

9． 已知类Myclass的定义如下 class MyClass { public： void function1(MyClass&c){cout＜＜c．data；} static void function2(MyClass&c){cout＜＜c．data；} void function3( ){cout＜＜data；} staric void function4( ){cout＜＜data；} private： int data； }； 其中有编译错误的函数是( )。

A．function1 B．function2 C．function3

D．functicIn4

正确答案：D

解析：funcyion4( )函数作为类的静态成员函数，不能直接访问类中说明的非静态成员，即cout＜＜data在编译时会出错。 知识模块：类和对象

10． 有如下程序： #include＜iostream＞ using namespace std； class XA{ im a； public： static int b； XA(int aa)：a(aa){b++；} int getA( ){return a；} }； int XA：：b=0； int main( ) { XA d1(4)，d2(5)； cout＜＜d1．getA( )+d2．getA( )+XA：：b+d1．b＜＜end1； return 0； } 运行这个程序的输出结果是( )。

A．9 B．11 C．13 D．15

正确答案：C

解析：在类XA的构造函数中，定义了用成员变量a的值初始化变量aa，同时静态成员变量b值加1。所以当在主main函数中定义类xA的对象d1(4)后，变量b的等于1，定义对象d2(5)后，变量b的值等于2，所以表达式d1．getA( )+d2．getA( )：：b+d1．b等于4+5+1+2+1=13。 知识模块：类和对象

11． 由于常对象不能被更新，因此( )。 A．通过常对象只能调用它的常成员函数 B．通过常对象只能调用静态成员函数 C．常对象的成员都是常成员

D．通过常对象可以调用任何不改变对象值的成员函数

正确答案：A

解析：此题考查的是常对象与常成员函数的概念。使用const关键字修饰的对象称为常对象，它不能被更新，所以常对象只能调用常成员函数而不能调用其它成员函数；使用const关键字声明的成员函数是常成员函数，它也不能被更新，常成员函数只能调用常成员函数而不能调用其它函数。 知识模块：类和对象

12． 有如下程序 #include＜iostream＞ using namespace std； int i=1； class Fun{ public： static int i； int value( ){return i-1；} int value( )const{return i+1；} }； int Fun：：i=2； int main( ){ int i=3； Fun fun1; const Fun fun2； return 0； } 若程序的输出结果是： 123 则程序中下划线处遗漏的语句是( )。

A．cout＜＜fun1．value( )＜＜Fun：：i＜＜fun2．value( )； B．cout＜＜Fun：：i＜＜fun1．value( )＜＜fun2．value( )； C．cout＜＜fun 1．value( )<<fun2．value( )＜＜Fun．．：i； D．cout＜＜fun2．value( )＜＜Fun：：i＜＜fun1．value( )；

正确答案：A

解析：此题考查的是常成员函数。const关键字可以用于参与重载函数的区分，此时常对象调用常成员函数，一般对象调用一般成员函数，当类中只有一个常成员函数时，一般对象也可以调用该常成员函数。本题中，通过fun1调用value( )函数时，是调用前一个，而通过fun2调用value( )函数是调用后一个；另外，value( )函数中访问的i是类中定义的数据成员i，全局变量i在类中被“屏蔽”。fun1．value( )输出i-1=2-1=1；fun2．value( )调用后一个value( )函数输出i+1=2+1=3；Fun：：i是通过类名直接访问类的静态数据成员i的值，即2；所以正确的输出顺序是A选项。 知识模块：类和对象

13． 有如下程序： #include＜iostream＞ using namespace std； class VAC{ public； int f( ) const{return 3；} int f( ) {return 5；} }； Int main( ){ VAC v1； const VAC v2； cout＜＜v1．f( )＜＜v2．f( )； fetum 0； } 运行时的输出结果是( )。

A．53 B．35 C．55 D．33

正确答案：A

解析：此题考查的是常成员函数的应用。VAC类中说明了两个函数，一个是常成员函数，一个是普通函数；在主函数中说明了两个对象，通过普通对象v1调用的是普通函数，输出5：通过常对象V2调用的是常成员函数，输出3。 知识模块：类和对象

14． 有如下程序： #include＜iostream＞ using namespace std； class MyClass{ public： MyClass(int x)：Val(x){} void Set(int x){val=x；} void Print( )const{cout＜＜’’val=‘‘＜＜val＜＜’＼t’；} private： int val； }； int main( ){ const MyClass obj 1(10)； MyClass obj2(20)； obj1．Print( )； ／／语句1 obj2．Print( )； ／／语句2 obj1．Set(20)；／／语句3 obj2．Set(30)；／／语句4 return 0； } 其主函数中错误的语句是( )。

A．语句1 B．语句2 C．语句3 D．语句4

正确答案：C

解析：在创建类对象obj1(10)时，前面有关键字const，所以当语句3调用obj1的成员函数试图修改其私有成员的数值的时候，会编译出错。 知识模块：类和对象

15． 有如下类定义和变量定义： clasS A{ public：

A( ){data=0；} ～A( ) {} int GetData( ) const{return data；} void SetData(int n) {data=n； } priyate： int data； }； const A a； A b； 下列函数调用中错误的是( )。

A．a．GetData( )； B．a．SetData(10)； C．b．GetData( )； D．b．SetData(10)；

正确答案：B

解析：由题意可知a为常对象，因为常对象不能被更新，所以通过这个常对象只能调用它的常成员函数GetData( )，而不能调用其他成员函数SetData(10)，因而选项B为本题的正确答案。 知识模块：类和对象

16． 有如下程序： #include＜iostream＞ Using namespace std； class A{ public： A(int i)： r1(i){} vgid print( ) {cout＜＜’E’＜＜r1＜＜’-’；} void print( ) const {cout＜＜’C’＜＜r1*r1＜＜’-’；} private： int r1； }； int main( ){ A a1(2)； const A．a2(4)； a1．print( )； a2．print( )； return 0； } 运行时的输出结果是( )。

A．运行时出错 B．E2-C16- C．C4-C16- D．E2-E4-

正确答案：B

解析：类A包括一个整型数据成员r1，一个一般成员函数print( )，一个常成员函数print( )const。在主函数中定义了对象a1，并对r1的值赋2和常对象a2，并对r1的值赋4，在C++中，常对象不能被更新，所以常对象只能调用类的常成员函数，而不能调用一般成员函数。而一般的对象，既可以调用一般成员函数也可以调用常成员函数。所以在本题中，当执行a1．print( )时，输出为E2-，执行a2．print( )时，输出为c16-。 知识模块：类和对象

17． 有如下程序： #include＜iostream＞ using namespace std； class A{ public： A(int i=0)：r1(i){} void print( ){cout＜＜’E’＜＜r1＜＜’-’；} void print( )const{cout＜＜’C’＜＜r1*r1＜＜’-’；} void print(int x){cout＜＜’p’＜＜r1*r1*r1＜＜’-’；} private： int r1； }； mt main( ){ A a1； const A a2(4)； a1．print(2)； a2．print( )； return 0； } 运行时的输出结果是( )。

A．P8-E4 B．P8-C16- C．P0-E4- D．P0-C16-

正确答案：D

解析：在主函数中创建a1对象时，调用类A的默认构造函数，其数据成员r1的值等于0。当执行a1．print(2)语句时，调用带参数的print成员函数，所以输出结果为p0-对象a2为常成员，所以其成员变量r1的值等于4，因为常对象只能调用常成员函数，所以当执行语句a2．print( )语句时，输出结果为C14．。 知识模块：类和对象

18． 某类中有一个无参且无返回值的常成员函数Show，则正确的Show函数原型是( )。

A．const void Show( )； B．void const Show( )； C．void Show( )const； D．void Show(const)；

正确答案：C

解析：常成员函数的说明格式如下：＜返回类型＞＜成员函数名＞(＜参数表＞)const；，所以对于本题来说无参且无返回值的常成员函数show，其正确的函数原型是选项C。 知识模块：类和对象

19． 已知类IMS中两个成员函数的声明为“void listen( )const；”与“void speak( )；”，另有两个对象的定义为“IMS obj1；”与“const IMS obj2；”，则下列语句中，产生编译错误的是( )。

A．obj1．listen( )； B．obj1．speak( )； C．obj2．listenO； D．obj2．speak( )；

正确答案：D

解析：函数listen( )作为类IMS的常成员函数，一般对象obj1和常对象obj2都可以调用它，而函数speak( )作为IMS的一般成员函数，则只有一般对象obj1可以调用，而常对象obi2调用会产生编译错误。 知识模块：类和对象

20． 已知函数print( )没有返回值，如果在类中将之声明为常成员函数，正确的是( )。

A．voidprint( )const； B．constvoidprint( )； C．void const print( )； D．void print(const)；

正确答案：A

解析：const成员函数表示该成员函数只能读类数据成员，而不能修改类成员数据。定义const成员函数时，把const关键字放在函数的参数表和函数体之间。 知识模块：类和对象

21． 有如下类定义： class Test { char a；const char b； public：

Test(char c){a=c；b=c；} ／／第1行 void f(char a)const{this-＞a=a；} ／／第2行 void g(char b){this-＞b=b；} ／／第3行 char h( ) const{return a；} ／／第4行 }； 编译时没有错误的行是( )。

A．第1行 B．第2行 C．第3行 D．第4行

正确答案：D

解析：类Test中的常成员函数h( )返回数据成员a的值。 知识模块：类和对象

22． 有如下类定义： class AA { int a； public； int getRef( )const{return&a；} ／／① int getValue( )const{return a；} ／／② void set(int n)const{a=n；} ／／③ friend void show(AA aa)const{cout＜＜a；} ／／④ }； 其中的四个函数定义中正确的是( )。

A．① B．② C．③ D．④

正确答案：B

解析：此题考查了常成员函数和友元函数的概念。选项A中，getRef( )函数的返回值和函数函数类型不符，故错误；C选项中set( )常成员函数改变了数据成员的值，这是不允许的：D选项中show( )函数被同时定义成友元函数和常成员函数是错误的。 知识模块：类和对象

23． 有如下程序： #include＜iostream＞ using namespace std； class Sample { friend long fun(Sample s)； public： Sample(long a){x=a；} private： long x； }； long fun(Sample s) { if(s．x＜2) return 1： return s．x*fun(Sample(s．x-1))： } int main( ) { int sum=0； for(int i=0；i＜6；i++){sum+=fun(Sample(i))；} cout＜＜sum； return 0； } 运行时输出的结果是( )。

A．120 B．16 C．154 D．34

正确答案：C

解析：此题考查的是友元函数和递归函数。因为fun函数是Sample类的友元函数，所以fun函数可以直接访问Sample类对象的私有成员x。主函数调用fun函数，构造参数为0～5。当n小于2时，fun函数返回1，其余返回值为n*fun(n-1)。n取0～5的值时fun(n)依次为1，1，2，6，24，120，累加结果为

154。 知识模块：类和对象

24． 有如下程序： #include＜iostream＞ #include＜cmath＞ using std：：cout； class Point{ public： Mend double distance(const Point&p)； ／／p距原点的距离 Point(int xx=0，int yy=0)：x(xx)，y(yy){} ／／① private： int x，y； }； double distance(const Point&p){ ／／② return sqrt(p．x*p．x+p．y*p．y)； } int main( ){ Point p1(3，4)； cout＜＜distance(p1)；／／③ return 0； } 下列叙述中正确的是( )。

A．程序编译正确

B．程序编译时语句①出错 C．程序编译时语句②出错 D．程序编译时语句③出错

正确答案：A

解析：这段程序是正确的，计算p距离原点的距离。语句①是类Point的构造函数，在构造函数中给变量xx和yy赋初值0。语句②是计算点p距原点的距离的函数distance。语句③是计算点p1距离原点的距离并输出。 知识模块：类和对象

25． 有如下程序： #include＜iostream＞ using namespace std； class Boat； class Car{ public： Car(int i)：weight(i){} Mend int Total(const Car&c，const Boat&b)；／／① private： int weight； }； class Boat{ public： Boat(int i)：weight(i){} Mend int Total(const Car&c，const Boat&b)；private： int weight； }； int Total(const Car&c，const Boat＆b){ ／／② return c．weight+b．weight； } int main( ){ Car c(10)； Boat b(8)； cout＜＜’’The total weight is’’＜＜Total(c，b)＜＜endl；／／③ return 0； }下列关于程序的描述中，正确的是( )。

A．程序编译正确

B．程序编译时语句①出错 C．程序编译时语句②出错 D．程序编译时语句③出错

正确答案：A 解析：程序中定义了类Car和类Boat，在两个类中分别定义他们的构造函数和友元函数friend。程序在VC6．0中编译通过。 知识模块：类和对象

26． 已知类MyClass声明如下： class MyClass{ int n； public： MyClass(int k)：n(k){} int getValueoconst{ return n； } }； 在下列数组定义中正确的是( )。

A．MyClass x1[2]；

B．MyClass x2[2]={new MyClass(1)，new MyClass(2)}； C．MyClass*x3[2]；

D．MyClass*x4[2]={MyClass(1)，MyClass(2)}；

正确答案：C

解析：考查韵是对象数组。选项A中在建立对象数组时也同样需要调用构造函数：选项B和D的类型不匹配，B中不能将指针传给非指针，D中是将非指针传给指针。 知识模块：类和对象

27． 已知类Myclass的定义如下： class MyClass{ public： MyClass(int d){data=d；} ～MyClass ( ) {} private： int data； }； 下列对Myclass类对象数组的定义和初始化语句中，正确的是( )。

A．MyClass arrays[2]；

B．MyClass arrays[2]={MyClass(5)}；

C．MyClass arrays[2]={MyClass(5)，MyClass(6)}； D．MyClass * arrays=new MyClass[2]；

正确答案：C 解析：在选项C中定义了类MyClass对象数组arrays[2]，并用对象MyClass(5)和MyClass(6)对这个数组中的两个元素赋初值。 知识模块：类和对象