类的继承与派生

• 继承(inheritance)机制是面向对象程序设计中使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能。这样产生的新类，称派生类（或子类），被继承的类称基类（或父类）。

  继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。之前接触的复用都是函数复用，继承是类设计层次的复用。 继承与派生是同一过程从不同的角度来看保持已有类的特性而构造新类的过程称为继承。 在已有类的基础上新增自己的特性而产生新类的过程称为派生。

  直接参与派生出某类的基类称为直接基类，基类的基类甚至更高层的基类称为间接基类。

  单继承时class 派生类名：继承方式  基类名{    
  成员声明；
  }；
  例如：
  class Derived: public Base{
  public:	
  Derived ();	
  ~Derived ();
  };
  

  多继承时class 派生类名：继承方式1  基类名1，继承方式2  基类名2，...{	
  成员声明；
  }；
  例如：
  class Derived: public Base1, private Base2{
  public:	
  Derived ();	
  ~Derived ();
  };
  

  如果没有注明继承方式，编译器默认为私有继承；继承方式规定了如何访问从基类中继承的成员；每一个“继承方式”，只用于限制对紧随其后之基类的继承。

  • 派生类生成过程

    吸收基类成员 吸收基类成员之后，派生类实际上就包含了它的全部基类中除构造和析构函数之外的所有成员。 改造基类成员 如果派生类声明了一个和某基类成员同名的新成员，派生的新成员就隐藏或覆盖了基类的同名成员。（同名隐藏） 添加新的成员 派生类新成员的加入是继承与派生机制的核心，是保证派生类在功能上有所发展

