C语言大学教程-C++语言第20章

面向对象编程：继承提纲继承简介基类和派生类派生类的定义格式基类和派生类之间的关系派生类的构造函数与析构函数多继承多继承中的二义性问题虚基类继承简介继承(Hierarchy)是C++语言的一种重要机制。继承是指把已有的类作为基类来定义新的类。新类继承了其基类的属性和操作，还可以具有其基类不具备的自己特有的属性和操作。继承性为软件的编写提供了强有力的机制，提高了软件的可靠性、易读性、有效性、可移植性和可重用性。继承提供了在已有类的根底上开发出新类的机制，可以节省重复代码的编写工作，是软件重用的根底。

BAA派生类是对基类的扩充一个类A，对A类加以扩展，即增加一些属性和行为，构成一个新类B，此时B类将A类已有的属性和行为继承下来。称类B继承了A，或称类A派生了B。A：父类，基类BaseClassB：子类，派生类DerivedClass基类和派生类基类和派生类类的继承是在现有类的根底之上，创立新类的机制。称现有的类为基类，新建立的类为派生类。新类继承了基类的属性和行为新类是基类的特殊情况。不必从“草稿”开始创立特殊的程序对象继承表达现实世界的层次概念：交通工具卡车汽车小汽车工具车轿车面包车基类和派生类关于基类和派生类的关系，可以表述为:派生类是基类的具体化，而基类那么是派生类的抽象。在C++中，继承分为单继承和多继承：单继承——派生类只有一个直接基类的继承方式；多继承——派生类有多个直接基类的继承方式。如以下图所示：外部存储器软盘光盘硬盘单继承ABC单继承XYZ多继承基类和派生类直接基类和间接基类父类被称为子类的直接基类父类的父类或更高层次的父类被称为这个子类的间接基类

派生类的定义格式〔单继承〕在C++中，派生类的一般声明语法如下:class<派生类名>:[继承方式]<基类名>{

派生类成员声明；

}；其中：

派生类只有一个直接基类为单继承①class是类声明的关键字，用于告诉编译器下面声明的是一个类。②派生类名是新生成的类名。派生类的定义格式〔单继承〕派生类的定义格式③共有三种继承方式：公有继承〔public〕，私有继承〔private，系统的默认值〕，保护继承〔protected〕。派生类的定义格式继承方式指定派生类成员以及类外对象对继承来的成员的访问权限。不同继承方式的影响主要表达在：1、派生类成员对基类成员的访问控制。2、派生类对象对基类成员的访问控制。④派生类成员指除了从基类继承来的所有成员之外，新增加的数据和函数成员。这些新增的成员正是派生类不同于基类的关键所在，是派生类对基类的开展。当重用和扩充已有的代码时，就是通过在派生类中新增成员来添加新的属性和功能。可以说，这就是类在继承根底上的进化和开展。派生类的定义格式派生与继承的实例

公司人员管理系统:小型公司人员分为:经理、兼职技术人员、销售经理和兼职推销员。要求:存储所有人员的姓名、编号、级别、当月薪水，计算月薪总额并显示全部信息。派生与继承的实例人员编号在生成人员信息时同时生成，每输入一个人员信息编号顺序加1。程序能够对不同人员按不同方法提升级别，月薪的计算方法是：经理拿固定月薪;兼职技术人员按工作小时数领取月薪;兼职推销员的报酬按该推销员当月销售额提成;销售经理既拿固定月薪也领取销售提成。派生与继承的实例

