C++试题B.docx

C++试题B.docx

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

C++试题B

一、选择题（15×1分＝15分）

1、关于继承和封装说法正确的是（） 。

A）封装就是完全封闭，外部只能通过接口实现互连

B）继承是封装的基础

C）封装是继承的基础

D）子类可只继承父类的部分可继承行为和属性，也可全部继承，就像儿子可继承父亲的部分性格一样

2、关于结构体、共用体及类的说法正确的是（） 。

A）结构体、共用体没有什么不同，都是把不同或相同类型的数据组织为一体

B）一般来说，结构体、共用体只有数据成员，没有成员函数

C）结构体、共用体与类相比，都含有数据成员的成员函数，只是前者是专为面向过程的程序设计的，后者为面向对象的程序设计的

D）类可只含数据成员或成员函数，不影响使用

3、假设person是一个类，p1是该类的一个对象，p2是一个指向p1的指针，getname（）是其中的一个函数，则下面对象的使用不正确的是（） 。

A）person.getname（）B）p1.getname（）C）p1.person:

:

getname（）D）p2->getname（）

4、关于构造函数的说法，正确的是（） 。

A）构造函数用于代替类中的一个成员函数来在创建对象时给对象赋初值（通常是成员变量），它是由人工设计的，因此可以在任何时候、任何地方来调用它

B）构造函数的名字与类名相同，因此同类的不同对象的构造函数是相同的

C）构造函数的参数多少没有定制，它的返回值的类型为vois型

D）构造函数的名字与类名相同，因此一个类只有一个构造函数，即构造函数不可重载

5、关于析构函数的说法，正确的是（） 。

A）析构函数用来释放构造函数为对象分配的内存空间。

它可以被用户调用，也可以被系统调用

B）析构函数没有数据类型，其返回值为隐含型

C）析构函数可以没有参数，也可以有多个参数

D）析构函数与构造函数不一样，它可以有多个，以方便使用

6、关于成员函数的重载，说法正确的是（） 。

A）就是在类中设计多个函数名相同，参数个数及类型也相同的函数

B）析构函数可以重载

C）函数重载，要求函数名相同，但参数个数不同或参数个数相同但其类型不同

D）构造函数不可重载

7、假设person是一个类，p、q是它的不同对象，有函数personf（person&x），下列过程中没有调用拷贝构造函数的是（） 。

A）personp（q）；B）personp＝q；C）q＝f（p）；D）personp（10）

8、关于友元函数的说法正确的是（） 。

A）友元函数可以是任何类中的一个函数

B）如果函数在被说明为友元函数的类中定义，则它就是该类的成员函数

C）不属于任何类的函数不可以被说明为友元函数

D）使用友元函数的主要目的是提高程序执行效率，因为它可以直接调用该类的私有变量。

9、关于静态数据成员的说法正确的是（） 。

A）静态数据成员虽然能实现同类的对象共享数据，但破坏了类的封装性

B）静态数据成员是所有同类对象共享的数据，它不能具体地属于哪一个对象

C）静态数据成员只在类中说明一次即可

D）若C为一个类，a为它的一个对象

10、关于继承的目的和作用，说法不正确的是（） 。

A）继承是为了重复利用父类的可用代码，避免重复劳动

B）继承可以增加自己的父类不能实现的功能的代码，使子类的功能更完美，提高程序设计效率

C）子类可以继承父类的函数和数据，以便重复使用

D）子类可以继承父类的所有特性，以便重复使用，这才是继承的目的

11、下列try、catch语句块说法不正确的是（） 。

A）try语句块出现之前不允许出现catch语句块

B）catch语句块只能跟在try语句块之后，它们之间可以有其他语句

C）try语句块之后可以紧跟多跟catch语句块

D）catch必须有参数

5、假定AB为一个类，则执行“AB a（4）,b[3],*p[2];”语句时，自动调用该类构造函数的次数为（） 。

A.3             B.4              C.6              D.9

12、假定要对类AB定义加号操作符重载成员函数，实现两个AB类对象的加法，并返回相加结果，则该成员函数的声明语句为：

（） 。

A. AB operator+（AB &a,AB &b）      B. AB operator+（AB &a）

C. operator+（AB a）                      D. AB &operator+（）

13、如果要对AB类中的整型静态变量c赋初值0，则书写语句正确的是（） 。

A）intc=0;B）staticintc=0;C）intAB:

:

c=0;D）staticintAB:

