继承和派生习题.docx

继承和派生习题.docx

《继承和派生习题.docx》由会员分享，可在线阅读，更多相关《继承和派生习题.docx（24页珍藏版）》请在冰点文库上搜索。

继承和派生习题

继承和派生习题

一、单选题

1．若类A和类B的定义如下：

classA

{

inti,j;

public:

intgeti（）{returni;}

};

classB:

publicA

{

intk;

public:

voidmake（）{k=i*j;}

};

则上述中，（）是非法的表达式。

A．k=i*jB．intk;C．returni;D．voidmake（）;

2．关于公有继承，下列说法错误的是（）。

A．基类的公有成员和保护成员被继承后作为派生类的公有成员和保护成员。

B．派生类的其他成员可以直接访问基类的公有成员和保护成员。

C．派生类的对象可以访问基类的私有成员。

D．派生类成员和对象都无法访问基类的私有成员。

3．下列说法中错误的是（）。

A．公有继承时基类中的public成员在派生类中仍是public的；

B．公有继承时基类中的private成员在派生类中仍是private的；

C．私有继承时基类中的public成员在派生类中是private的；

D．保护继承时基类中的public成员在派生类中是protected的；

4．在公有继承中，基类中的公有成员作为派生类的（）。

A．公有成员

B．私有成员

C．保护成员

D．私有成员函数

5．基类中的（）不允许外界访问，但允许派生类的成员访问，这样既有一定的隐藏能力，又提供了开放的接口。

A．公有成员

B．私有成员

C．保护成员

D．私有成员函数

6．在下面的表达式中，不表示虚继承的是（）。

A．virtualpublic

B．publicvirtual

C．public

D．virtual

7．设置虚函数的声明中，正确的是（）。

A．简化程序

B．消除二义性

C．提高运行效率

D．减少目标代码

8．下面叙述错误的是（　）。

A．基类的protected成员在派生类中仍然是protected

B．基类的protected成员在public派生类中仍然是protected的

C．基类的protected成员在private派生类中是private的

D．基类的protected成员不能被派生类的对象访问

9．派生类的对象对它的基类成员中（）是可以访问的。

A．公有继承的公有成员

B．公有继承的私有成员

C．公有继承的保护成员

D．私有继承的公有成员

10．下列对派生类的描述中，错误的是（）。

A．一个派生类可以作为另一个派生类的基类

B．派生类至少有一个基类

C．派生类的缺省继承方式是private

D．派生类只含有基类的公有成员和保护成员

11．继承具有（），即当基类本身也是某一个类派生类时，底层的派生类也会自动继承间接基类的成员。

A．规律性

B．传递性

C．重复性

D．多样性

12．设有基类定义：

classCbase

{private:

inta;

protected:

intb;

public:

intc;

};

派生类采用何种继承方式可以使成员变量b成为自己的私有成员（）

A．私有继承

B．保护继承

C．公有继承

D．私有、保护、公有均可

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．派生类的对象对它的基类成员中的（）是可以访问的。

A．公有继承的公有成员

B．公有继承的私有成员

C．公有继承的保护成员

D．私有继承的私有成员

20．下列虚基类的声明中，正确的是（　）。

A．classvirtualB:

publicA

B．virtualclassB:

publicA

C．classB:

publicAvirtual

D．classB:

virtualpublicA

二、填空题

1．在继承机制下，当对象消亡时，编译系统先执行的析构函数，然后才执行

的析构函数，最后执行的析构函数。

2．派生类构造函数的初始化列表中包含。

3．派生类可以定义其中不具备的数据和操作。

4．C++将类继承分为和两种。

三、问答题

写出下列程序运行结果:

1.#include

usingnamespacestd;

classA

{

intx;

public:

intz;

voidsetx（inti）{x=i;}

intgetx（）{returnx;}

};

classB:

publicA

{

intm;

public:

voidsetvalue（inta,intb,intc）

{

setx（c）;

z=b;

m=a;

}

voiddisplay（）

{

cout<

}

};

intmain（）

{

Bobj;

obj.setvalue（2,3,4）;

obj.display（）;

return0;

}

2．写出程序运行结果:

#include

usingnamespacestd;

classbase

