C++特性之继承性--《C++ primer》



继承性：" 继承 "是面向对象软件技术当中的一个概念,是类间的一种基本关系,是基于层次关系的不同类共享数据和操作的一种机制。父类定义了其所有子类的公共属性和操作,在子类中除了定义自己特有的属性和操作外,还可以对父类（或祖先类）中的操作重新定义其实现方法,即重载.

继承可以使得子类具有父类的各种属性和方法,而不需要再次编写相同的代码。在令子类继承父类的同时,可以重新定义某些属性,并重写某些方法,即覆盖父类的原有属性和方法,使其获得与父类不同的功能.  继承是指一个对象直接使用另一对象的属性和方法.事实上,我们现实中遇到的很多实体都有继承的含义.例如,若把汽车看成一个实体,它可以分成多个子实体,如:卡车、公共汽车等.这些子实体都具有汽车的特性,因此,汽车是它们的"父亲",而这些子实体则是汽车的"孩子".

继承有三种继承方式:

（1）公有继承：基类成员保持自己的访问级别：基类的public成员在派生类中还是public，基类的protected成员在派生类中还是protected。

在基类中的访问权限	在派生类中的访问权限
private	不可直接访问
public	public
protected	protected

对于公有继承方式,基类成员对其对象的可见性与一般类及其对象的可见性相同,公有成员可见,其他成员不可见.这里保护成员与私有成员相同.基类成员对派生类的可见性对派生类来说,基类的公有成员和保护成员可见,基类的公有成员和保护成员作为派生类的成员时，它们都保持原有的状态;基类的私有成员不可见,基类的私有成员仍然是私有的，派生类不可访问基类中的私有成员.基类成员对派生类对象的可见性对派生类对象来说,基类的公有成员是可见的,其他成员是不可见. 所以,在公有继承时,派生类的对象可以访问基类中的公有成员,派生类的成员函数可以访问基类中的公有成员和保护成员.

（2）受保护继承：基类的public和protected成员在派生类中成为protected成员。

在基类中的访问权限	在派生类中的访问权限
private	不可直接访问
public	protected
protected	protected

对于保护继承方式,这种继承方式与私有继承方式的情况相同,两者的区别仅在于对派生类的成员而言,基类成员对其对象的可见性与一般类及其对象的可见性相同,公有成员可见,其他成员不可见. 基类成员对派生类的可见性对派生类来说,基类的公有成员和保护成员是可见的,基类的公有成员和保护成员都作为派生类的保护成员,并且不能被这个派生类的子类所访问;基类的私有成员是不可见的,派生类不可访问基类中的私有成员.基类成员对派生类对象的可见性对派生类对象来说,基类的所有成员都是不可见的.所以,在保护继承时,基类的成员也只能由直接派生类访问,而无法再往下继承.

（3）私有继承：基类的所有成员在派生类中成为private成员。

在基类中的访问权限	在派生类中的访问权限
private	不可直接访问
public	private
protected	private

对于私有继承方式,基类成员对其对象的可见性与一般类及其对象的可见性相同,公有成员可见,其他成员不可见.基类成员对派生类的可见性对派生类来说,基类的公有成员和保护成员是可见的,基类的公有成员和保护成员都作为派生类的私有成员，并且不能被这个派生类的子类所访问;基类的私有成员是不可见的,派生类不可访问基类中的私有成员.基类成员对派生类对象的可见性对派生类对象来说,基类的所有成员都是不可见的. 所以,在私有继承时,基类的成员只能由直接派生类访问,而无法再往下继承.

对于C++三大特性之一的继承机制，要想理解好它，需要多敲一些小程序练习观察总结，下面是一个多继承的例子，涉及到的知识点较多，可以比较学习。

#include <iostream>   
using namespace std;   
    
class A 
{   
  public:   
     A() 
     {   
         cout<<"int A::A()"<<endl;   
     }   
     A(A &a) 
     {   
         cout<<"int A::A(A &a)"<<endl;   
     }   
     A& operator=(A& a) 
     {   
         cout<<"int A::operator=(A &a)"<<endl;   
         return a;   
     }   
     virtual ~A() 
     {   
         cout<<"int A::~A()"<<endl;   
     }   
};  
 
class M :public A 
{   
   public:   
       M() 
       {   
           cout<<"int M::M()"<<endl;   
       }   
       M(M &a) 
       {   
           cout<<"int M::M(M &a)"<<endl;   
       }   
       M& operator=(M& m) 
       {   
            cout<<"int M::operator=(M &a)"<<endl;   
            return m;   
        }   
        virtual ~M() 
        {   
             cout<<"int M::~M()"<<endl;   
        }   
};  

class B:virtual public M
{  
   public:  
        B() 
        {   
            cout<<"int B::B()"<<endl;
        }   
        B(B &a) 
        {   
            cout<<"int B::B(B &a)"<<endl;  
        }   
        B& operator=(B& b) 
        {   
            cout<<"int B::operator=(B &a)"<<endl;   
            return b;
         }   
         virtual ~B() 
         {   
             cout<<"int B::~B()"<<endl;
         }  
};   
    
class N :public A 
{  
  public:
       N() 
       {   
           cout<<"int N::N()"<<endl;   
       }   
       N(N &a) 
       {   
           cout<<"int N::N(N &a)"<<endl;
       }   
       N& operator=(N& n) 
       {   
           cout<<"int N::operator=(N &a)"<<endl;  
           return n;   
       }   
       virtual ~N() 
       {   
           cout<<"int N::~N()"<<endl;   
       }   
};   


class C:virtual public N 
{
   public:
        C() 
        {   
            cout<<"int C::C()"<<endl;
        }   
        C(C &a) 
        {   
             cout<<"int C::C(C &a)"<<endl;
        }   
        C& operator=(C& c) 
        {   
             cout<<"int C::operator=(C &a)"<<endl;
             return c;   
         }   
        virtual ~C() 
        {   
             cout<<"int C::~C()"<<endl;
        }   
};   

class E:virtual public M
{   
     public:
          E() 
          {   
              cout<<"int E::E()"<<endl;
          }   
          E(E &a) 
          {   
              cout<<"int E::E(E &a)"<<endl;  
          }   
          E& operator=(E& e) 
          {   
              cout<<"int E::operator=(E &a)"<<endl;
              return e;  
          }   
          virtual ~E() 
          {    
               cout<<"int E::~E()"<<endl;
          }   
};   

class D:public B, public C, public E 
{   
    public:
        D() 
        {   
            cout<<"int D::D()"<<endl;
        }   
        D(D &a) 
        {   
            cout<<"int D::D(D &a)"<<endl;
        }   
        D& operator=(D& d) 
        {   
            cout<<"int D::operator=(D &a)"<<endl;
            return d;
        }   
        virtual ~D() 
        {   
            cout<<"int D::~D()"<<endl;
        }  
};  
  
int main(int argc, char *argv[]) 
{   
      cout<<"-------构造函数-------"<<endl;   
      D d;   
      cout<<"-------复制构造函数-------"<<endl;   
      D d1(d);   
      cout<<"-------赋值操作符-------"<<endl;
      d = d1;   
      cout<<"-------析构函数-------"<<endl;
   return 0;
}