C++试题及答案.docx

C++试题及答案.docx

《C++试题及答案.docx》由会员分享，可在线阅读，更多相关《C++试题及答案.docx（15页珍藏版）》请在冰豆网上搜索。

C++试题及答案

一、（共10分，每题1分）单项选择

1.对于全局函数intf（void），与其完全等价的函数原型为：

[c]

A.int&f（）;B.intf（void）const;C.constintf（）;D.A、B、C都不是

2.类A中有唯一的非静态成员函数intf（A&one）和私有的数据成员intx;,那么在此成员函数的函数体中可以有语句：

[d]

A.return（this）;B.x=f（this）;C.this->f;D.int*constpX=&;

3.下面关于new和delete操作符的说法，哪个是不正确的：

[d]

A.使用new操作符，可以动态分配全局堆中的内存资源。

B.若p的类型已由A*强制转换为void*，那么执行语句deletep；时，类A的析构函数不会被调用。

C.实现全局函数时，new和delete通常成对地出现在由一对匹配的花括号限定的语句块中。

D.执行语句A*p=newA[100];时，类A的构造函数只会被调用1次。

4.类TM和类TN是两个独立的类，那么类TM中哪种形式的数据成员一定是不允许的：

[c]

A.TM*a;B.TN&a;C.TMa;D.TNa;

5.类B是通过public继承方式从类A派生而来的，且类A和类B都有完整的实现代码，那么下列说法正确的是:

A.类B中具有pubic可访问性的成员函数个数一定不少于类A中public成员函数的个数。

B.一个类B的实例对象占用的内存空间一定不少于一个类A的实例对象占用的内存空间。

C.只要类B中的构造函数都是public的，在main函数中就可以创建类B的实例对象。

D.类A和类B中的同名虚函数的返回值类型必须完全一致。

6.下列哪种函数可以是虚的：

[d]

A.自定义的构造函数B.拷贝构造函数C.静态成员函数D.析构函数

7.类A有一个实例化的常量对象a，那么下面的说法中不正确的是：

A.类A中的非静态数据成员一定都是常量成员。

B.通过a可以直接调用类A的常量成员函数。

C.a不能直接作为左值表达式使用。

D.a可以是静态常量对象。

8.在不考虑强制类型转换的情况下，关于类中常量成员函数的下列说法不正确的是：

A.常量成员函数中不能修改本类中的非静态数据成员。

B.常量成员函数中可以调用本类中的任何静态成员函数。

C.常量成员函数的返回值只能是void或常量。

D.若常量成员函数中调用虚函数f，那么函数f在本类中也一定是一个常量成员函数。

9.类C是以多重继承的方式从类A和类B继承而来的，类A和类B无公共的基类，那么：

A.类C的继承方式只能采用public继承。

B.可改用单继承的方式实现类C的同样功能。

C.类A和类B至少有一个是抽象类。

D.类A和类B至少有一个是虚基类。

10.下列哪种用法不能体现类A和类B之间的组合关系：

A.类A中声明数据成员Bb;

B.类A中声明数据成员B*b;

C.类A中声明数据成员constB&b;

D.类A中声明成员函数Bfunc（B&obj）;

二、（共10分，每题2分，多选、少选、错选都不得分）多项选择

1.下面关于指针变量和引用变量的说法正确的是:

A.指针变量存放的是内存地址，并且可以置为0。

B.定义引用变量时，必须同时指明具体被引用的对象或变量。

C.使用取地址操作符，可以取得指针变量自身的地址，但取不到引用变量自身的地址。

D.类中的数据成员可以是指针变量，但不能是引用变量。

2.类A中有唯一的一个公有成员函数f，对于类A的一个对象a,执行语句（100）;成功，那么f的函数原型可以为：

A.A&f（int,int=50）;f（int&）const;A*f（constint）;D.Af（constint&）const;

3.关于类中重载赋值运算符的正确说法是：

A.由编译器提供的缺省赋值函数具有public访问性并且执行按位赋值。

B.在重载派生类的赋值操作时，不但要实现派生类中数据成员的赋值，还要负责基类中数据成员的赋值。

C.只有在类中含有指针数据成员或引用数据成员时，才需要重载类的赋值操作。