:

c=0;

14、在进行完任何C++流的操作后，都可以用C++流的有关成员函数检测流的状态；其中只能用于检测输入流状态的操作函数名称是（） 。

A）fail B）eof C）bad D）good  

二、判断题（10×1分＝10分）

1.为了避免派生类catch不能捕获异常，基类catch总是放在派生类catch后。

2.同一类的不同对象占有不同的内存空间。

3.当内联函数被调用时，内联函数的代码在调用处被展开。

4.数据只有在流中从可以被操作。

5.把流分为输入流和输出流是相对文件流的，输出流是数据从文件流向流中，输入流是数据从流中流向内存变量。

6.函数的返回值类型在区别重载函数时起着举足轻重的作用。

7.多重继承往往产生二义性问题，可用成员名限定法来消除。

8.基类构造函数的调用顺序是按基类被继承时声明的顺序从右至左调用。

9.已知：

doublek=10;可以用double&p=10;表示引用。

10.virtual只用来说明类声明中的原型，不能用在函数实现时。

三、程序填空题（10×2分＝20分）

1、下面程序的功能是输出将1元人民币换成1分、2分、5分的所有方案，请填空。

#include

（1）

voidmain（）

｛inti,j,k,s=0;

for（i=0;i<=20;i++）

for（j=0;j<=50;j++）