• 访问控制

  不同继承方式的影响主要体现在： （1）派生类成员对基类成员的访问权限； （2）通过派生类对象对基类成员的访问权限；

  • 三种继承方式：公有继承、私有继承、保护继承；

    • 公有继承： （1）基类的public和protected成员的访问属性在派生类中保持不变，但基类的private成员不可直接访问。类中的成员函数可以直接访问基类中的public和protected成员，但不能直接访问基类的private成员。 （2）派生类中的成员函数可以直接访问基类中的public和protected成员，但不能直接访问基类的private成员。 （3）通过派生类的对象只能访问基类的public成员。

      //Point.h//公有继承举例
      #ifndef _POINT_H
      #define _POINT_H
      class Point {	
      //基类Point类的定义
      public:		//公有函数成员
      void initPoint(float x = 0, float y = 0)  { this->x = x; this->y = y;}	
      void move(float offX, float offY)  { x += offX; y += offY; }	
      float getX() const { return x; }	
      float getY() const { return y; }
      private:		//私有数据成员	
      float x, y;
      };
      #endif //_POINT_H
      

      //Rectangle.h
      #ifndef _RECTANGLE_H
      #define _RECTANGLE_H
      #include "Point.h"
      class Rectangle: public Point {	
      //派生类定义部分，公有继承
      public:	//新增公有函数成员	
      void initRectangle(float x, float y, float w, float h) {
      		initPoint(x, y); //调用基类公有成员函数		
      		this->w = w;		this->h = h;	
      		}	
      float getH() const { return h; }	
      float getW() const { return w; }
      private:	//新增私有数据成员	
      float w, h;
      };
      #endif //_RECTANGLE_H
      

      #include “Rectangle.h”
      #include <iostream>
      #include <cmath>
      using namespace std;
      int main() {	
      Rectangle rect;	//定义Rectangle类的对象	
      //设置矩形的数据	
      rect.initRectangle(2, 3, 20, 10);		
      rect.move(3,2);	//移动矩形位置	
      cout << "The data of rect(x,y,w,h): " << endl;	//输出矩形的特征参数	
      cout << rect.getX() <<", "		<< rect.getY() << ", "		<< rect.getW() << ", "		<< rect.getH() << endl;	
      return 0;
      }
      

    • 私有继承： （1）CPP的默认继承方式（在不标注的情况下默认为私有继承）。 （2）基类的public和protected成员都以private身份出现在派生类中，但基类的private成员不可直接访问。 （3）派生类中的成员函数可以直接访问基类中的public和protected成员，但不能直接访问基类的private成员。 （4）通过派生类的对象不能直接访问基类中的任何成员。

      point.h文件同上
      

      //Rectangle.h
      #ifndef _RECTANGLE_H
      #define _RECTANGLE_H
      #include "Point.h"
      class Rectangle: private Point {	
      //派生类定义部分，私有继承public:	
      //新增公有函数成员	
      void initRectangle(float x, float y, float w, float h) {		
      initPoint(x, y); //调用基类公有成员函数		
      this->w = w;		this->h = h;	
      }	
      void move(float offX, float offY) { Point::move(offX, offY);	}	
      float getX() const { return Point::getX(); }	
      float getY() const { return Point::getY(); }	
      float getH() const { return h; }	
      float getW() const { return w; }//定义成常成员函数，防止常对象无法调用；
      private:	//新增私有数据成员	
      float w, h;
      };
      #endif //_RECTANGLE_H
      

      #include “Rectangle.h”
      #include <iostream>
      #include <cmath>
      using namespace std;
      int main() {	
      Rectangle rect;	//定义Rectangle类的对象	
      rect.initRectangle(2, 3, 20, 10);	//设置矩形的数据	
      rect.move(3,2);	//移动矩形位置	
      cout << "The data of rect(x,y,w,h): " << endl;	cout << rect.getX() <<", "	//输出矩形的特征参数		<< rect.getY() << ", "		<< rect.getW() << ", "		<< rect.getH() << endl;	
      return 0;}
      

    • 保护继承： （1）基类的public和protected成员都以protected身份出现在派生类中，但基类的private成员不可直接访问。 （2）派生类中的成员函数可以直接访问基类中的public和protected成员，但不能直接访问基类的private成员。 （3）通过派生类的对象不能直接访问基类中的任何成员 // 对建立其类对象的模块(如main()等测试模块)来说，它与 private 成员的性质相同（隐藏，不可直接访问）。 对于其派生类来说，它与 public 成员的性质相同。 既实现了数据隐藏，又方便继承，实现代码重用。

  • 类型兼容（转换）规则

    一个公有派生类的对象在使用上可以被当作基类的对象，反之则禁止。 从具体表现在： （1）派生类的对象可以隐含转换为基类对象。 （2）派生类的对象可以初始化基类的引用。 （3）派生类的指针可以隐含转换为基类的指针。（父指子） 通过基类对象名、指针只能使用从基类继承的成员

  • 继承中的构造函数和析构函数

    1. 构造函数

       基类的构造函数不被继承，派生类中需要声明自己的构造函数。 定义派生类的构造函数时，只需要对本类中新增成员进行初始化，对继承来的基类成员的初始化，如果不显式调用基类构造函数，则基类缺省构造函数会自动调用。 当派生类的构造函数需要传参数去初始化基类的成员时，就要显式地调用基类带参数的构造函数。

       派生类名::派生类名(形参表):基类名1(参数), 基类名2(参数), ...基类名n(参数), 本类对象成员和基本类型成员初始化列表{
               //其他初始化  
               }；
       

       构造函数执行顺序： （1）调用基类构造函数，调用顺序按照它们被继承时声明的顺序（从左向右）。 （2）对本类成员初始化列表中的基本类型成员和对象成员进行初始化，初始化顺序按照它们在类中声明的顺序。对象成员初始化是自动调用对象所属类的构造函数完成的。 （3）执行派生类的构造函数体中的内容

    2. 复制构造函数

       若建立派生类对象时没有编写复制构造函数，编译器会生成一个隐含的复制构造函数，该函数先调用基类的复制构造函数，再为派生类新增的成员对象执行拷贝。 若编写派生类的复制构造函数，则需要为基类相应的复制构造函数传递参数。 例如: C::C(const C &c1): B(c1) {…}//这里利用派生类为基类传值，利用了类型兼容原则，父指子；

    3. 析构函数

       析构函数也不被继承，派生类自行声明； 声明方法与一般（无继承关系时）类的析构函数相同。 不需要显式地调用基类的析构函数，系统会自动隐式调用。 析构函数的调用次序与构造函数相反。

  • 派生类成员的标识与访问

    • 成员按照访问属性可以分为：

      1. 不可访问的成员

         从基类私有成员继承而来，派生类或是建立派生类对象的模块都没有办法访问到它们，如果派生类继续派生新类，也无法访问

         1. 私有成员

            从基类继承过来的成员以及新增加的成员，在派生类内部可以访问，但是建立派生类对象的模块中无法访问，继续派生，就变成了新的派生类的不可访问成员。

         2. 保护成员

            可能是新增也可能时从基类中继承过来的，派生类内部成员可以访问，建立派生类对象的模块无法访问，进一步派生，在新的怕四恶化你该类中可能成为私有成员或者保护成员

         3. 公有成员

            派生类、建立派生类的模块都可以范围跟，继续派生，可能为私有、保护、公有成员。

    • 作用域限定

      “::”是作用域分辨符，用于限定要访问的成员所在的类的名称。

      类名::成员名；
      类名::成员名（参数表）
      

      对于在不同作用域声明的标识符，如果存在两个或者多个具有包含关系的作用域，外层声明了一个标识符，而内层没有再次再次声明同名标识符，则该标识符在内层可见；如果在内层声明，则外层的标识符在内层不可见，这时称内层标识符隐藏了外层，即隐藏规则

      当派生类与基类中有相同成员（即使数据类型不同也算）时： 若未特别限定，则通过派生类对象使用的是派生类中的同名成员。 如要通过派生类对象访问基类中被隐藏的同名成员，应使用基类名和作用域操作符（::）来限定。

      如果子类中定义的函数与父类的函数同名但具有不同的参数数量或参数类型，不属于函数重载，这时子类中的函数将使父类中的函数隐藏，调用父类中的函数必须使用父类名称来限定。只有在相同的作用城中定义的函数才可以重载。

    • 虚基类

      如果某个派生类的部分或全部直接基类是从另一个共同的基类派生而来，在这些直接基类中，从上一级基类继承来的成员就拥有相同的名称，因此派生类中也就会产生同名现象，对这种类型的同名成员也要使用作用域分辨符来唯一标识，而且必须用直接基类来进行限定。——会产生二义性，虚基类来解决同一数据成员具有多个副本，函数有多个映射

      class 派生类名:virtual 继承方式 基类名{}//虚基类使派生时，在派生类中标注的
      

      建立一个对象时，如果这个对象中含有从虚基类继承来的成员，则虚基类的成员是由最远派生类的构造丽数通过调用虚基类的构造两数进行初始化的。而且，只有最远派生类的构造函数会调用虚基类的构造函数，该派生类的其他基类(例如，上例中的Basel和Base2类)对虚基类构造函数的调用都自动被忽略细节

  • 构造一个类的对象的一般顺序是： （1）如果该类有直接或间接的虚基类，则先执行虚基类的构造函数。 （2）如果该类有其他基类，则按照它们在继承声明列表中出现的次序，分别执行它们 的构造函数，但构造过程中，不再执行它们的虚基类的构造函数 （3）按照在类定义中出现的顺序，对派生类中新增的成员对象进行初始化。对于类 类型的成员对象，如果出现在构造函数初始化列表中，则以其中指定的参数执行构造画 数，如未出现，则执行默认构造函数;对于基本数据类型的成员对象，如果出现在构造函数 的初始化列表中，则使用其中指定的值为其赋初值，否则什么也不做 （4）执行构造函数的函数体。