{

public:

voidwho（）{cout<<"baseclass"<

};

classderive1:

publicbase

{

public:

voidwho（）{cout<<"derive1class"<

};

classderive2:

publicbase

{

public:

voidwho（）{cout<<"derive2class"<

};

voidmain（）

{

baseobj1;

obj1.who（）;

derive1obj2;

obj2.base:

:

who（）;

derive2obj3;

obj3.base:

:

who（）;

}

3．阅读下列程序，写出程序运行结果。

#include

usingnamespacestd;

classBase

{

intx;

public:

Base（inti）

{

x=i;

cout<<"ConstuctorofBase"<

}

~Base（）{cout<<"DestuctorofBase"<

voidshow（）{cout<<"x="<

};

classDerived:

publicBase

{

Based;

public:

Derived（inti）:

Base（i）,d（i）{cout<<"ConstuctorofDerived"<

~Derived（）{cout<<"DestuctorofDerived"<

};

intmain（）

{

Derivedobj（5）;

obj.show（）;

return0;

}

4．阅读下列程序，写出程序运行结果。

#include

usingnamespacestd;

classPerson

{

public:

Person（）{cout<<"ConstructorofPerson"<

~Person（）{cout<<"DestructorofPerson"<

};

classStudent:

publicPerson

{

public:

Student（）{cout<<"ConstructorofStudent"<

~Student（）{cout<<"DestructorofStudent"<

};

classTeacher:

publicPerson

{

public:

Teacher（）{cout<<"ConstructorofTeacher"<

~Teacher（）{cout<<"DestructorofTeacher"<

};

intmain（）

{

Students;

Teachert;

return0;

}

5．阅读下列程序，写出程序运行结果。

#include

usingnamespacestd;

classdata

{

public:

intx;

data（intn）

{

x=n;

cout<<"data"<

}

~data（）{cout<<"data"<

};

classA

{

datad1;

public:

A（intx）:

d1（x）{cout<<"A"<

voiddispa（）

{

cout<

}

~A（）{cout<<"A"<

};

classB:

publicA

{

datad2;

public:

B（intx）:

A（x-1）,d2（x）{cout<<"B"<

~B（）{cout<<"B"<

voiddispb（）

{

dispa（）;

cout<

}

};

intmain（）

{

Bobj（5）;

obj.dispb（）;

return0;

}

6．阅读下列程序，写出程序运行结果。

#include

usingnamespacestd;

classA

{

protected:

intx,y;

public:

A（）

{

x=3,y=4;

cout<<"A（）Constructor!

"<

}

A（intm,intn）

{

x=m,y=n;

cout<<"A（intm,intn）Constructor!

"<

}

~A（）{cout<<"ADestructor!

"<

};

classB:

publicA

{

protected:

inti,j;

public:

B（inta,intb）:

A（a,b）

{

i=3,j=4;

cout<<"B（inta,intb）Constructor!

"<

}

B（inta,intb,intm,intn）:

A（m,n）

{

i=a,j=b;

cout<<"B（inta,intb,intm,intn）Constructor!

"<

}

~B（）{cout<<"BDestructor!

"<

voidprint（）

{

cout<

}

};

intmain（）

{

Bd（1,2）;

d.print（）;

return0;

}

7．阅读下列程序，写出程序运行结果。

#include

usingnamespacestd;

classA

{

protected:

intx,y;

public:

A（intm=5,intn=6）

{

x=m,y=n;

}

};

classB:

publicA

{

protected:

inti,j;

public:

B（inta,intb）

{

i=a,j=b;

}

B（inta,intb,intm,intn）:

A（m,n）

{

i=a,j=b;

}

voidprint（）

{

cout<

}

};

intmain（）

{

Bd（1,2）;

d.print（）;

Bc（1,2,3,4）;

c.print（）;

return0;

}

8．阅读下列程序，写出程序运行结果。

#include

usingnamespacestd;

classA

{

public:

A（inti,intj）

{

a=i;

b=j;

}

voidmove（intx,inty）

{

a+=x;

b+=y;

}

voidshow（）{cout<

private:

inta,b;

};

classB:

publicA

{

public:

B（inti,intj）:

A（i,j）{}

voidfun（）

{

move（3,5）;

}

};

intmain（）

{

Bd（3,4）;

d.fun（）;

d.show（）;

return0;

}

9．阅读下列程序，写出程序运行结果。

#include

usingnamespacestd;

classBaseClass

{

public:

BaseClass（）{cout<<"BaseClassConstructor!

"<

~BaseClass（）{cout<<"BaseClassDestructor!

"<

};

classDerivedClass:

publicBaseClass

{

public:

DerivedClass（）{cout<<"DerivedClassConstructor!

"<

~DerivedClass（）{cout<<"DerivedClassDestructor!

"<

};

intmain（）

{

DerivedClassd;

return0;

}

10．写出下列程序运行结果:

#include

usingnamespacestd;

classB0

{

public:

voiddisplay（）{cout<<"B0:

:

display（）"<

};

classB1:

publicB0

{

public:

voiddisplay（）{cout<<"B1:

:

display（）"<

};

classD1:

publicB1

{

public:

voiddisplay（）{cout<<"D1:

:

display（）"<

};

intmain（）

{

B0b0;

B1b1;

D1d1;

B0*p;

p=&b0;

p->display（）;

p=&b1;

p->display（）;

p=&d1;

p->display（）;

}

11．写出程序运行结果:

#include

usingnamespacestd;

classBase

{

intx;

public:

Base（intxx=0）:

x（xx）{cout<<"ConstuctorofBase"<

~Base（）{cout<<"DestuctorofBase"<

voidPrint（）{cout<

intGetX（）{returnx;}

};

classDerived:

publicBase

{

inty;

Basez;

public:

Derived（intxx=0,intyy=0）:

Base（xx）,y（yy）,z（xx+yy）

{cout<<"ConstuctorofDerived"<

~Derived（）{cout<<"DestuctorofDerived"<

voidPrint（）

{

Base:

:

Print（）;

cout<

}

};

intmain（）

{

Derivedobj1

（2）;

obj1.Print（）;

return0;

}

12．写出程序运行结果:

#include

usingnamespacestd;

classAA

{

inta;

public:

AA（）{cout<<"InitializingAA!

\n";}

~AA（）{cout<<"DestroyingAA!

\n";}

};

classBB

{

intb;

AAp;

public:

BB（）{cout<<"InitializingBB!

\n";}

~BB（）{cout<<"DestroyingBB!

\n";}

};

voidmain（）

{

BBX;

cout<<"Endingmain!

\n";

}

13．写出程序运行结果:

#include

usingnamespacestd;

classA

{

public:

A（）{cout<<"ConstructorA"<

~A（）{cout<<"DestructorA"<

};

classB:

publicA

{

public:

B（）{cout<<"ConstructorB"<

~B（）{cout<<"DestructorB"<

};

classC:

publicB

{

public:

C（）{cout<<"ConstructorC"<

~C（）{cout<<"DestructorC"<

};

intmain（）

{

Cc1;

return0;

}

14．写出程序运行结果:

#include

usingnamespacestd;

classA

{

public:

A（）{a=0;b=0;}

A（inti）{a=i;b=0;}

A（inti,intj）{a=i;b=j;}

voiddisplay（）

{

cout<<"a="<

}

private:

inta,b;

};

classB:

publicA

{

public:

B（）{c=0;}

B（inti）:

A（i）{c=0;}

B（inti,intj）:

A（i,j）{c=0;}

B（inti,intj,intk）:

A（i,j）{c=k;}

voiddisplay1（）

{

display（）;

cout<<"c="<

}

private:

intc;

};

intmain（）

{

Bb1;

Bb2

（1）;

Bb3（1,3）;

Bb4（1,3,5）;

b1.display1（）;

b2.display1（）;

b3.display1（）;

b4.display1（）;

return0;

}

15．定义一个基类有姓名、性别、年龄，再由基类派生出教师类和学生类，教师类增加工号、职称和工资，学生类增加学号、班级、专业和入学成绩。

16．声明一个哺乳动物Mammal类，再由此派生出狗Dog类，声明一个Dog类的对象，观察基类与派生类的构造函数与析构函数的调用顺序。

17．声明一个Shape基类，在此基础上派生出Rectangle和Circle类，二者都有GetArea（）函数计算对象的面积。

使用Rectangle类创建一个派生类Square。

18．什么叫做虚基类?

它有何作用?

19．如果在派生类B已经重载了基类A的一个成员函数fn1（），没有重载成员函数fn2（），如何调用基类的成员函数fn1（），fn2（）?

20．派生类构造函数执行的次序是怎样的?