{

（2）；

if（k>=0）

{cout<

}

cout<<”共有方案”<

｝

2、

#include

classComplex

{

public:

Complex（（3））//默认为纯虚数，即实部为0

｛real=x;image=y;}

（4）//对运算符+进行重载实现复数加法

{Complext;

t.real=（5）；

t.image=（6）；

returnt;

}

voiddisp（）{cout<

private：

doublereal,image ;

};

3、请按下面程序的提示信息将程序填充完整。

#include

classPoint//Point类声明

{public:

Point（intx,inty）{X=x;Y=y;（7）；}

intGetX（）{returnX;}//返回X的值

intGetY（）{returnY;}//返回Y的值

staticvoidGetC（）{cout<<"Objectid="<

private:

intX,Y;

（8）；

};

intPoint:

:

countP=0;//用来统计已生成的Point对象的个数

voidmain（）

{

（9）;//指向函数的指针gc指向类的成员函数GetC

PointA（4,5）;//声明对象A

cout<<"PointA,"<

（10）；//通过函数指针gc调用GetC函数

}

四、读程序写结果（5×5分＝25分）

1、

#include

usingnamespacestd;

classB0

{public:

virtualvoiddisplay（）{cout<<"B0:

:

display（）"<

classB1:

publicB0

{public:

voiddisplay（）{cout<<"B1:

:

display（）"<

classD1:

publicB1

{public:

voiddisplay（）{cout<<"D1:

:

display（）"<

voidmain（）

{B0b0,*p;B1b1;D1d1;

p=&b0;p->display（）;

p=&b1;p->display（）;

p=&d1;p->display（）;

}

2、

#include

classA{

   inta;

public:

   A（intaa=0）{a=aa;}

   ~A（）{cout<<"DestructorA!

"<

};

classB:

publicA{

   intb;

public:

   B（intaa=0,intbb=0）:

A（aa）{b=bb;}

~B（）{cout<<"DestructorB!

"<

};

voidmain（）{   Bx（5）,y（6,7）;}

3、

#include

inta=5;

voidmain（）

{  inta=10,b=20;

   cout<

   {  inta=0,b=0;

for（inti=1;i<6;i++）{    a+=i;b+=a;   }

        cout<

:

a<

   }

   cout<

}

4、

#include

classB1

{public:

B1（inti）{cout<<"constructingB1"<

~B1（）{cout<<"destructingB1"<

};

classB2

{public:

B2（intj）{cout<<"constructingB2"<

~B2（）{cout<<"destructingB2"<

};

classB3

{public:

B3（）{cout<<"constructingB3*"<

~B3（）{cout<<"destructingB3"<

};

classC:

publicB2,publicB1,publicB3

{public:

C（inta,intb,intc,intd）:

B1（a）,memberB2（d）,memberB1（c）,B2（b）{}

private:

B1memberB1;

B2memberB2;

B3memberB3;

};

voidmain（）

{Cobj（1,2,3,4）;}

5、

#include

voidmain（）

{

try{inta=8;doubleb=8.8;throwa

a:

b;}

catch（intx）{cout<<”theintvalue“<

catch（doubley）{cout<<”thedoublevalue“<

}

五、程序设计（第一题8分，第二题10分，第三题12分）

1、编写一个程序，至少设计一个点类Point，求两个点之间的距离。

2、下面为单链表的结点类模板，各成员数据以及成员函数的意义在后面进行了描述，请将其4个成员函数的实现代码补充完整。

template

classNode

{

private:

Node*next;//指向后继结点的指针

public:

Tdata;//数据域

Node（constT&item,Node*ptrnext=NULL）;//构造函数

voidInsertAfter（Node*p）;//在本结点之后插入一个同类结点p

Node*DeleteAfter（void）;//删除本结点的后继结点，并返回其地址

Node*NextNode（void）const;//获取后继结点的地址

};

3、设计一个倒计时的时钟类，该类包括days，hours，minutes，seconds四个成员数据，分别表示倒计时的天数、小时数、分钟数和秒数，成员函数包括构造函数、显示四个成员数据值的函数和后置――运算符的重载函数，要求倒计时的最短时间为10天9小时8分7秒。

参考答案

一、选择题（15×1分＝15分）

（1）C

（2）B（3）A（4）B（5）A

（6）C（7）D（8）D（9）B（10）D

（11）B（12）C（13）B（14）D（15）B

二、判断题（10×1分＝10分）

（1）√

（2）×（3）√（4）√（5）×

（6）×（7）√（8）×（9）×（10）√

三、程序填空题（10×2分＝20分）

（1）#include

（2）k=100-5*i-2*j;

（3）doublex=0,doubley=0

（4）Complexoperator+（Complex&y）

（5）real+y.real

（6）image+y.image

（7）countP++;

（8）staticintcountP;

（9）void（*gc）（）=Point:

:

GetC

（10）gc（）

四、读程序写结果（5×5分＝25分）

1、

B0:

:

display（）

B1:

:

display（）

D1:

:

display（）

2、

Destructor B!

 7

Destructor A!

 6

Destructor B!

 0

Destructor A!

 5

3、

10 20

15 35 5

10 20

4、

constructingB22

constructingB11

constructingB3*

constructingB13

constructingB24

constructingB3*

destructingB3

destructingB2

destructingB1

destructingB3

destructingB1

destructingB2

5、

thedoublevalue8wasthrown

五、程序设计（第一题8分，第二题10分，第三题12分）

1、

#include

#include

classPoint

{doublex,y;

public:

Point（doublei,doublej）{x=i;y=j;}

doublegetx（）{returnx;}

doublegety（）{returny;}

voiddisp（）{cout<<"（"<

};

doubledistance（pointpx，pointpy）

{doubled，dx，dy;

dx=px.getx（）-py.getx（）;

dy=px.gety（）-py.gety（）;

d=sqrt（dx*dx+dy*dy）;

returnd;

}

voidmain（）

{pointp1（2,2）,p2（5,5）;

p1.disp（）;cout<<"与";p2.disp（）;

cout<<"之间距离="<

}

2、

template

Node:

:

Node（constT&item,Node*ptrnext）:

data（item）,next（ptrnext）

{}

//返回后继结点的指针

template

Node*Node:

:

NextNode（void）const

{returnnext;}

//在当前结点之后插入一个结点p

template

voidNode:

:

InsertAfter（Node*p）

{

p->next=next;//p结点指针域指向当前结点的后继结点

next=p;//当前结点的指针域指向p

}

//删除当前结点的后继结点，并返回其地址

template

Node*Node:

:

DeleteAfter（void）

{

Node*tempPtr=next;//将欲删除的结点地址存储到tempPtr中

if（next==NULL）//如果当前结点没有后继结点，则返回NULL

returnNULL;

next=tempPtr->next;//使当前结点的指针域指向tempPtr的后继结点

returntempPtr;//返回被删除的结点的地址

}

3、

classClock

{

public:

Clock（intd=10,inth=9,intm=8,ints=7）;

Clockoperator++（int）;

voiddisp（）;

private：

intdays,hours,minutes,seconds ;

};

Clock:

:

Clock（intd,inth,intm,ints）

{

intt;

t=s+100*m+h*10000+d*1000000;

if（t<10090807）{cout<<”Error”;exit

（1）;}

days=d;hours=h;minutes=m;seconds=s;

}

ClockClock:

:

operator--（int）

{

}

voidClock:

:

disp（）

{cout<