D.通过修改类A的声明或定义，可以禁止用户在类A对象间进行任何赋值操作。

4.在类的静态成员函数的实现体中，可以访问或调用：

A.本类中的静态数据成员B.本类中非静态的常量数据成员

C.本类中其它的静态成员函数D.本类中非静态的成员函数

5.关于异常和C++提供的异常处理机制正确的说法是：

A.若程序员预见到程序中的异常，则一定可以通过修改程序代码来避免异常出现。

B.使用dynamic_cast操作符可能会产生异常。

C.异常可以用catch进行捕获处理。

D.异常可以是对象，也可以是普通整数。

三、（共20分，每题2分）判断正误，对于你认为错误的论述，说明原因或举出反例。

1.函数体内声明的静态变量，至多只会被初始化一次。

2.对于同一个类中的两个非静态成员函数，它们的函数的名称、参数类型、参数个数、参数顺序以及返回值的类型不能完全相同。

3.inline函数表示编译器一定会将函数体直接插入到调用此函数的地方，这样可以加快程序的运行速度。

4.每个cpp文件是单独编译的，但一个程序中多个cpp文件的编译顺序是不固定的。

5.将类A所有构造函数的可访问性都限制为私有的，那么在main函数中不可能得到类A的实例对象。

6.名字空间是可以多层嵌套的；对于类A中的函数成员和数据成员，它们都属于类名A代表的一层名字空间。

7.若在类Base和派生类Derived中，分别声明一个同名的整型成员变量intx;,那么通过Derived类的实例对象，不可能输出基类Base中的变量x的值。

8.若类A是类B的友员类，且类B是类C的友员类，那么类A也是类C的友员类。

9.虽然抽象类的析构函数可以是纯虚函数，但要实例化其派生类对象，仍必须提供抽象基类中析构函数的函数体。

10.构造函数的初始化列表中的内容，不会影响构造对象中成员数据的初始化顺序。

四、（5分）写出下面程序的运行结果

#include<>

