继承

继承，非常nice，让我们来看一下

一、什么是继承        

继承就是在已有类的基础上创建新类的过程一个B类继承 A类，或称从类A派生类B，A称为基类，B称为派生类。

语法形式如下：

  class 派生类名: 基类名表

   {

        数据成员和成员函数声明

   };

基类名表 构成

  访问控制  基类名 1 ， 访问控制   基类名 2 ， … ，访问控制   基类名 n

注意不论种方式继承基类，派生类都不能直接使用基类的私有成员

派生类的生成过程经历了三个步骤：

        1.吸收基类成员（全部吸收 ( 构造、析构除外 ), 但不一定可见 ）

        在C++的继承机制中，派生类吸收基类中除构造函数和析构函数之外的全部成员。

         2. 改造 基类成员

         通过在派生类中定义同名成员（包括成员函数和数据成员）来屏蔽（隐藏）在派生类中不起作用的部分基类成员。

         3.添加派生类新成员

         仅仅继承基类的成员是不够的，需要在派生类中添加新成员，以保证派生类自身特殊属性和行为的实现。

结构如下

        

接下来引用一段代码来详细的表示一下引用过程：

#include<iostream>
using namespace std ;
class A
{ public :
      void  get_XY()   { cout << "Enter two numbers of x, y : " ;  cin >> x >> y ; }
      void  put_XY()    { cout << "x = "<< x << ", y = " << y << '\n' ; }
   protected:    int x, y ;
};
class B : public A
{ public :
      int  get_S() { return s ; };
      void  make_S()  { s = x * y ; };    	// 使用基类数据成员x，y
   protected:   int s;
};
class C : public B
{ public : 
      void  get_H()   { cout << "Enter a number of h : " ;  cin >> h ; } 
      int  get_V() { return v ; }
      void  make_V()  { make_S(); v = get_S() * h ; } 	// 使用基类成员函数
   protected:    int h, v;
};

int main()
{ A objA ;
   B objB ;
   C objC ;
   cout << "It is object_A :\n" ;
   objA.get_XY() ;
   objA.put_XY() ;
   cout << "It is object_B :\n" ;
   objB.get_XY() ;
   objB.make_S() ;
   cout << "S = " << objB.get_S() << endl ;
   cout << "It is object_C :\n" ;
   objC.get_XY() ;
   objC.get_H();
   objC.make_V() ;
   cout << "V = " << objC.get_V() << endl ;
}

运行结果如下：

二、其他问题

1.重名成员

派生类定义了与基类同名的成员，在派生类中访问同名成员时屏蔽了基类的同名成员在派生类中使用基类的同名成员，显式地使用类名限定符：    类名 :: 成员

2.静态成员

派生类中访问静态成员，用以下形式显式说明：

  类名 :: 成员      或通过对象访问  对象名 . 成员

三、基类的初始化

在创建派生类对象时用指定参数调用基类的构造函数来初始化派生类继承基类的数据

派生类构造函数声明为

派生类构造函数 ( 变元表 ): 基类 ( 变元表 ), 对象成员1(变元表 )

   … 对象成员n ( 变元表 )；

 构造函数执行顺序：基类、对象成员、派生类

调用构造函数顺序测试，构造函数无参数

#include<iostream>
using namespace std ;
class  Base
  { public :  Base ( ) { cout << "Base created.\n" ;  }
  } ;
class  D_class : public  Base
  { public :  D_class ( ) { cout << "D_class created.\n" ;  }
  } ;
int main ( )
{ D_class d1 ; }

四、派生类构造函数和析构函数的定义规则 

   （一） 派生类构造函数和析构函数的使用原则

    1. 基类的构造函数和析构函数不能被继承

    2.如果基类没有定义构造函数或有无参的构造函数，派生类也可以不用定义构造函数

    3.如果基类无无参的构造函数，派生类必须定义构造函数

    4.如果派生类的基类也是派生类，则每个派生类只负责直接基类的构造

    5.派生类是否定义析构函数与所属的基类无关

   （二）派生类的构造函数的定义 

派生类的数据成员既包括基类的数据成员，也包括派生类新增数据成员。

在C++中,派生类构造函数的一般格式为:

      派生类::派生类名(参数总表):基类名(参数表)

   {

             // 派生类新增成员的初始化语句

   }

     注意：这是基类有构造函数且含有参数时使用

        （三）派生类析构函数 

（1 ）当派生类中不含对象成员时

在创建派生类对象时, 构造函数的执行顺序是：基类的构造函数→派生类的构造函数；

在撤消派生类对象时, 析构函数的执行顺序是：派生类的析构函数→基类的析构函数。

（2 ）当派生类中含有对象成员时

在定义派生类对象时，构造函数的执行顺序：基类的构造函数→对象成员的构造函数→派生类的构造函数；

在撤消派生类对象时，析构函数的执行顺序：派生类的析构函数→对象成员的析构函数→基类的析构函数

class B
{
public:
    B() { cout<<"B()"<<endl; }
    ~B() { cout<<"~B()"<<endl; }
};
class D : public B
{
public:
    D(){ cout<<"D()"<<endl; }
    ~D() { cout<<"~D()"<<endl; }
};
int main()
{
    D d;
    return 0;
}

即先调用D的析构函数，再调用B的析构函数

例题：考察一个点、圆、圆柱体的层次结构 