分析：·描述全体职员的共性〔基类〕·描述每一类特殊人员〔派生类〕雇员技术人员经理销售人员销售经理classemployee{private: char*name; //姓名

intindividualEmpNo; //个人编号

intgrade; //级别

floataccumPay; //月薪总额

staticintemployeeNo;//本公司职员编号目前最大值public: employee(); //构造函数 ~employee(); //析构函数

voidpay(); //计算月薪函数

voidpromote(int); //升级函数

voiddisplayStatus(); //显示人员信息};

classtechnician:publicemployee //兼职技术人员类{private:

floathourlyRate;//每小时酬金

intworkHours; //当月工作时数public: technician(); //构造函数

voidpay(); //计算月薪函数

voiddisplayStatus(); //显示人员信息};新增加的成员同名覆盖，改造基类成员

派生类的成员:1.从基类继承的成员;2.改造基类成员;3.添加派生类新成员.同名覆盖派生类修改基类的成员，是在派生类中声明了一个与基类成员同名的新成员。在派生类作用域内或者在类外通过派生类的对象直接使用这个成员名，只能访问到派生类中声明的同名新成员，这个新成员覆盖了从基类继承的同名成员，这种情况称为同名覆盖。

同名覆盖#include<iostream>usingnamespacestd;classbase{public:voidfunction(){cout<<"functionofclassbase"<<endl;}};同名覆盖classderiver:publicbase{public:voidfunction(){cout<<"functionofclassderiver"<<endl;}};intmain(){deriverobj;obj.function();}基类和派生类之间的继承关系在面向对象程序中，基类的成员可以有public〔公有〕、protected〔保护〕和private〔私有〕三种访问属性。再次强调：在基类内部，自身成员可以对任何一个其它成员进行访问，但是通过基类的对象，就只能访问基类的公有成员。派生类继承了基类的全部数据成员和除了构造、析构函数之外的全部函数成员，但是这些成员的访问属性在派生的过程中是可以调整的。从基类继承的成员，其访问属性由继承方式控制。公有继承(public)基类的public和protected成员的访问属性在派生类中保持不变，但基类的private成员不可访问。派生类中的成员函数可以直接访问基类中的public和protected成员，但不能访问基类的private成员。派生类的对象只能访问基类的public成员。公有继承(public)public成员 public成员protected成员 protected成员private成员public成员protected成员private成员基类派生类#include<iostream>using

namespace

std；classA{public:voidget_XY(){cout<<"Entertwonumbersofx,y:";cin>>x>>y;}voidput_XY(){cout<<"x="<<x<<",y="<<y<<'\n';}protected:intx,y;};classB:publicA{public:intget_S(){returns;};voidmake_S(){s=x*y;}; //使用基类数据成员x，yprotected:ints;};classC:publicB{public:voidget_H(){cout<<"Enteranumberofh:";cin>>h;}intget_V(){returnv;}voidmake_V(){make_S();v=get_S()*h;} //使用基类成员函数

protected:inth,v;};#include<iostream>usingnamespacestd;classA{public:voidget_XY(){cout<<"Entertwonumbersofx,y:";cin>>x>>y;}voidput_XY(){cout<<"x="<<x<<",y="<<y<<'\n';}protected:intx,y;};classB

:publicA{public:intget_S(){returns;};voidmake_S(){s=x*y;};//使用基类数据成员x，yprotected:ints;};classC:publicB{public:voidget_H(){cout<<"Enteranumberofh:";cin>>h;}intget_V(){returnv;}voidmake_V(){make_S();v=get_S()*h;} //使用基类成员函数

protected:inth,v;};classAclassC:publicBclassB:publicA#include<iostream>usingnamespacestd;classA{public:voidget_XY(){cout<<"Entertwonumbersofx,y:";cin>>x>>y;}voidput_XY(){cout<<"x="<<x<<",y="<<y<<'\n';}

protected:intx,y;};classB:publicA{public:intget_S(){returns;};voidmake_S(){s=x*y;};//使用基类数据成员x，y

protected:ints;};classC:publicB{public:voidget_H(){cout<<"Enteranumberofh:";cin>>h;}intget_V(){returnv;}voidmake_V(){make_S();v=get_S()*h;} //使用基类成员函数

protected:inth,v;};classAclassC:publicBclassB:publicA保护数据成员在类层次中可见voidmain(){AobjA;

BobjB;

CobjC;cout<<"Itisobject_A:\n";objA.get_XY();objA.put_XY();cout<<"Itisobject_B:\n";objB.get_XY();objB.make_S();cout<<"S="<<objB.get_S()<<endl;cout<<"Itisobject_C:\n";objC.get_XY();objC.get_H();objC.make_V();cout<<"V="<<objC.get_V()<<endl;}7.2.1访问控制objA.yobjA.xobjAobjB.sobjB.yobjB.xobjBobjC.hobjC.vobjC.sobjC.yobjC.xobjCxyshvvoidmain(){AobjA;BobjB;CobjC;cout<<"Itisobject_A:\n";

objA.get_XY();objA.put_XY();cout<<"Itisobject_B:\n";objB.get_XY();objB.make_S();cout<<"S="<<objB.get_S()<<endl;cout<<"Itisobject_C:\n";objC.get_XY();objC.get_H();objC.make_V();cout<<"V="<<objC.get_V()<<endl;}对objA的数据成员操作7.2.1访问控制objA.yobjA.xobjAobjB.sobjB.yobjB.xobjBobjC.hobjC.vobjC.sobjC.yobjC.xobjCxyshvvoidmain(){AobjA;BobjB;CobjC;cout<<"Itisobject_A:\n";objA.get_XY();objA.put_XY();cout<<"Itisobject_B:\n";

objB.get_XY();objB.make_S();cout<<"S="<<objB.get_S()<<endl;cout<<"Itisobject_C:\n";objC.get_XY();objC.get_H();objC.make_V();cout<<"V="<<objC.get_V()<<endl;}调用基类A成员函数对objB的数据成员操作7.2.1访问控制objA.yobjA.xobjAobjB.sobjB.yobjB.xobjBobjC.hobjC.vobjC.sobjC.yobjC.xobjCxyshvvoidmain(){AobjA;BobjB;CobjC;cout<<"Itisobject_A:\n";objA.get_XY();objA.put_XY();cout<<"Itisobject_B:\n";objB.get_XY();

objB.make_S();cout<<"S="<<objB.get_S()<<endl;cout<<"Itisobject_C:\n";objC.get_XY();objC.get_H();objC.make_V();cout<<"V="<<objC.get_V()<<endl;}调用派生类B成员函数对objB的数据成员操作objA.yobjA.xobjAobjB.sobjB.yobjB.xobjBobjC.hobjC.vobjC.sobjC.yobjC.xobjCxyshvvoidmain(){AobjA;BobjB;CobjC;cout<<"Itisobject_A:\n";objA.get_XY();objA.put_XY();cout<<"Itisobject_B:\n";objB.get_XY();objB.make_S();cout<<"S="<<objB.get_S()<<endl;cout<<"Itisobject_C:\n";

objC.get_XY();objC.get_H();objC.make_V();cout<<"V="<<objC.get_V()<<endl;}调用基类A成员函数对objC的数据成员操作7.2.1访问控制objA.yobjA.xobjAobjB.sobjB.yobjB.xobjBobjC.hobjC.vobjC.sobjC.yobjC.xobjCxyshvvoidmain(){AobjA;BobjB;CobjC;cout<<"Itisobject_A:\n";objA.get_XY();objA.put_XY();cout<<"Itisobject_B:\n";objB.get_XY();objB.make_S();cout<<"S="<<objB.get_S()<<endl;cout<<"Itisobject_C:\n";objC.get_XY();

objC.get_H();objC.make_V();cout<<"V="<<objC.get_V()<<endl;}objA.yobjA.xobjAobjB.sobjB.yobjB.xobjBobjC.hobjC.vobjC.sobjC.yobjC.xobjC调用派生类C成员函数对objC的数据成员操作xyshv#include<iostream>usingnamespacestd;classA{public: A(){x=1;} intout(){returnx;} voidaddX(){x++;}private: intx;};classB:publicA{public: B(){y=1;} intout(){returny;} voidaddY(){y++;}private: inty;};voidmain(){Aa;Bb;b.addX();b.addY();cout<<"a.x="<<a.out()<<endl;cout<<"b.x="<<b.A::out()<<endl;cout<<"b.y="<<b.out()<<endl;}classB:publicAclassA基类的私有数据成员不能在派生类中直接访问但派生类对象建立私有数据空间

