C++中三种继承方式(转)

public      公有继承
protected  保护继承
private    私有继承

    我们知道类的private和protected成员，在类外是不可以使用的，只有public成员可以在类外直接使用。

    公有继承时，基类的private成员派生类也不可用，基类的public和protected成员在派生类中可直接使用。继承过来（变成派生类相应的public和protected成员）只有public成员在派生类外可以直接使用。

    保护继承时，基类的private成员仍为有私有，基类的public和protected成员变成派生类的protected成员，这时在派生类外也不能直接使用原基类的public成员。

    私有继承时，基类的private成员仍为有私有，基类的public和protected成员将变成派生类的private成员。

举个例子：

class A
{
  public:
    int m_public;
  protected:
    int m_protected;
  private:
    int m_private;
};

class B :public A
{
   void SetPublic(int nPublic)
   {
       m_public = nPublic;
   }
   void SetProtected(int nProtected)
   {
       m_protected = nProtected;
   }
   void SetPrivate(int nPrivate)
   {
       m_private = nPrivate;       //错误，因为基类的private成员不能用
   }
};

B b;                  //创建B类的对象c
b.m_public = 100;     //正确
b.m_protected = 100;  //错误，public继承中基类的protected在派生类中是protected
b.m_private = 100;    //错误，在派生类中都不可以直接使用，在类外就更不能了


class C :protected A
{
   void SetPublic(int nPublic)
   {
       m_public = nPublic;
   }
   void SetProtected(int nProtected)
   {
       m_protected = nProtected;
   }
   void SetPrivate(int nPrivate)
   {
       m_private = nPrivate;       //错误，因为基类的private成员不能用
   }
};

C c;                  //创建C类的对象c
c.m_public = 100;     //错误，protected继承C类里变成了protected成员
c.m_protected = 100;  //错误，protected继承C类里还是protected成员
c.m_private = 100;    //错误，在派生类中都不可以直接使用，在类外就更不能了


class D :private A
{
   void SetPublic(int nPublic)
   {
       m_public = nPublic;
   }
   void SetProtected(int nProtected)
   {
       m_protected = nProtected;
   }
   void SetPrivate(int nPrivate)
   {
       m_private = nPrivate;       //错误，因为基类的private成员不能用
   }
};

D d;                  //创建D类的对象d
d.m_public = 100;     //错误，private继承D类里变成了private成员
d.m_protected = 100;  //错误，private继承D类里变成了private成员
d.m_private = 100;    //错误，在派生类中都不可以直接使用，在类外就更不能了

    从例子来看，三种继承从派生类内部引用来看好像没有区别，只在类外引用时表现不同。现在还看不出public和protected继承的区别

那再看一个例子：
class E :public B
{
   void SetPublic(int nPublic)
   {
      m_public = nPublic;        //正确  因为这是B类的公有成员
   }
   void SetProtected(int nProtected)
   {
      m_protected = nProtected;  //正确  因为这是B类的保护成员，现成变成E类的protected成员
   }
   void SetPrivate(int nPrivate)
   {
      m_private = nPrivate;      //错误，因为基类的private成员不能用
   }
};
E e;                  //创建E类的对象e
e.m_public = 100;     //正确
e.m_protected = 100;  //错误，protected继承E类里变成了protected成员
e.m_private = 100;    //错误，在派生类中都不可以直接使用，在类外就更不能了

class F  :public C
{   
   void SetPublic(int nPublic)
   {
      m_public = nPublic;         //正确 因为这是C类的protected成员
   }
   void SetProtected(int nProtected)
   {
      m_protected = nProtected;   //正确 因为这是C类的protected成员，现成变成F类的protected成员
   }
   void SetPrivate(int nPrivate)
   {
      m_private = nPrivate;       //错误，因为基类的private成员不能用
   }
};
F f;                  //创建F类的对象f
f.m_public = 100;     //错误，在C类里就已变成protected成员
f.m_protected = 100;  //错误，protected继承E类里变成了protected成员
f.m_private = 100;    //错误，在派生类中都不可以直接使用，在类外就更不能了

class G  :public D
{
   void SetPublic(int nPublic)
   {
      m_public = nPublic;         //错误 因为这是D类的private成员
   }
   void SetProtected(int nProtected)
   {
      m_protected = nProtected;   //错误 因为这是D类的private成员
   }
   void SetPrivate(int nPrivate)
   {
      m_private = nPrivate;       //错误，因为基类的private成员不能用
   }
};
//那G在类外就没有了可以引用的继承过来成员了