class Point
{   friend ostream &operator<< (ostream &, const Point &);
  public:
    Point( int = 0, int = 0 ) ;	// 带默认参数的构造函数
    void setPoint( int, int ) ;	// 对点坐标数据赋值
    int getX() const { return x ; }	    int getY() const { return y ; }
  protected:    int x, y;	// Point类的数据成员
};
class Circle : public Point
{   friend ostream &operator<< (ostream &, const Circle &);	// 友元函数
  public:
    Circle(double r=0.0, int x=0, int y=0);	// 构造函数
    void setRadius(double);  /*置半径*/          double getRadius() const;     /*返回半径*/ 
    double area() const;		// 返回面积
  protected:    double radius;	// 数据成员，半径
};
class Cylinder:public Circle
{    friend ostream & operator<<(ostream &, const Cylinder &);    // 友元函数
   public:
     Cylinder(double h=0.0, double r=0.0, int x=0, int y=0);      // 构造函数
     void setHeight(double);    /* 置高度值*/           double getHeight() const;	    /* 返回高度值*/
     double area() const;	     /* 返回面积*/            double volume() const;	    /* 返回体积*/
   protected:     double height;	// 数据成员，高度
};

五、多继承

一个类有多个直接基类的继承关系称为多继承 多继承声明语法如下：

class  派生类名: 访问控制  基类名1,  访问控制  基类名2,  … , 访问控制  基类名n

    {

         数据成员和成员函数声明

    }；

（一）多继承的派生类构造和访问

1、多个基类的派生类构造函数可以用初始式调用基类构造函数初始化数据成员。

2、执行顺序与单继承构造函数情况类似。多个直接基类构造函数执行顺序取决于定义派生类时指定的各个继承基类的顺序。

3、 一个派生类对象拥有多个直接或间接基类的成员。不同名成员访问不会出现二义性。如果不同的基类有同名成员，派生类对象访问时应该加以识别。

 （二）多继承的构造函数

派生类名(参数总表):基类名1(参数表1),基类名2(参数表2),…,基类名n(参数表n)

   {

           // 派生类新增成员的初始化语句

    }

 （三）多继承方式下构造函数的执行顺序：

多继承方式下构造函数的执行顺序：

先执行所有基类的构造函数

再执行对象成员的构造函数

最后执行派生类的构造函数

处于同一层次的各基类构造函数的执行顺序取决于定义派生类时所指定的基类顺序

与派生类构造函数中所定义的成员初始化列表顺序没有关系。

内嵌对象成员的构造函数执行顺序与对象在派生类中声明的顺序一致

六、赋值兼容规则 

（一）赋值兼容规则指在程序中需要使用基类对象的任何地方，都可以用公有派生类的对象来替代。

赋值兼容规则中所指的替代包括以下的情况：

 a派生类的对象可以赋给基类对象

 b派生类的对象可以初始化基类的引用

 c派生类的对象的地址可以赋给基类类型的指针

（二）赋值兼容的可行性

通过公有继承，

  派生类得到了除了构造、析构函数以外的所有成员

  且这些成员的访问控制属性也和基类完全相同。

  这样，它便具备了基类的所有功能。

利用赋值兼容规则

  派生类的对象可以赋给基类对象(强制类型转换)

  派生类的对象可以初始化基类的引用

  派生类的对象的地址可以赋给基类类型的指针

根据赋值兼容规则, 以下几种情况是合法的: 

(1) 可以用派生类对象给基类对象赋值。例如:

      Base b;

      Derived d;

      b=d;

         这样赋值的效果是, 对象 b 中所有数据成员都将具有对象d 中对应数据成员的值。

(2) 可以用派生类对象来初始化基类的引用。例如:

     Derived d;

     Base &br=d;

(3) 可以把派生类对象的地址赋值给指向基类的指针。例如:

   Derived d;

   Base *bptr=&d;

         这种形式的转换,是在实际应用程序中最常见到的。

(4) 可以把指向派生类对象的指针赋值给指向基类对象的指针。例如:

    Derived *dptr,obj; dptr=&obj;

    Base *bptr=dptr;

（三）赋值兼容应注意的问题

（1）声明为指向基类的指针可以指向它的公有派生类的对象，但不允许指向它的私有派生类的对象。例如：

   class B  {…}；

   class D：privateB {…}；

   B b1，*pbl；D d1；

    pb1=&b1;        //合法，基类B的对象b1和B类的指针

      pb1=&d1;        //非法，不允许将基类指针指向它的私有派生类对象

（2）允许将一个声明为指向基类的指针指向其公有派生类对象，但是不能将一个声明为指向派生类对象的指针指向其基类的一个对象。

  (3) 声明为指向基类对象的指针，当其指向公有派生类对象时，只能用它来直接访问派生类中从基类继承来的成员，而不能直接访问公有派生类的定义的成员。

七、心得体会

        继承确实是一个比较实用的模块。在已有类的基础上创建新类的过程一个B类继承A类，或称从类A派生类B，A称为基类，B称为派生类，确实能在写代码的过程中省下不少功夫，比如用户类中有管理类的部分操作，就完全可以使用继承来减少工作量。学习到现在的过程中，渐渐掌握了更多新的，方便的知识，能够使自己的代码更优化，继承就是其中之一。不仅减少了代码长度，减少了工作量，而且代码更条理了，是挺好用的技能。