b.xa.xb.yclassBase{public:voidfoo(intf){bar=f;}//….protected:intbar;doublefoo_bar;};classDerived:publicBase{public:voidfoo(stringf){bar=f;}boolbar(Base*pb);voidfootbar();//…..protected:stringbar;};voidDerived::footbar(){bar=1024;}boolDerived::bar(Base*pb){returnfoo_bar==pb->foo_bar;}intmain(){Derivedd;d.foo(“1024”);}找出错误，并说明原因私有继承(private)基类的public和protected成员都以private身份出现在派生类中，但基类的private成员不可直接访问。派生类中的成员函数可以直接访问基类中的public和protected成员，但不能访问基类的private成员。派生类的对象不能访问基类中的任何成员。私有继承(private)public成员protected成员private成员public成员protected成员private成员基类派生类private成员private成员#include<iostream>using

namespace

std；classA{public:voidget_XY(){cout<<"Entertwonumbersofx,y:";cin>>x>>y;}voidput_XY(){cout<<"x="<<x<<",y="<<y<<'\n';}protected:intx,y;};classB:privateA{public:intget_S(){returns;};voidmake_S(){s=x*y;}; protected:ints;};classC:publicB{public:voidget_H(){cout<<"Enteranumberofh:";cin>>h;}intget_V(){returnv;}voidmake_V(){make_S();v=get_S()*h;}

protected:inth,v;};voidmain(){AobjA;BobjB;CobjC;cout<<"Itisobject_A:\n";objA.get_XY();objA.put_XY();cout<<"Itisobject_B:\n";

objB.get_XY();objB.make_S();cout<<"S="<<objB.get_S()<<endl;cout<<"Itisobject_C:\n";objC.get_XY();objC.get_H();objC.make_V();cout<<"V="<<objC.get_V()<<endl;}找出错误的地方保护继承(protected)基类的public和protected成员都以protected身份出现在派生类中，但基类的private成员不可访问。派生类中的成员函数可以直接访问基类中的public和protected成员，但不能访问基类的private成员。派生类的对象不能访问基类中的任何成员.保护继承(protected)public成员protected成员private成员public成员protected成员private成员基类派生类protected成员protected成员保护继承(protected)对建立其所在类对象的模块来说，它与private成员的性质相同。对于其派生类来说，它与public成员的性质相同。既实现了数据隐藏，又方便继承，实现代码重用。private成员和protected成员的区别无论何种继承方式，private成员是无法在派生类中被直接访问的。而对于protected成员，根据不同的派生方式，protected成员的直接访问特性可以被〔或不被〕传递到派生类的派生类中。7.2.3派生类中的静态成员

基类定义的静态成员，将被所有派生类共享.根据静态成员自身的访问特性和派生类的继承方式，在类层次体系中具有不同的访问性质.

派生类中访问静态成员，用以下形式显式说明：类名::成员或通过对象访问 对象名.成员派生类中的静态成员#include<iostream>usingnamespacestd;{public:

staticvoidAdd(){i++;}

staticinti;voidout(){cout<<"statici="<<i<<endl;}};intB::i=0;{public:voidf(){i=5;Add();B::i++;B::Add();}};voidmain(){Bx;Dy;x.Add();x.out();y.f();cout<<"statici="<<B::i<<endl;cout<<"statici="<<x.i<<endl;

//cout<<"statici="<<y.i<<endl;}静态成员函数classBclassD:privateB静态数据成员#include<iostream>usingnamespacestd;classB{public:

staticvoidAdd(){i++;}

staticinti;voidout(){cout<<"statici="<<i<<endl;}};intB::i=0;classD:privateB{public:voidf(){i=5;

Add();B::i++;B::Add();}};voidmain(){Bx;Dy;x.Add();x.out();y.f();cout<<"statici="<<B::i<<endl;cout<<"statici="<<x.i<<endl;

//cout<<"statici="<<y.i<<endl;}i是类D的私有静态数据成员类中可见Add()是类D的私有静态成员函数类中可调用#include<iostream>usingnamespacestd;classB{public:

staticvoidAdd(){i++;}

staticinti;voidout(){cout<<"statici="<<i<<endl;}};intB::i=0;classD:privateB{public:voidf(){i=5;Add();B::i++;B::Add();}};voidmain(){Bx;Dy;x.Add();x.out();y.f();cout<<"statici="<<B::i<<endl;cout<<"statici="<<x.i<<endl;cout<<"statici="<<y.i<<endl;}〔可以换成public继承〕访问B类的静态成员访问B类的静态数据成员通过B类对象访问静态数据成员派生类的构造函数与析构函数基类的构造函数不被继承，派生类中需要声明自己的构造函数。声明构造函数时，只需要对本类中新增成员进行初始化，对继承来的基类成员的初始化，自动调用基类构造函数完成。派生类的构造函数需要给基类的构造函数传递参数派生类的构造函数与析构函数析构函数也不被继承，派生类自行声明声明方法与一般〔无继承关系时〕类的析构函数相同。不需要显式地调用基类的析构函数，系统会自动隐式调用。析构函数的调用次序与构造函数相反。简单的派生类的构造函数简单的派生类只有一个基类，而且只有一级派生(只有直接派生类，没有间接派生类)，在派生类的数据成员中不包含基类的对象。