classA{

public:

A（intv1）

（v1）{f（）;}

virtual~A（）{f（）;}

virtualvoidf（）{++count;x+=10;Show（）;}

virtualvoidShow（）const

{cout<<"count="<

protected:

staticintcount;

private:

intx;

};

classB:

publicA{

public:

B（intv1,intv2）:

A（v1）,y（v2）{f（）;}

virtual~B（）{f（）;}

virtualvoidf（）{++count;y+=50;Show（）;}

virtualvoidShow（）const

{cout<<"count="<

private:

inty;

};

intA:

:

count=0;

intmain（）

{A*p=newB（1,2）;

p->f（）;

deletep;

return0;

}

五、（5分）写出下面程序的运行结果

#include<>

classA{

private:

friendclassB;

A（intval=0）:

data（val）,use

（1）{}

intuse,data;

};

classB{

public:

B（intval=0）:

pa（newA（val））{}

~B（）{if（--pa->use==0）deletepa;}

B（constB&rhs）{++rhs->use;pa=;}

B&operator=（constB&rhs）;

A*operator->（）const{returnpa;}

voidDisplay（）const{cout<<"data="<data

<<"use="<use<

private:

A*pa;

};

B&B:

:

operator=（constB&rhs）

{

if（this==&rhs）return*this;

if（--pa->use==0）deletepa;

++rhs->use;

pa=;

return*this;

}

intmain（）{

Bb1

（1）,b2（b1）,b3（3）;

（）;

（）;

（）;

b3=b1;

（）;

（）;

return0;

}

六、（共20分）回答下列各题

1.说明类中的public、protected和private成员函数分别在public、protected和private继承方式下在派生类中的可访问性。

（4分）

2.若类A和类B没有继承关系，对于函数voidfunc（A&）,请至少用两种不同方法说明如何才能传递一个非常量的B类对象给func函数。

（4分）

3.在声明类中的构造函数、析构函数、纯虚函数、静态成员函数、非静态的成员函数以及全局函数作为类的友元函数时，哪些可以是常量成员函数（3分）

4.举例说明重载（overload）、重定义（redefine）和重写（override）的含义。

（3分）

5.通常类A的拷贝构造函数的原型写为A（constA&）;，请问为什么参数一定要使用引用形式使用const修饰符除了可以防止修改传递给构造函数的实参外，还有什么作用（3分）

6.程序员规范中要求不要写出类似（++i）+（i++）或f（++i,i++）这样的代码，请说明原因。

（3分）

七、（共8分）阅读下面部分程序代码，完成3个问题。

#include<>

classA{

public:

A（intv1）

（v1）{}

virtualintGetData（）const{returnx;}

private:

intx;

};

classB:

publicA{

public:

B（intv1,intv2）:

A（v1）,y（v2）{}

virtualintGetData（）const{returny;}

private:

inty;

};

classC:

publicB{

public:

C（intv1,intv2,intv3）:

B（v1,v2）,z（v3）{}

virtualintGetData（）const{returnz;}

private:

intz;

};

constA&max2（constA&one,constA&two）

{return（one>twoone:

two）;}

voidmain（）{

Bb（1,2）;Cc（100,10,1）;

cout<

cout<

}

1）（4分）请在不改变上述已有代码的条件下，添加必要的函数使得程序可以编译通过和运行，并输出结果2和5。

其中比较对象时只比较各自的或在派生类定义的数据成员，如比较类B的对象b和类C的对象c时，实际比较的是和。

2）（2分）若不改变函数max2的函数体，只将函数声明改成A&max2（constA&one,constA&two）,请问这样行吗为什么

3）（2分）若main中有语句A*p=newC（1,2,3）;和deletep;,那么类A、类B和类C应做何修改

八、（共10分）现考虑编写一个扑克游戏：

只用一付无大小王的扑克，扑克的花色（suit）分为Spade、Heart、Diamond和Club，每门花色的牌共13张，面值（rank）分别为2、3、4、5、6、7、8、9、10、Jack、Queen、King和Ace，每张扑克牌应包含如下信息：

唯一的ID号（1-52）、花色、面值、背面图案的编号等。

每张扑克牌的操作有：

判断两张扑克牌是相同花色吗相同面值吗判断一张扑克牌是给定的花色吗是给定的面值吗请写出扑克牌类Card类的声明和实现代码，要求选取适当形式的数据成员描述每张扑克牌的信息，同时以成员函数的形式实现指定的操作。

九、（共12分）现有一个2x2的矩阵，其第一行元素从左到右依次为a1和a2，第二行元素从左到右依次为a3和a4，简记此矩阵为M（a1,a2,a3,a4）。

对矩阵M可进行两种操作：

一种是转置，即交换a2和a3的位置；另一种是变换，即将矩阵M（a1,a2,a3,a4）变换为M（b1,b2,b3,b4）,其中bi是变换ai后的结果。

假定已有全局函数intGetNextPrime（intdata）;它返回比data大的最小素数，若返回值越界则返回2。

不用考虑模板，请按下列具体要求实现代码。

1）（6分）若ai都是整数，每次变换都将ai变换成比ai大的最小素数（i=1,2,3,4）。

请用类M描述满足上述条件的矩阵,要求给出类M的声明和实现代码，同时写出main函数，并在其中创建一个M（1,10,100,1000）矩阵。

2）（6分）若矩阵中元素a2和a3既可以是整数，也可以是另一个满足此定义的矩阵，例如：

矩阵M（1,M（2,3,M（4,5,6,7）,

9,10）。

矩阵转置时，既要交换a2和a3的位置，还要对a2和a3中的矩阵进行转置；矩阵变换时，同样也要对其中的矩阵元素进行变换。

请给出满足此要求的矩阵类M的声明和实现代码。

一、单选

二、多选

1.ABC

2.ACD

3.ABD

4.AC

5.BCD

三、判断对错

1.对

2.错如可有两个成员函数,intf（）;和intf（）const;

3.错是否真正内联，由编译器决定。

如函数是递归函数，那么永远不会内联。

4.对

5.错可通过类的静态成员函数创建实例，如单件模式。

6.对

7.错如可通过继承自基类的成员函数访问基类中的x.

8.错友员关系不具有传递性。

9.对

10.对

四、写结果。

目的是考察虚函数的调用，包括普通成员函数中调用其它虚函数和

在构造、析构函数中只会调用虚函数的本地版本。

五、写结果。

是一个使用Handle类进行引用计数的例子。

六、回答问题

1.重点是基类中的任何Private在派生类中都是不可访问的。

2.可在A类中定义一个构造函数：

A（constB&）;

或在B类中定义一个自动转换函数：

operatorA（）const;

3.只有纯虚函数、非静态的成员函数可以是常量成员函数。

（这题有点问题，析构函数可以是纯虚函数，但不能是常量函数）

4.如类A中有函数intf（void）;和intf（int）;为重载（overload）（同名，参数不同）

如类A中有函数intf（void）;，A的派生类B中给intf（void）一个新的实现体，为redefine

如类A中有虚函数virtualintf（void）;,A的派生类B中给virtualintf（void）一个新的实现体,

为override.

5.A（constA&one）.当调用此拷贝构造函数时，需将参数压栈，若不使用&，就需要在

栈内创建一个one的副本，而这需要用拷贝构造函数。

这样就会形成递归调用。

使用const,还允许用一个常量对象作为样本，来构造一个新的对象。

6.计算子表达式的顺序由编译器决定的，虽然参数的压栈顺序在给定的调用方式下式固定的，

但参数表达式的计算顺序也由编译器决定的。

不同的编译器或不同的表达式计算的顺序可能

不一致。

七.

1.添加全局函数

booloperator>（constA&one,constA&two）

{

return（）>（）;

}

2.不行。

return（one>twoone:

two）;时，不能将常量赋给变量。

3.需要将ABC三个类的析构函数改为虚的。

八.Card类（不用enum，只用数字也可以）

main函数略

中。

constenumSUIT{SPADE=0,HEART,DIAMOND,CLUB};

constenumRANK{TWO=0,THREE,FOUR,FIVE,SIX,SEVEN,EIGHT,NINE,TEN,JACK,QUEEN,KING,ACE};

classCard

{

public:

Card（intid）:

mID（id）,mSuit（（id-1）/13）,mRank（（id-1）%13）{}

boolIsSameSuit（constCard&rhs）

{return（（this==&rhs）false:

mSuit==;}

boolIsSameRank（constCard&rhs）

{return（（this==&rhs）false:

mRank==;}

boolIsSuit（intsuit）

{returnmSuit==suit;}

boolIsRank（intrank）

{returnmRank==rank;}

private:

staticintnBackImg;

1）classM

{

public:

M（intv1,intv2,intv3,intv4）:

a1（v1）,a2（v2）,a3（v3）,a4（c4）{}

voidTurn（）{inttemp=a2;a2=a3;a3=temp;}

voidTrans（）{

a1=GetNextPrime（a1）;

a2=GetNextPrime（a2）;

a3=GetNextPrime（a3）;

a4=GetNextPrime（a4）;

}

private:

inta1,a2,a3,a4;

};

2）（因没有讲授设计模式部分，可以采用变通的方法,例如）

classM

{

public:

M（intv1,intv2,intv3,intv4）

:

a1（v1）,a2（v2）,a3（v3）,a4（v4）,p2（0）,p3（0）{}

M（intv1,intv2,M*pt3,intv4）

:

a1（v1）,a2（v2）,a3（0）,a4（v4）,p2（0）,p3（pt3）{}

M（intv1,M*pt2,intv3,intv4）

:

a1（v1）,a2（0）,a3（v3）,a4（v4）,p2（pt2）,p3（0）{}

M（intv1,M*pt2,M*pt3,intv4）

:

a1（v1）,a2（0）,a3（0）,a4（v4）,p2（pt2）,p3（pt3）{}

voidTurn（）

{

inttemp=a2;a2=a3;a3=temp;

M*p=p2;p2=p3;p3=p;

if（p2）p2->Turn（）;

if（p3）p3->Turn（）;

}

voidTrans（）{

a1=GetNextPrime（a1）;

if（p2）

p2->Trans（）;

else

a2=GetNextPrime（a2）;

if（p3）

p3->Trans（）;

else

a3=GetNextPrime（a3）;

a4=GetNextPrime（a4）;

}

private:

inta1,a2,a3,a4;

M*p2;

M*p3;

};