C++中的继承

继承的目的：实现代码重用。继承为软件的层次化开发提供了保证。

一、继承方式

三种继承方式：公有继承public（原封不动），保护继承protect（折中），私有继承private（化公为私）。无论派生列表中是什么访问标号，所有继承Base的类对Base中的成员具有相同的访问权限。派生标号将控制派生类的用户对从Base继承而来的成员的访问。

举例如下：

class A
{
public:
 A(int ival):i(ival)
 {

 }
 int i;
private:
 int j;
};

class B : private A
{
public:
 B():A(3)
 {
 }
 void print()
 {
  cout<<i<<"/t"<<endl;
 }

};

我们来分析一下派生类B中对基类A中的数据成员的访问权限。对于A中i是public,则允许其他所有外部类（包括派生类）对其访问，所以可以在B中直接访问A中i成员；j 是private,则在B中无法直接访问，一般的设计是A提供访问j的接口，由外部调用。以上讨论的是B中对A的数据成员的访问权限，这与private继承还是public继承无关，继承的方式仅影响外界通过B来访问A的权限。比如本例中是private继承，则用B实例一个对象b,b.i是非法的，不能访问A中的i成员，因为是private继承，相当于将A的数据成员都加入了B的private域中，这样b.i就不可以直接访问了。同理对于public,protect.

二、“打捞”成员

那如果访问b.i呢？有两种方法，一是提供外部接口（这里不多说了），另一种是“打捞”，即使用using关键字。

使用方法如下：

class B : private A
{
public:
 using A::i;
 B():A(3)
 {
 }
 void print()
 {
  cout<<i<<"/t"<<endl;
 }

};

void main()  
{  
 B b;
 cout<<b.i<<endl;
}

使用using后，可以直接访问b.i了，不过using的使用有几点注意：

1，不能区分重载；

即如果打捞的是函数，则打捞所有重载的函数。

比如：

class A
{
public:
 A(int ival):i(ival)
 {

 }
 void f(int a,int b){}
 void f(float a,float b){}
 int i;
private:
 int j;
};

class B : private A
{
public:
 using A::f;//将打捞所有名为f的函数
 B():A(3)
 {
 }
 void print()
 {
  cout<<i<<"/t"<<endl;
 }

};

void main()  
{  
 B b;
 b.f(2,3);  //调用f(int,int)

 b.f(2.0,3.0); //调用f(float,float)
}  

using A::f;将打捞所有名为f的函数；不仅意味着不能区分重载，如果名为f的函数不在一个访问域内，则调用出错：

如：

class A
{
public:
 A(int ival):i(ival)
 {

 }
 void f(int a,int b){}
 void f(float a,float b){}
 int i;
private:
 void f(int,float){}
 int j;
};

由于接下的第二条性质：不能提高访问级别，即第三个f打捞以后依然是私有的，B的实例化对象不能直接访问，所以会出错

2，只能还原，不能提高访问级别；

即原来为保护或者私有的访问级别，在打捞以后只能回复原来的访问权限。
3，只能还原直接基类，不能“隔代”打捞；
4，不能让子类孙类重复打。