简单派生类的构造函数的一般形式为

派生类构造函数名〔总参数列表〕:基类构造函数名〔参数列表〕{派生类中新增数据成员初始化语句}【例】简单的派生类的构造函数。#include<iostream>#include<string>usingnamespacestd;classStudent//声明基类Student{public:Student(intn,stringnam,chars)//基类构造函数{num=n;name=nam;sex=s;}~Student(){}//基类析构函数protected://保护局部intnum;stringname;charsex;};classStudent1:publicStudent//声明派生类Student1{public://派生类的公用局部Student1(intn,stringnam,chars,inta,stringad):Student(n,nam,s)//派生类构造函数{age=a;//在函数体中只对派生类新增的数据成员初始化addr=ad;}voidshow(){cout<<″num:″<<num<<endl;cout<<″name:″<<name<<endl;cout<<″sex:″<<sex<<endl;cout<<″age:″<<age<<endl;cout<<″address:″<<addr<<endl<<endl;}~Student1(){}//派生类析构函数private://派生类的私有局部intage;stringaddr;};intmain(){Student1stud1(10010,″Wang-li″,′f′,19,″115BeijingRoad,Shanghai″);Student1stud2(10011,″Zhang-fun″,′m′,21,″213ShanghaiRoad,Beijing″);stud1.show();//输出第一个学生的数据

