C++面向对象程序设计习题 继承与派生

继承与派生练习题1.什么是继承性？为什么说它是面向对象程序中的重要机制？所谓继承，就是从先辈处得到属性和行为特征。

2.C++中继承分为哪两个类？继承方式又分哪三种？基类和派生类public(公有)、private(私有)和protected(保护)继承3.三中继承方式中有哪些特点？不同基础更方式中派生类的对象对基类成员的访问有何不同？(1) 公有继承(public)方式：基类中的公有成员和保护成员在派生类中仍然是公有成员和保护成员，而基类的私有成员在派生类中不可访问。

(2) 保护继承(protected)方式：基类中的公有成员和保护成员在派生类中都变成保护成员，而基类的私有成员在派生类中不可访问。

(3) 私有继承(private)方式：基类中的公有成员和保护成员在派生类中都变成私有成员，而基类的私有成员在派生类中不可访问。

因此，无论哪种继承方式，基类中的私有成员在派生类中都不允许访问，基类中的公有成员和保护成员都可以被派生类中的成员直接访问。

派生类对象对基类成员的访问1. 保护继承在类定义中，在关键字protected下说明的成员称为保护成员。

保护成员既具有私有的特性又具有公有的特性。

2. 公有继承在公有继承方式下，基类中的公有成员和保护成员在派生类中仍然是公有成员和保护成员，因此，派生类的其它成员可以直接访问它们，但通过派生类的对象只能访问基类的公有成员，不能访问基类的保护成员和私有成员。

3. 私有继承在私有继承方式下，基类中的公有成员和保护成员在派生类中都变成私有成员，因此，派生类的其它成员可以直接访问它们，但通过派生类的对象不能访问基类的任何成员。

4.如何定义单继承的派生类？如何定义多继承的派生类？一个派生类只有一个直接基类，则该继承称为单一继承一个派生类有多个直接基类，则该继承称为多重继承5.派生类与基类之间有什么关系？在面向对象程序设计中，继承就是一个新类可以从现有类获得特征，从现有类产生新类的过程就是类的派生。

现有的用来派生新类的类称为基类或父类，由现有类派生出来的新类称为派生类或子类。

6.单继承中，派生类的构造函数定义格式如何？在C++中，派生类构造函数的一般形式为：派生类名::派生类名(参数总表):基类名(参数表1),对象成员名1(参数表2),对象成员名2(参数表3),…{派生类新增成员的初始化语句}7.多继承中，派生类的构造函数定义格式如何？多重继承定义的一般形式如下：class 派生类名:继承方式1 基类名1,继承方式2 基类名2,…,继承方式n 基类名n {派生类新增加的数据成员和成员函数说明};多重继承派生类的构造函数多重继承派生类的构造函数的一般形式如下：派生类名::派生类名(参数总表):基类名1(参数表1),…,基类名n(参数表n),对象成员名1(对象参数表1),…,对象成员名m(对象参数表m){派生类新增成员的初始化语句}8.多继承中，在哪些情况下会出现二义性？如何消除二义性？在多重继承下，产生二义性的情况主要有以下两种。

1. 调用不同基类的同名成员时产生二义性在多重继承情况下，派生类有多个基类，如果这些基类中有同名的成员，则在派生类中和派生类的对象调用同名成员时，可能产生二义性2. 访问共同基类的成员时产生二义性当一个派生类有多个直接基类，而这些直接基类又有一个共同的基类时，对这个共同基类中成员的访问会出现二义性。

可以使用成员名限定方式，不过这时应该用其直接基类进行限定。

由于多重继承中存在二义性，因此，一个类不能从同一个类中直接继承一次以上。

9.为什么要引入虚基类？带有虚基类的派生类的构造函数有什么特点？在多重继承中，C++提供了虚基类来解决这种二义性问题。

虚基类不是一种新的类型的类，而是一种继承方式。

如果采用虚基类方式定义派生类，则在建立派生类的对象时，类层次结构中某个虚基类的成员只在内存中出现一次，即基类的一个实例被所有派生类的对象所共享。

C++规定，虚基类成员的初始化由最近派生类的构造函数调用虚基类的构造函数完成。

为了保证虚基类的构造函数由最近派生类的构造函数调用，所有由虚基类作为直接或间接基类的派生类的构造函数的成员初始化列表中必须包含对虚基类构造函数的调用。

如果没有列出对虚基类构造函数的调用，则虚基类中必须有缺省构造函数。

C++中又规定，在派生类构造函数的成员初始化列表中，出现的虚基类构造函数先于非虚基类构造函数的调用。

作业题一、选择填空1．下列对派生类的描述中，（）是错的。

A．一个派生类可以作另一个派生类的基类；B．派生类至少有一个基类；C．派生类的成员除了它自己的成员外，还包含了它的基类的成员；D．派生类中继承的基类成员的访问权限到派生类保持不变。

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

