继承与派生习题
C++讲义-第九章习题
一．选择题
1．下列对派生类的描述中，错误的是（）
A．一个派生类可以作为另一个派生类的基类。
B．派生类至少有一个基类。
C．派生类的成员除了它自己的成员之外，还包含了它的基类的成员。
D．派生类中继承的基类成员的访问权限到派生类保持不变。
2．派生类的对象对它的基类成员中，可以访问的是（）
A．公有继承的公有成员。
B．公有继承的私有成员。
C．公有继承的保护成员。
D．私有继承的公有成员。
3．对基类和派生类的关系描述中，错误的是（）
A．派生类是基类的具体化。
B．派生类是基类的子集。
C．派生类是基类定义的延续。
D．派生类是基类的组合。
4．派生类的构造函数的成员初始化列表中，不能包含的是（）
A．基类的构造函数。
B．派生类中子对象的初始化。
C．基类的子对象初始化。
D．派生类中一般数据成员的初始化。
5．关于子类型的描述中，错误的是（）
A．子类型就是指派生类是基类的子类型。
B．一种类型当它至少提供了另一种类型的行为，则这种类型是另一种类型的子类型。
C．在公有继承下，派生类是基类的子类型。
D．子类型关系是不可逆的。
6．关于多继承二义性的描述中，错误的是（）
A．一个派生类的两个基类中都有某个同名成员，在派生类中对这个成员的访问可能出现二义性。
B．解决二义性的常用方法是对成员名进行类名限定。
C．基类和派生类中同时出现的同名函数，也存在二义性问题。
D．一个派生类是从两个基类派生来的，而这两个基类又有一个共同的基类，对该基类成员进行访问时，也可能出现二义性。
7．设置虚基类的目的是（）
A．简化程序B．消除二义性
C．提高运行效率D．减少目标代码
8．带有虚基类的多层派生类构造函数的成员初始化列表中都要列出虚基类的构造函数，这样将对虚基类的子对象初始化的次数为（）
A．与虚基类下面的派生类个数有关。B．多次
C．二次D．一次
9．C++中的类有两种用法：一种是类的实例化，即生成类的对象，并参与系统的运行；另一种是通过（），派生出新的类。
A．复用B．继承C．单继承D．多继承
10．当基类本身也是某一个类的派生类时，底层的派生类也会自动继承间接基类的成员，这种特性是继承的（）。
A．规律性B．传递性C．重复性D．多样性
11．若类A与类B的定义如下：
class A
{
int i,j;
public:
void get();
//.....
};
class B:A
{
int k;
public:
void make() { k=i*j; }
//....
};
则上述定义中，非法的是（）。
A．void get(); B．int k; C．void make() D．k=i*j;
12．在派生类中定义的析构函数与它所属的基类的关系是（）。
A．一定有关B．一定无关C．以上都不对
13．在多继承中，公有派生和私有派生对于基类成员在派生类中的可访问性与单继承的规则是（）。
A．完全相同的B．完全不同的
C．部分相同，部分不同D．以上都不对
14．在多继承的构造函数定义中，几个基类的构造函数之间的分隔符是（）。
A．：B．；C．，D．：：
二．判断下列描述的正确性。
1．C++语言中，既允许单继承，又允许多继承。
2．派生类是从基类派生出来的，它不能再派生新的派生类。
3．派生类的继承方式有两种：公有继承和私有继承。
4．在公有继承中，基类中的公有成员和私有成员在派生类中都是可见的。
5．在公有继承中，基类中只有公有成员对派生类对象是可见的。
6．在私有继承中，基类中只有公有成员对派生类是可见的。
7．在私有继承中，基类中所有成员对派生类的对象都是不可见的。
8．在保护继承中，对于垂直访问同于公有继承，而对于水平访问同于私有继承。
9．派生类是它的基类的组合。
10．构造函数可以被继承。
11．析构函数不能被继承。
12．子类型是不可逆的。
13．只有是类M继承了类N，就可以说类M是类N的子类型。
14．如果A类型是B类型的子类型，则A类型必然适应于B类型。
15．多继承情况下，基类构造函数的执行顺序取决于定义派生类时所指定的各基类的顺序。
16．单继承情况下，派生类中对基类成员的访问也会出现二义性。
17．解决多继承情况下出现的二义性的方法之一是使用成员名限定法。
18．虚基类是用来解决多继承中公共基类在派生类中产生多个基类子对象的拷贝问题。三．回答问题。
1．在下面给定的含有虚基类的复杂继承结构中，回答下列提出的各问题。
class A
{
public:
void f();
};
class B:virtual public A
{
public:
void f();
};
class C:public B
{ };
class D:public C,virtual public A
{
public:
void g();
};
问题：
⑴画出上述结构的DAG图。
⑵设有 D d;问：d.f()是否有二义性。
⑶设有：void D::g() { f(); }。问：g()函数中对f()调用是否有二义性。
2．在下面给定的继承结构中，回答下列提出的问题。
class A
{
public:
int a;
int b();
int f();
int f(int);
int g();
};
class B
{
public:
char f();
int g();
private:
int a;
int b();
};
class C:public A,public B
{
};
设有：C *pc;
问题：
⑴pc->a=1是否存在二义性。
⑵pc->b()是否存在二义性。
⑶pc->f()是否存在二义性。
⑷pc->f(10)是否存在二义性。
⑸pc->g()是否存在二义性。
四．分析下列程序的输出结果。
1．程序清单如下：
#include
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<<"("< int a,b; }; class B:private A { public: B(int i,int j,int k,int m):A(i,j) { x=k; y=m; } void show() { cout< 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 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<<"("< int a,b; }; class B:public A { public: B(int i,int j,int k,int m):A(i,j) { x=k; y=m; } void show() { cout< 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(); } 3．程序清单如下： #include class L { public: void InitL(int x,int y) { X=x;Y=y; } void Move(int x,int y) { X+=x; Y+=y; } int GetX() { return X; } int GetY() { return Y; } private: int X,Y; }; class R:public L { public: void InitR(int x,int y,int w,int h) { InitL(x,y); W=w; H=h; } int GetW() { return W; } int GetH() { return H; } private: int W,H; }; class V:public R { public: void fun() { Move(3,2); } }; void main() { V v; v.InitR(10,20,30,40); v.fun(); cout< 4．程序清单如下： #include class P { public: P(int p1,int p2) { pri1=p1; pri2=p2; } int inc1() { return ++pri1; } int inc2() { return ++pri2; } void display() { cout<<"pri1="< int pri1,pri2; }; class D1: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="< private: int pri3; }; class D2:public P { public: D2(int p1,int p2,int p3):P(p1,p2),pri4(p3) { } int inc1() { P::inc1(); P::inc2(); return P::inc1(); } int inc4() { return ++pri4; } void display() { P::display(); cout<<"pri4="< private: int pri4; }; class D12:private D1,public D2 { public: D12(int p11,int p12,int p13,int p21,int p22,int p23,int p):D1(p11,p12,p13),D2(p21,p22,p23) { pri12=p; } int inc1() { D2::inc1(); return D2::inc1(); } int inc5() { return ++pri12; } void display() { D2::display(); cout<<"pri12="< private: int pri12; }; void main() { D12 d(1,2,3,4,5,6,7); d.display(); cout< d.inc1(); d.inc4(); d.inc5(); d.D12::inc1(); d.display(); } 5．程序清单如下： #include class P { public: P(int p1,int p2) { pri1=p1; pri2=p2; } int inc1() { return ++pri1; } int inc2() { return ++pri2; } void display() { cout<<"pri1="< 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="< int pri3; }; class D2:virtual public P { public: D2(int p1,int p2,int p3):P(p1,p2),pri4(p3) { } int inc1() { P::inc1(); P::inc2(); return P::inc1(); } int inc4() { return ++pri4; } void display() { P::display(); cout<<"pri4="< int pri4; }; class D12:private D1,public D2 { public: D12(int p11,int p12,int p13,int p21,int p22,int p23,int p) :D1(p11,p12,p13),D2(p21,p22,p23),P(p11,p12),pri12(p) { } int inc1() { D2::inc1(); return D2::inc1(); } int inc5() { return ++pri12; } void display() { D2::display(); cout<<"pri12="< int pri12; }; void main() { D12 d(1,2,3,4,5,6,7); d.display(); cout< d.inc1(); d.inc4(); d.inc5(); d.D12::inc1(); d.display(); } 6．程序清单如下： #include class data { int x; public: data(int x) { data::x=x; cout<<"class data"< class a { data d1; public: a(int x):d1(x) { cout<<"class a"< }; class b:public a { data d2; public: b(int x):a(x),d2(x) { cout<<"class b"< class c:public b { public: c(int x):b(x) { cout<<"class c"< }; void main() { c obj(5); } 7．程序清单如下： #include class base { public: void who() { cout<<"base class"< }; class derive1:public base { public: void who() { cout<<"devive1 class"< }; class derive2:public base { public: void who() { cout<<"derive2 class"< void main() { base obj1,*p; derive1 obj2; derive2 obj3; p=&obj1; p->who(); p=&obj2; p->who(); p=&obj3; p->who(); obj2.who(); obj3.who(); } 8．程序清单如下： #include class base { int x1,x2; public: void assign(int p1,int p2) { x1=p1; x2=p2; } int inc1() { return ++x1; } int inc2() { return ++x2; } void display() { cout<<"base x1="< }; class derive1:base { int x3; public: derive1(int p3) { x3=p3; } void assign(int p1,int p2) { base::assign(p1,p2); } int inc1() { return base::inc1(); } int inc2() { return base::inc2(); } int inc3() { return ++x3; } void display() { cout<<"derive1 x3="< }; class derive2: public base { int x4; public: derive2(int p4) { x4=p4; } int inc1() { int temp=base::inc1(); temp=base::inc1(); temp=base::inc1(); return base::inc1(); } int inc4() { return ++x4; } void display() { base::display(); cout<<"derive2 x4="< } }; void main() { base p; p.assign(-2,-2); p.display(); derive1 d1(-4); d1.assign(10,10); d1.inc1(); d1.display(); derive2 d2(5); d2.assign(-6,-6); d2.display(); d2.inc1(); d2.inc2(); d2.display(); d2.base::inc1(); d2.display(); } 9．程序清单如下： #include class base { public: base() { cout<<"base类构造函数"< virtual ~base()=0; }; base::~base() { cout<<"base类析构函数"< class derived:public base { public: derived() { cout<<"derived类构造函数"< ~derived() { cout<<"derived析构造函数"< void main() { derived *p=new derived; delete p; } 10．程序清单如下： #include class person { char *name; int age; char *add; public: person() { cout<<"person class constructor"< class student:public person { char *department; int level; public: student() { cout<<"student class constructor"< class teacher:public person { char *major; float salary; public: teacher() { cout<<"teacher class constructor"< ~teacher() { cout<<"teacher class destructor"< }; void main() { student s1; teacher t1; } 五．填空题 1．派生可分为、和。由得到的派生类，其基类的所有公有成员都只能成为它的私有成员，这些私有成员只能被派生类的成员函数访问，而无权访问。的意义是基类中所有公有成员在派生类也都是公有的。 2．基类的不能为派生类的成员访问，基类的在派生类中的性质和继承的性质一样，而基类的在私有继承时在派生类中成为私有成员函数，在公有和保护继承时在派生类中仍为保护成员函数。 3．提供了类对外部的接口，是类的内部实现，而不允许外界访问，但允许派生类的成员访问，这样既有一定的隐藏能力，又提供了对外开放的接口。 4．对于派生类的构造函数，在定义对象时构造函数的执行顺序为：先执行，再执行，后执行。对于多继承的情形，在执行基类构造函数时，其执行按顺序执行的。 5．对于派生类与基类的关系，可从三个方面进行理解。可认为派生类是基类的、派生类是基类、派生类是基类的。 6．当派生类对象生命周期结束时，系统会自动调用析构函数。由于，所以在执行析构函数时，先执行，再执行。 7．派生类与基类之间可以存在类型适应的关系，派生类可以是基类的子类型，基于这种关系的继承要求是，且子类型的适应关系是。类型适应原则也称为赋值兼容原则， 赋值兼容原则的具体内容是：、、。 8．派生类对基类成员的访问可能会产生二义性的问题，消除二义性访问的常用方法是使用作用 域运算符对被访问的成员进行惟一性标识。但当基类本身之间就存在继承关系时，用作用域运算符对成员进行惟一性标识时，要求必须用进行限定，而消除二义性访问的另一种途径是采用技术。 9．要保证虚基类子对象在构造派生类对象时只被构造一次，则虚基类的构造函数由负责调用。若在成员的初始化列表中出现对虚基类与非虚基类构造函数的调用，则优先执行的是。 10．在多继承的派生层次中，若上层的公共基类是虚基类，则从不同途径继承下来的虚基类子 对象在派生类中只存在个拷贝，因此对虚基类成员的访问自然就消除了二义性。 六．程序设计 1．编写一个程序，设计一个汽车类vehicle，包括的数据成员有：车轮个数wheels和车重weight。小车类car是它的私有派生类，其中包括载人数passenger_load。卡车类truck是vehicle的私有派生类，其中包含载人数passenger_load和载重量payload。每个类都有相关数据的输出方法。 2．设计一个圆类circle和一个桌子类table，另设计一个圆桌类roundtable，它是从前两个类中派生的，要求输出一个圆桌的高度、面积和颜色等数据。 3．设计一个虚基类base，包含姓名和年龄私有数据成员以及相关的成员函数，由它派生出领导类leader，包含职务和部门私有数据成员以及相关的成员函数。再由base类派生出工程师类engineer，包含职称和专业私有数据成员以及相关的成员函数。然后由leader和engineer类派生出主任工程师类chairman。采用一些数据进行测试。 4．设计一学生与教师管理程序。教师包括编号、姓名、职称和教研室数据的输入输出；学生包括编号、姓名、性别、班号、英语、高等数学和数据结构三门课程成绩的输入输出和计算平均分。七．名词解释 继承；基类；派生类；虚基类；赋值兼容；子类型；公有继承；私有继承；保护继承 继承和派生习题 1 分析以下程序的执行结果 #include 类的继承与派生 编写一个程序设计一个汽车类vehicle，包含的数据成员有车轮个数wheels 和车重weight。小车类car是它的派生类其中包含载人数passenger_load。卡车类truck是vehicle的派生类其中包含载人数passenger_load和载重量payload，每个类都有相关数据的输出方法. 提示:vehicle类是基类由它派生出car类和truck类将公共的属性和方法放在vehicle类中。 输出结果: 车型：小车 车轮：4个 重量：2000公斤 载人：5人 车型：卡车 车轮：10个 重量：8000公斤 载人：3人 参考代码: #include float weight; // 重量 public: vehicle(int wheels,float weight); int get_wheels(); float get_weight(); float wheel_load(); void show(); }; class car:public vehicle // 定义小车类 { int passenger_load; // 载人数 public: car(int wheels,float weight,int passengers=4); int get_passengers(); void show(); }; class truck:public vehicle // 定义卡车类 { int passenger_load; // 载人数 float payload; // 载重量 public: truck(int wheels,float weight,int passengers=2,float max_load=24000.00); int get_passengers(); float efficiency(); void show(); }; vehicle::vehicle(int wheels,float weight) { vehicle::wheels=wheels; vehicle::weight=weight; 第八章继承与多态习题 一.基本概念与基础知识自测题 8.1填空题 8.1.1 如果类α继承了类β，则类α称为（1）类，而类β称为（2）类。（3）类 的对象可作为（4）类的对象处理，反过来不行，因为（5）。如果强制转换则要注意（6）。 答案：（1）基类 （2）派生类 （3）派生类 （4）基类 （5）派生类有一些新成员 （6）只能派生类强制转换为基类 8.1.2 当用public继承从基类派生一个类时，基类的public成员成为派生类的（1）成员， protected成员成为派生类的（2）成员，对private成员是（3）。公有派生可以使其类的（4），所以公有派生是主流。 答案：（1）public成员 （2）protected成员 （3）不可访问 （4）接口不变 8.1.4 一个派生类只有一个直接基类的情况称为（1），而有多个直接基类的情况称为 （2）。继承体现了类的（3）概念，这在MFC中得到了很好表现，MFC中只采用了（4）。 答案：（1）单继承 （2）多重继承 （3）层次 （4）单继承 8.1.6 C++中多态性包括两种多态性：（1）和（2）。前者是通过（3）实现的， 而后者是通过（4）和（5）来实现的。 答案：（1）编译时的 （2）运行时的 （3）函数和运算符的重载 （4）类继承关系 （5）虚函数 8.2简答题（以下习题题号可能和教材不一致！） 8.2.1构造函数和析构函数可以继承吗？派生类构造函数各部分的执行次序是怎样的？答：构造函数和析构函数不可以继承。派生类构造函数各部分的执行次序是： 1.调用基类构造函数，按它们在派生类声明的先后顺序，依次调用。 2.调用新增成员对象的构造函数，按它们在类定义中声明的先后顺序，依次调用。 3.派生类的构造函数体中的操作。 8.2.2什么叫派生类的同名覆盖（override）? 1. 类的继承与派生综合题1 题目描述 定义Staff（员工）类，由Staff分别派生出Saleman(销售员)类和Manager（经理）类，再由Saleman（销售员）类和Manager（经理）类采用多重继承方式派生出新类SaleManager（销售经理）类。 要求： a.在Staff类中包含的数据成员有编号（num）、姓名（name）、出勤率（rateOfAttend）、基本工资（basicSal）和奖金（prize）。在Saleman类中还包含数据成员：销售员提成比例（deductRate）和个人销售额（personAmount），在Manager类中还包含数据成员：经理提成比例（totalDeductRate）和总销售额（totalAmount）。在SaleManager类中不包含其他数据成员。 b.各类人员的实发工资公式如下： 员工实发工资=基本工资+奖金*出勤率 销售员实发工资=基本工资+奖金*出勤率+个人销售额*销售员提成比例 经理实发工资=基本工资+奖金*出勤率+总销售额*经理提成比例 销售经理实发工资=基本工资+奖金*出勤率+个人销售额*销售员提成比例+总销售额*经理提成比例 c.每个类都有构造函数、输出基本信息函数（Output）和输出实发工资函数（OutputWage）。 主函数如下： int main() { Salemanobjsale(101101, "LD", 0.88f, 1200, 800, 0.05f, 10000); Manager objmana(101102, "NXG", 0.90f, 2500, 1000, 0.10f, 20000); SaleManagerobjsalemana(101103, "HDY", 0.99f, 3500, 2000, 0.20f, 100000, 0.20f,150000); objsale.Output(); cout<< "销售员的实发工资：" << " "; cout< 继承与多态习题 一.基本概念与基础知识自测题 8.1填空题 8.1.1 如果类α继承了类β，则类α称为（1）类，而类β称为（2）类。（3）类 的对象可作为（4）类的对象处理，反过来不行，因为（5）。如果强制转换则要注意（6）。 答案：（1）基类 （2）派生类 （3）派生类 （4）基类 （5）派生类有一些新成员 （6）只能派生类强制转换为基类 8.1.2 当用public继承从基类派生一个类时，基类的public成员成为派生类的（1）成员， protected成员成为派生类的（2）成员，对private成员是（3）。公有派生可以使其类的（4），所以公有派生是主流。 答案：（1）public成员 （2）protected成员 （3）不可访问 （4）接口不变 8.1.3 利用继承能够实现（1）。这种实现缩短了程序开发的时间，VC++中的（2）很 好地体现了这一点。 答案：（1）代码的复用 （2）MFC编程 8.1.4 一个派生类只有一个直接基类的情况称为（1），而有多个直接基类的情况称为 （2）。继承体现了类的（3）概念，这在MFC中得到了很好表现，MFC中只采用了（4）。 答案：（1）单继承 （2）多重继承 （3）层次 （4）单继承 8.1.5 C++中多态性包括两种多态性：（1）和（2）。前者是通过（3）实现的， 而后者是通过（4）和（5）来实现的。 答案：（1）编译时的 （2）运行时的 （3）函数和运算符的重载 （4）类继承关系 （5）虚函数 8.1.6 在基类中将一个成员函数说明成虚函数后，在其派生类中只要（1）、（2）和 （3）完全一样就认为是虚函数，而不必再加关键字（4）。如有任何不同，则认为是（5）而不是虚函数。除了非成员函数不能作为虚函数外，（6）、（7）和（8）也不能作为虚函数。 答案：（1）同虚函数名 （2）同参数表 （3）同返回类型。如基类中返回基类指针，而派生类中返回派生类指针是允许的 （4）virtual （5）重载 （6）静态成员函数 （7）内联函数 （8）构造函数 8.1.7 纯虚函数定义时在函数参数表后加（1），它表明程序员对函数（2），其本质 是将指向函数体的指针定为（3）。 答案：（1）=0 （2）不定义 （3）NULL 8.2简答题 8.2.1构造函数和析构函数可以继承吗？派生类构造函数各部分的执行次序是怎样的？答：构造函数和析构函数不可以继承。派生类构造函数各部分的执行次序是： 1.调用基类构造函数，按它们在派生类声明的先后顺序，依次调用。 2.调用新增成员对象的构造函数，按它们在类定义中声明的先后顺序，依次调用。 3.派生类的构造函数体中的操作。 8.2.2什么叫派生类的同名覆盖（override）? 答：如果派生类声明了一个和某个基类成员同名的新成员（当然如是成员函数，参数表也必须一样，否则是重载），派生类中的新成员就屏蔽了基类同名成员，类似函数中的局部变量屏蔽全局变量。称为同名覆盖（override）。 8.2.3派生类的析构函数中需完成什么任务？是否要编写对基数和成员对象的析构函数的 调用？为什么？ 答：析构函数的功能是作善后工作，析构函数无返回类型也没有参数，情况比较简单。派生类析构函数定义格式与非派生类无任何差异，不要编写对基数和成员对象的析构函数的调用，只要在函数体内把派生类新增一般成员处理好就可以了，因为对新增的成员对象和基类的善后工作，系统会自己调用成员对象和基类的析构函数来完成。 8.2.4为什么要使用虚基类？怎样定义虚基类？用一个实例来解释虚基类在其派生类中的 存储方式。 答：在多重继承是有可能出现同一基类的两个拷贝，为避免这种情况，可使用虚基类。虚基类（virtual base class）定义方式如下： class派生类名:virtual 访问限定符基类类名{...}; class派生类名:访问限定符virtual基类类名{...}; virtual 关键字只对紧随其后的基类名起作用。 继承与组合 一、实验目的 1．了解继承在面向对象程序设计中的重要作用。 2．进一步理解继承与派生的概念。 3．掌握通过继承派生出一个新的类的方法。 4．了解虚基类的作用和用法。 5．掌握类的组合 二、实验内容 1．请先阅读下面的程序，写出程序运行的结果，然后再上机运行程序，验证自己分析的结果是否正确。 (1) #include buf=new char[i]; } virtual ~B() { delete []buf; cout<<"B::~B() called.\n"; } private: char *buf; }; void fun(A *a) { cout<<"May you succeed!"< A::A() called. B::B() called. May you succeed! B::~B() called. A::~A() called. (2) #include 第九章继承与派生类 9．2 典型例题分析与解答 例题1：下列对派生类的描述中，（）是错误的。 A．一个派生类可以作为另一个派生类的基类 B．派生类至少有一个基类 C．派生类的成员除了它自己的成员外，还包含了它的基类成员 D．派生类中继承的基类成员的访问权限到派生类保持不变 答案：D 分析：一个派生类可以作为另一个派生类的基类。无论是单继承还是多继承，派生类至少有 成 的成员时可能出现二义性。消除二义性的方法是采用作用域运算符。派生类和它的基类中出现同名函数时，不可能出现二义性。 例题4：多继承派生类构造函数构造对象时，（）被最先调用。 A．派生类自己的构造函数 B．虚基类的构造函数 C．非虚基类的构造函数D．派生类中子对象类的构造函数 答案：Ｂ 分析：多继承派生类构造函数构造对象时，构造函数的调顺序是：虚基类的构造函数，派生类中子对象类的构造函数,派生类自己的构造函数。 例题5：C++类体系中，能被派生类继承的是（）。 A．构造函数B．虚函数C．析构函数D．友元函数答案：Ｂ 分析：C++类体系中，构造函数、析构函数和友元函数是不能被派生类继承的． 例题6：设有基类定义： class Cbase { private: int a; protected: int b; public: int c; }; 用派生类中子对象类的析构函数，最后调用基类的析构函数。 例题11：设有以下类的定义： class A class B: protected A class C: private B { int A1; { int b1; { int c1; protected: int A2; protected: int b2; protected: int c2; public: int A3; public: int b3; public: int c3; }; }; }; 请按访问权限写出派生类C中具有的成员。 私有成员： (1) 福建农林大学金山学院实验报告 系（教研室）：信息与机电工程系专业：计算机科学与技术年级： 实验课程：面向对象程序设计姓名：学号： 实验室号 计算机号 实验时间：指导教师签字：成绩： 实验4 派生类和继承（一） 一、实验目的和要求 （1）掌握派生类的声明与定义方法，进一步理解类的继承的概念，能够定义和使用类的继承关系。 （2）熟悉公有派生和私有派生的访问特性。 二、实验内容和原理 1、程序分析题（写出程序的输出结果，并分析结果）。 2、(1)定义一个基类animal，该类具有私有整型成员变量age,weight，构造派生类dog公有继承animal，dog类新增私有成员变量color，新增成员函数SetAge（int n）中直接给age赋值，新增成员函数SetWeight（int m）中直接给weight赋值，查看编译结果，并分析结果。(2)将类animal中的age和weight为公有成员，重做第一步，并分析结果。(3)将类animal中的age和weight为保护成员，重做第一步，并分析结果。（4）将派生类dog的继承方式改为私有继承方式和保护继承方式重做以上各小题，并分析结果。 三、实验环境 1. 硬件：PC机； 2. 软件：Windows操作系统、Visual C++ 6.0 四、算法描述及实验步骤 2.1 #include {private:char color[10]; public: int SetAge(int n) {age=n;return n;} int SetWeight (int m) {weight=m;return m; } }; int main() { int x,y; dog a; cout<<"请输入这条狗的岁数="; cin>>x;cout< 1. 定义一个哺乳动物类Mamma，l 并从中派生出一个狗类Dog，要求： ( 1) 添加Dog 类的颜色数据成员，访问属性为私有，通过函数来对颜色进行设置和获取。 ( 2) 分别为基类和派生类添加相应的构造函数(有参、无参) 测试。 class Mammal { protected: int itsAge; int itsWeight; public: int GetAge(){return itsAge;} void SetAge(int age) {itsAge=age;} int GetWeight() { return itsWeight;} void SetWeight(int weight) {itsWeight= weight;} }; class Dog : public Mammal { // 定义Dog 类的数据成员和成员函数 }; 改: #include 实验四继承与派生 一、实验目的： 掌握利用单继承和多重继承的方式定义派生类的方法； 深刻理解在各种继承方式下构造函数和析构函数的执行顺序； 理解和掌握公有继承，私有继承和保护继承对基类成员的访问机制； 理解虚基类的概念以及引入虚基类的目的和作用。 二、实验时间： 三、实验地点： 四、实验内容： 1．运行以下程序，并对运行结果进行分析 #include"stdafx.h" #include 1197: 继承与派生1 Description 请以点类Point为基类派生出一个圆类Circle。圆类Circle的数据成员为r（私有属性，存储圆的半径，圆心的点坐标通过继承点类Point加以实现），成员函数有构造函数Circle、计算圆的面积函数Area、计算圆的周长函数Perimeter和输出函数Display，其中构造函数实现基类和圆类的数据成员的初始化，Display函数实现圆心坐标（利用基类Point的Display实现）、圆的半径、圆的面积（利用Area函数实现）和圆的周长（利用Perimeter函数实现）的输出。请编写圆类的定义及成员函数实现，并在主函数中定义圆类对象，验证各个函数的正确性。说明：圆周率PI的取值为3.14 已知Point类的定义及main代码如下：（不允许改动） class Point { public: Point(double xx,double yy); //constructor void Display(); //display point private: double x,y; //平面的点坐标x，y }; int main() { double x,y,r; cin>>x>>y>>r; //圆心的点坐标及圆的半径 Circle C(x,y,r); C.Display(); //输出圆心点坐标，圆的半径，圆的面积，圆的周长 return 0; } Input Output Sample Input 1.5 2.6 1.8 Sample Output Center:Point(1.5,2.6) Radius:1.8 Area:10.1736 Perimeter:11.304 ************************************************************************** #include 一、选择题 1. 在C++中,类与类之间的继承关系具有（C ） A）自反性B）对称性C）传递性D）反对称性 2. 在公有继承的情况下，基类的成员（私有的除外）在派生类中的访问权限（B A）受限制B）保持不变C）受保护D）不受保护 3. 按解释中的要求在下列程序划线处填入的正确语句是： （C ） #in elude 6. 当一个派生类仅有protected继承一个基类时，基类中的所有公有成员成为派生类的（C） A） public 成员B） private 成员C） protected 成员D) 友元 7. 不论派生类以何种方法继承基类，都不能使用基类的(B ) A) public 成员B) private 成员C) protected 成员D) public 成员和protected 成员 8 下面叙述错误的是( S )。 A) 基类的protected 成员在派生类中仍然是protected 的 B) 基类的protected 成员在public 派生类中仍然是protected 的 C) 基类的protected 成员在private 派生类中是private 的 D) 基类的protected 成员不能被派生类的对象访问 9. 下列说法中错误的是( S )。 A) 保护继承时基类中的public 成员在派生类中仍是public 的 B) 公有继承时基类中的private 成员在派生类中仍是private 的 C) 私有继承时基类中的public 成员在派生类中是private 的 D) 保护继承时基类中的public 成员在派生类中是protected 的 10下面叙述错误的是( C)。 A) 派生类可以使用private 派生 B) 对基类成员的访问必须是无二义性的 C) 基类成员的访问能力在派生类中维持不变 D) 赋值兼容规则也适用于多继承的组合 11派生类的构造函数的成员初始化列表中，不能包含(C )。 A) 基类的构造函数B) 派生类中子对象 的初始化 C) 基类中子对象的初始化D) 派生类中一般数 据成员的初始化 12. 下列虚基类的声明中，正确的是： ( B ) A)class virtual B: public A B)class B: virtual public A C)class B: public A virtual D)virtual class B: public A 13..实现运行时的多态性采用（D ） A）重载函数B）构造函数C）析构函数D）虚函数 14. 若一个类中含有纯虚函数，则该类称为（D ） 第一节类的继承与派生 一、基本概念 继承是面向对象程序设计的一个特性，所谓继承就是在已有类的基础上创建新的类，新类可以从一个或多个已有类中继承成员函数或数据成员，而且新类还可以重新定义或加进新的数据和函数。其中，已有类称为基类或父类，新类称为派生类或子类。 在现实世界中许多事物都具有继承性。例如：“汽车”这个类中包括了许多类型，有运输汽车、专用汽车；运输汽车中又包括客车、货车…….；专用汽车中又包括巡逻车、消防车、救护车……..；所有这些类型的车都具有汽车的共同特性即都有发动机、车身、轮胎等共性，还都是自行驱动的。 而客车和货车又有所不同，客车用来载客，货车用来拉货，它们有自己不同于其它车的特性，这就是继承。我们把汽车称为基类，把运输汽车、客车、货车称为派生类。通过继承，派生类不仅拥有了基类的属性和行为，而且具有不同于它类的自己的特点。 二、派生类的定义与构成 当你去水果店买水果的时候，你经常会发现很多同类水果又有了新的品种。比如，“李子”既小又涩，嫁接在梨树上后长出来的李子却硕大、香甜、清脆，比没有嫁接的李子好吃，但它还是李子家族中的一员；所以，可以认为“嫁接李子”是从“李子”中派生出来的。当然，可以把“李子”嫁接在梨树上，也可以嫁接在苹果树上，结出来的都是“李子”，但是各自味道不同。 所谓派生就是从已有类中产生一个新的子类。 基类就是已存在的可以派生新类的类，如下图中的A、D、E都是基类。 派生类就是由基类派生出来的新类，如下图中的B、C、F都是派生类。 1. 单继承派生类的定义格式 class <派生类名> : <继承方式> <基类名> { 派生类成员的定义; }; 其中，“派生类名”是新定义的一个类的名字，它是从“基类名”中派生的，并且按指定的“继承方式”派生。 例如： class peach 多继承派生类的定义格式 class <派生类名> ：<继承方式1> <基类名>，<继承方式2> <基类名>, ……. { 派生类成员的定义； }; 多继承与单继承在定义格式的区别仅在于它们的基类个数不同，单继承的基类只有一个，而多继承的基类有多个，相邻两个基类之间用逗号间隔，每个基类名前都应有一个该基类的继承方式的说明符。 例如： class peach //定义基类：peach { datatype color , shape ; 继承与派生练习题 习题八 第八章继承与派生 1.下列对派生类的描述中，（D.派生类中继承的基类成员的访问权限到派生类保持不变 ）是错误的。 A．一个派生类可以作为另一个派生类的基类 B．派生类至少有一个基类 C．派生类的成员除了它自己的成员外，还包含了它的基类成员 D．派生类中继承的基类成员的访问权限到派生类保持不变 2. 派生类的对象对它的哪一类基类成员是可以访问的？（A．公有继承的基类的公有成员） A．公有继承的基类的公有成员 B. 公有继承的基类的保护成员 C. 公有继承的基类的私有成员 D. 保护继承的基类的公有成员 3. 关于多继承二义性的描述，（D.派生类和它的基类中出现同名函数时，将可能出现二义性 ）是错误的。 A．派生类的多个基类中存在同名成员时，派生类对这个成员访问可能出现二义性B．一个派生类是从具有共同的间接基类的两个基类派生来的，派生类对该公共基类的访问可能出现二义性 C．解决二义性最常用的方法是作用域运算符对成员进行限定 D．派生类和它的基类中出现同名函数时，将可能出现二义性 4. 多继承派生类构造函数构造对象时，（B．虚基类的构造函数）被最先调用。 A．派生类自己的构造函数B．虚基类的构造函数 C．非虚基类的构造函数 D．派生类中子对象类的构造函数 5. C++类体系中，能被派生类继承的是（ B．虚函数）。 A．构造函数 B．虚函数 C．析构函数 D．友元函数 6. 设有基类定义： class Cbase { private: int a; protected: int b; public: int c; }; 派生类采用何种继承方式可以使成员变量b成为自己的私有成员(A. 私有继承) A. 私有继承 B.保护继承继承和派生习题
类的继承与派生
C 第八章继承与派生习题习题解答
类的继承与派生综合题
继承与多态习题
实验六继承与派生
C++继承与派生类习题
实验四：派生类和继承(一)
c++实验8继承与派生上机练习题
实验四 继承与派生
继承与派生参考代码
C++习题3(继承和多态)
实验五类的继承与派生
继承与派生练习题