stud2.show();//输出第二个学生的数据

return0;}运行结果为num:10010name:Wang-lisex:faddress:115BeijingRoad,Shanghainum:10011name:Zhang-funsex:maddress:213ShanghaiRoad,Beijing派生类在建立对象时调用构造函数，其实参传递给形参的形式如下：派生类的构造函数也可以只在类体中声明，而在类外定义。

【例】

类内声明的形式如下：Student1(intn，stringnam，chars，inta，stringad);类外定义派生类构造函数:Student1∷Student1(intn，stringnam,chars,inta，stringad):Student(n，nam，s){age=a;addr=ad;}

注意:在类中对派生类构造函数作声明时，不包括基类构造函数名及其参数表列。只在定义函数时才将它列出。在调用派生类构造函数时，基类构造函数的实参也可以不从派生类构造函数的总参数表中传递过来，而直接使用常量或全局变量。

【例】派生类构造函数首行可写成以下形式:Student1(intn，stringnam，chars，inta，stringad):Student(10010，nam，s)派生类构造函数的定义也可以采用参数初始化表的形式。

【例】Student1(intn,stringnam,chars,inta,stringad):Student(n,nam,s),age(a),addr(ad){}在建立派生类对象时，执行构造函数的顺序是:①先调用基类构造函数；②再执行派生类构造函数本身(即派生类构造函数的函数体)。在派生类对象释放时，先执行派生类析构函数，再执行其基类析构函数。有子对象的派生类的构造函数类的数据成员中可以包含类的对象，即对象中的对象，称为子对象(subobject)。派生类构造函数的任务应该包括3个局部:①对基类数据成员初始化；②对子对象数据成员初始化；③对派生类数据成员初始化。定义有子对象的派生类构造函数的一般形式为派生类构造函数名〔总参数表列〕:基类构造函数名〔参数表列〕，子对象名(参数表列){派生类中新增数成员据成员初始化语句}【例】包含子对象的派生类的构造函数。#include<iostream>#include<string>usingnamespacestd;classStudent//声明基类{public://公用局部Student(intn,stringnam)//基类构造函数{num=n;name=nam;}voiddisplay()//成员函数，输出基类数据成员{cout<<″num:″<<num<<endl<<″name:″<<name<<endl;}protected://保护局部intnum;stringname;};classStudent1:publicStudent//声明公用派生类Student1{public:

