- 引言
C++是面向对象的程序设计语言，是一种由实际问题抽象的类所定义的对象来进行程序编写的计算机语言。对象是类的实例化，因此，类功能的延展性、类代码的可重用性（即：类的继承性）就成为C++面向对象程序语言的重要优越性之一。本篇是按功能应用分类，而非通常的概念性分类，并给予实例说明。
- 分类
单继承： class A；
class B:继承类型 A ；
多继承： class A； class B； class C；
class D:继承类型 A,继承类型 B,继承类型 C ；
多层继承： class A；
class B:继承类型 A ；
class C:继承类型 B ；
多层多继承： class A；
class B:继承类型 A ； class C:继承类型 A ；
class D:继承类型 B,继承类型 C；
- 实例说明
单继承： 单继承较简单，且在后面的多继承、多层继承都要用到，因此，此处实例略。
多继承：
#include<iostream.h>
class A
{
public:
A(int i){cout<<" Construct A "<<i<<endl;}
~A(){cout<<" Destruct........A "<<endl;}
};
class B
{
public:
B(int i){cout<<" Construct B "<<i<<endl;}
~B(){cout<<" Destruct........B "<<endl;}
};
class C
{
public:
C(){cout<<" Construct C * "<<endl;}
~C(){cout<<" Destruct........C * "<<endl;}
};
class D:public B,protected A,private C
{
public:
D(int a,int b,int c,int d):A(a),memberB(d),memberA(c),B(b){}
private:
A memberA;
B memberB;
C memberC;
};
void main()
{ D obj(1,2,3,4);}
运行结果： Construct B 2 Destruct........C *
Construct A 1 Destruct........B
Construct C * Destruct........A
Construct A 3 Destruct........C *
Construct B 4 Destruct........A
Construct C * Destruct........B
多层继承：
#include<iostream.h>
class A
{
public:
A()
{x=5;}
f1()
{cout<<"Class A f1() output X: "<<x<<endl;}
protected:
f2()
{cout<<"Class A f2() output X: "<<x<<endl;}
private:
int x;
};
class B:protected A
{
public:
B():A(){y=10;}
f3()//子类成员函数可以对父类中的公有和保护成员进行访问
{cout<<"Class B f3()............"<<endl;
f1();
f2();}
//f4()//子类成员函数可以对父类中的私有成员进行访问
//{x=10;}
protected:
f4()//子类成员函数可以对父类中的公有和保护成员进行访问
{cout<<"Class B f4()............"<<endl;
f1();
f2();}
private:
f5()//子类成员函数可以对父类中的公有和保护成员进行访问
{cout<<"Class B f5()............"<<endl;
f1();
f2();}
int y;
};
class C:private B
{public:
f6()
{cout<<"Class C f6()....................."<<endl;
f1();
f2();}
f7()
{cout<<"Class C f7()...................."<<endl;
f3();}
f8()
{cout<<"Class C f8()...................."<<endl;
f4();}
};
void main()
{
A a;
cout<<"对Class A 对象函数进行调用****************"<<endl;
a.f1();//共有成员是对象对外的唯一接口
// a.f2();//对象对保护成员不能访问
// a.x; //对象对私有成员不能访问
cout<<"对Class B 对象函数进行调用****************"<<endl;
B b;
// b.f1();//当B对A公有继承时，此句可行；否则不可行
b.f3();
cout<<"对Class C 对象函数进行调用****************"<<endl;
C c;
c.f6();
c.f7();
c.f8();
}
运行结果： 对Class A 对象函数进行调用****************
Class A f1() output X: 5
对Class B 对象函数进行调用****************
Class B f3()............
Class A f1() output X: 5
Class A f2() output X: 5
对Class C 对象函数进行调用****************
Class C f6().....................
Class A f1() output X: 5
Class A f2() output X: 5
Class C f7().....................
Class B f3()............
Class A f1() output X: 5
Class A f2() output X: 5
Class C f7().....................
Class B f4()............
Class A f1() output X: 5
Class A f2() output X: 5
多层多继承：是有关virtual函数的多态性问题，因此将在下一主题<多态性>中给予详细
说明。
- 注意事项
- 子类成员、子类的对象对父类的私有成员（private）都不可访问。
- 在公有继承（public）中，父类中的公有成员（public）和保护成员（protected）的属性不变。
- 在保护继承（protected）中，父类中的公有成员（public）和保护成员（protected）的属性均为子类中保护成员（protected）。保护成员（protected）即实现对于对象的数据数据隐藏，又能方便继承。
- 在私有继承（private）中，父类中的公有成员（public）和保护成员（protected）的属性均为子类中私有成员（private）。
- 在类的多继承中，子类构造函数的声明形式：
子类名::子类名（基类A形参，基类B形参，基类C形参，....，本类参数）：基类A（形参），基类B（形参），基类C（形参），....，对象数据成员的初始化{}；
调用基类构造函数，调用顺序是按照它们被继承是声明的顺序（从左到右）；调用成员对象的构造函数，调用顺序按照它们在类中声明的顺序。析构相反！如上述实例一所示。
- 继承具有传递性。如上述实例二所示。