A．公有继承的公有成员；B．公有继承的私有成员；C．公有继承的保护成员；D．私有继承的公有成员。

3．派生类的构造函数的成员初始化列表中，不能包含（）。

A．基类的构造函数；B．派生类中对象成员的初始化；C．基类的对象成员的初始化；D．派生类中一般数据成员的初始化。

4．关于多继承二义性的描述中，（）是错的。

A．一个派生类的两个基类中都有某个同名成员，在派生类中对这个成员的访问可能出现二义性；B．解决二义性的最常用的方法是对成员名的限定义；C．基类和派生类中同时出现的同名函数，也存在二义性问题；调用时才产生D．一个派生类是从两个基类派生出来的，而这两个基类又有一个共同的基类，对该基类成员进行访问时，也可能出现二义性。

7．设置虚基类的目的是（）A．简化程序；B．消除二义性；C．提高运行效率；D．减少目标代码。

8．带有虚基类的多层派生类构造函数的成员初始化列表中虚基类的构造函数将被初始化（）A．类下面的派生类个数有关；B．三次；C．二次；D．一次。

二、判断下列描述是否正确，对者划√,错者划×。

√1．C++语言中，既允许单继承，又允许多重继承。

×2．派生类是从基类派生出来，它不能再生成新的派生类。

×3．派生类的继承方式有两种：公有继承和私有继承。

×4．在公有继承中，基类中的公有成员和私有成员在派生类中都是可访问的。

√5．在公有继承中，基类中只有公有成员对派生类对象是可访问的。

×6．在私有继承中，基类中只有公有成员对派生类是可访问的。

√7．在私有继承中，基类中所有成员对派生类的对象都是不可访问的。

8．在保护中继承中，对于垂直访问同于公有继承，而对于水平访问同于私有继承。

√9．派生类是它的基类的组合。

×10．构造函数可以被继承，析构函数不能被继承。

√11．多继承情况下，派生类的构造函数的执行顺序取决于定义派生类时所指定的各基类的顺序。

×12．单继承情况下，派生类中对基类成员的访问也会出现二义性。

√13．解决多继承情况下出现的二义性的方法之一是使用成员名限定法。

三、分析下列程序输出的结果。

1．#include <iostream.h>class A{public:A(int i,int j){a=i;b=j;}void Move(int x,int y){a+=x;b+=y;}void Show(){cout<<"("<<a<<","<<b<<")"<<endl;}private:int a,b;};class B:private A{public:B(int i,int j,int k,int l):A(i,j){x=k;y=l;}void Show(){cout<<x<<","<<y<<endl;}void fun(){Move(3,5);}void f1(){A::Show();}private:int x,y;};void main(){A e(1,2);e.Show();B d(3,4,5,6);d.fun();d.Show();d.f1();}2．#include <iostream.h>class A{public:A(int i,int j){a=i;b=j;}void Move(int x,int y){a+=x;b+=y;}void Show(){cout<<"("<<a<<","<<b<<")"<<endl;} private:int a,b;};class B:private A{public:B(int i,int j,int k,int l):A(i,j),x(k),y(l){ }void Show(){cout<<x<<","<<y<<endl;}void fun(){Move(3,5);}void f1(){A::Show();}private:int x,y;};int main(){A e(1,2);e.Show();B d(3,4,5,6);d.fun();d.A::Show();d.B::Show();d.f1();}3．#include<iostream.h>class P{public:P( int p1,int p2) { pri1=p1;pri2=p2;}Int inc1() { return ++pri1;}int inc2() {return ++pri2;}void display() {cout<<”pri1=”<<pri1<<”,pri2=”<<pri2<<endl;}private:int pri1,pri2;};class D1:virtual private P{public:D1(int p1,int p2,int p3):P(p1,p2){ pri3=p3; }int inc1() {return P::inc1();}int inc3() {return ++pri3;}void display(){P::display();cout<<”pri3=”<<pri3<<endl;}private:int pri3;};class D2:virtual public P{public:D2(int p1,int p2,int p4):P(p1,p2){ pri4=p4; }int inc1(){P::inc1();P::inc2();return P::inc1();}int inc4() {return ++pri4;}void display(){P::display();cout<<”pri4=”<<pri4<<endl;}private:int pri4;};class D12:private D1,public D2{public:D12( int p11,intp12,intp13,intp21,intp22,intp23,int p):D1(p11,p12,p13,),D2(p21,p22,p23),p(p11,p21){pri2=p;}int inc1(){D2::inc1();return D2::inc1();}int inc5() {return ++pri12;}void display(){cout<,”D2:;display()\n”;D2:;display();cout<<pri12=”<<pri12<<endl;}private:int pri12;};void main(){D12 d(1,2,3,4,5,6,7);d.display();cout<<endl;d.inc1();d.inc4();d.inc5();d,D12::inc1();d.display();}。