Student1(intn,stringnam,intn1,stringnam1,inta,stringad):Student(n,nam),monitor(n1,nam1)//派生类构造函数

{age=a;addr=ad;}voidshow(){cout<<″Thisstudentis:″<<endl;display();//输出num和namecout<<″age:″<<age<<endl;//输出agecout<<″address:″<<addr<<endl<<endl;//输出addr}voidshow_monitor()//成员函数，输出子对象

{cout<<endl<<″Classmonitoris:″<<endl;monitor.display();//调用基类成员函数

}private://派生类的私有数据

Studentmonitor;//定义子对象(班长)intage;stringaddr;};intmain(){Student1stud1(10010,″Wang-li″,10001,″Li-sun″,19,″115BeijingRoad,Shanghai″);stud1.show();//输出学生的数据

stud1.show_monitor();//输出子对象的数据return0;}运行时的输出如下:

Thisstudentis:num:10010name:Wang-liage:19address:115BeijingRoad,ShanghaiClassmonitoris:num:10001name:Li-sun派生类构造函数中的基类构造函数和子对象的参数列表的次序可以是任意的，编译系统会根据参数名来确立它们的传递关系的。执行派生类构造函数的顺序是:①调用基类构造函数，对基类数据成员初始化；②调用子对象构造函数，对子对象数据成员初始化；③再执行派生类构造函数本身，对派生类数据成员初始化。多层派生时的构造函数一个类不仅可以派生出一个派生类，派生类还可以继续派生，形成派生的层次结构。【例】多级派生情况下派生类的构造函数。#include<iostream>#include<string>usingnamespacestd;classStudent//声明基类{public://公用局部Student(intn,stringnam)//基类构造函数{num=n;name=nam;}voiddisplay()//输出基类数据成员{cout<<″num:″<<num<<endl;cout<<″name:″<<name<<endl;}protected://保护局部intnum;//基类有两个数据成员stringname;};classStudent1:publicStudent//声明公用派生类Student1{public:Student1(intn,charnam[10],inta):Student(n,nam)//派生类构造函数

{age=a;}//在此处只对派生类新增的数据成员初始化

voidshow()//输出num，name和age{display();//输出num和namecout<<″age:″<<age<<endl;}private://派生类的私有数据

intage;//增加一个数据成员

};classStudent2:publicStudent1//声明间接公用派生类Student2{public:

Student2(intn,stringnam,inta,ints):Student1(n,nam,a){score=s;}voidshow_all()//输出全部数据成员{show();//输出num和namecout<<″score:″<<score<<endl;//输出age}private:intscore;//增加一个数据成员

};intmain(){Student2stud(10010,″Li″,17,89);stud.show_all();//输出学生的全部数据return0;}运行时的输出如下:

num:10010name:Liage:17score:89上例派生关系如以下图所示。在执行Student2构造函数时，先调用Student1构造函数；在执行Student1构造函数时，先调用基类Student构造函数。初始化的顺序是:①先初始化基类的数据成员num和name。②再初始化Student1的数据成员age。③最后再初始化Student2的数据成员score。派生类构造函数的特殊形式在使用派生类构造函数时，有以下特殊的形式:

①

当不需要对派生类新增的成员进行任何初始化操作时，派生类构造函数的函数体可以为空，即构造函数是空函数。此派生类构造函数的作用只是为了将参数传递给基类构造函数和子对象，并在执行派生类构造函数时调用基类构造函数和子对象构造函数。classApublic:{public:B(intx):A(x){}A(intx){n=x;}};private:intn;};ClassB:publicA{

②

如果在基类中没有定义构造函数，或定义了没有参数的构造函数，那么在定义派生类构造函数时可不写基类构造函数。调用派生类构造函数时系统会自动首先调用基类的默认构造函数。classApublic:{public:B(inty1){y=y1;}A(intx=0){n=x;}private:private:inty;};intn;};ClassB:publicA{如果在基类中既定义无参的构造函数，又定义了有参的构造函数，那么在定义派生类构造函数时，既可以包含基类构造函数及其参数，也可以不包含基类构造函数。在调用派生类构造函数时，根据构造函数的内容决定调用基类的有参的构造函数还是无参的构造函数。#include<iostream>usingnamespacestd;classBASE{public:BASE(){cout<<"\nConstructBASE!";}~BASE(){cout<<"\nDestructBASE!";}};

classDERIVE:publicBASE{public:DERIVE(){cout<<"\nConstructDERIVE!";}~DERIVE(){cout<<"\nDestructDERIVE!";}//private://BASEderive_base;};voidmain(){BASEbase;DERIVEderive;}多继承class<派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…{//以下定义派生类新成员private://私有成员说明

...public://公有成员说明

...protected://保护成员说明

...};多个基类派生一个类多继承Circle类Point类

Radius类

组合例:

先定义“点”类Point和“半径”类Radius，再由Point类和Radius类多重派生出“圆”类Circle。#include<iostream>usingnamespacestd;#definePI3.14159classPoint{protected:

//A intx,y;public: Point(inta=0,intb=0){x=a;y=b;} voidShowPoint(){cout<<"Point:("<<x<<','<<y<<")\n";} intGetx(){returnx;} intGety(){returny;} voidSetxy(inta,intb){x=a;y=b;}};classRadius{protected:

//B intr;public: Radius(intra=0){r=ra;} voidSetr(intra){r=ra;} intGetr() {returnr;}};classCircle:publicPoint,publicRadius

//C{public: Circle(intx,inty,intra):Point(x,y),Radius(ra)

//D {} doubleArea() {returnPI*r*r;}//直接访问基类的保护成员

voidMove(intx_offset,inty_offset) {x+=x_offset;y+=y_offset;}

voidShowCircle() { ShowPoint(); cout<<"Radius:"<<r<<'\t'; cout<<"Area:"<<Area()<<endl; }};voidmain(){ Circlec(1,1,1); c.ShowCircle(); c.Move(1,2); c.ShowCircle(); c.Setxy(4,5); c.Setr(2); c.ShowCircle();}多继承说明：构造函数调用的顺序是先执行基类的构造函数，再执行派生类自己的构造函数的函数体。析构函数顺序和构造函数调用顺序相反调用基类的构造函数的顺序并不是D行的书写顺序决定的，而是C行定义派生类时的派生顺序决定的，即使将D行改写成Circle(intx,inty,intra):Radius(ra),Point(x,y)，程序的运行结果依然不变。

一般地，派生类成员的访问是唯一的。但是在多继承的情况下，可能出现派生类对其类成员访问的不唯一性，即二义性。下面是出现二义性的两种情况：1、调用不同类的具有相同名字成员时可能出现二义性，例如：

#include<iostream> usingnamespacestd;classA{public:voidf();};