继承



C++ 继承

面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行时间的效果。

当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。

继承代表了 is a 关系。例如，哺乳动物是动物，狗是哺乳动物，因此，狗是动物，等等。

基类 & 派生类

一个类可以派生自多个类，这意味着，它可以从多个基类继承数据和函数。定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名，形式如下：

class derived-class: access-specifier base-class

其中，访问修饰符 access-specifier 是 public、protected 或 private 其中的一个，base-class 是之前定义过的某个类的名称。如果未使用访问修饰符 access-specifier，则默认为 private。

假设有一个基类 Shape，Rectangle 是它的派生类，如下所示：

实例

#include <iostream>
 
using namespace std;
 
// 基类
class Shape 
{
   public:
      void setWidth(int w)
      {
         width = w;
      }
      void setHeight(int h)
      {
         height = h;
      }
   protected:
      int width;
      int height;
};
 
// 派生类
class Rectangle: public Shape
{
   public:
      int getArea()
      { 
         return (width * height); 
      }
};
 
int main(void)
{
   Rectangle Rect;
 
   Rect.setWidth(5);
   Rect.setHeight(7);
 
   // 输出对象的面积
   cout << "Total area: " << Rect.getArea() << endl;
 
   return 0;
}
当上面的代码被编译和执行时，它会产生下列结果：

Total area: 35

访问控制和继承
派生类可以访问基类中所有的非私有成员。因此基类成员如果不想被派生类的成员函数访问，则应在基类中声明为 private。

我们可以根据访问权限总结出不同的访问类型，如下所示：

访问 public protected private
同一个类 yes yes yes
派生类 yes yes no
外部的类 yes no no
一个派生类继承了所有的基类方法，但下列情况除外：

基类的构造函数、析构函数和拷贝构造函数。
基类的重载运算符。
基类的友元函数。
继承类型
当一个类派生自基类，该基类可以被继承为 public、protected 或 private 几种类型。继承类型是通过上面讲解的访问修饰符 access-specifier 来指定的。

我们几乎不使用 protected 或 private 继承，通常使用 public 继承。当使用不同类型的继承时，遵循以下几个规则：

公有继承（public）：当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。
保护继承（protected）： 当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。
私有继承（private）：当一个类派生自私有基类时，基类的公有和保护成员将成为派生类的私有成员。
多继承
多继承即一个子类可以有多个父类，它继承了多个父类的特性。

C++ 类可以从多个类继承成员，语法如下：

class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…
{
<派生类类体>
};
其中，访问修饰符继承方式是 public、protected 或 private 其中的一个，用来修饰每个基类，各个基类之间用逗号分隔，如上所示。

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

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

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

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

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

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

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

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

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

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

多继承的简单应用:

class Base1
{ public:
      Base1(int x) { value = x ; }
      int getData() const { return value ; }
   protected:
      int value;
};
class Base2
{ public:
      Base2(char c) { letter=c; }
      char getData() const { return letter;}
   protected:
      char letter;
};
class Derived : public Base1, public Base2
{    friend ostream &operator<< ( ostream &, const Derived & ) ;
   public :
      Derived ( int, char, double ) ;
      double getReal() const ;
   private :
      double real ;
};

int main()
{ Base1 b1 ( 10 ) ;
   Base2 b2 ( 'k' ) ;
   Derived d ( 5, 'A', 2.5 ) ;
      :
   return ;
}

派生类析构函数：

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

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

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

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

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

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

 例：

1. #include<iostream.h>
2. class base
3. {
4. public:
5. base(){ cout<< "constructing base class"<< endl;}
6. ~base(){ cout<< "destructing base class"<< endl; }
7. };
8. class subs: public base
9. {
10. public:
11. subs(){ cout<< "constructing sub class"<< endl;}
12. ~subs(){ cout<< "destructing sub class"<< endl;}
13. };
14. void main()
15. {
16. subs s;
17. }

执行结果：

constructingbase class

constructingsub class

destructingsub class

destructingbase class

执行顺序：
     ●先执行所有基类的构造函数

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

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

【注】处于同一层次的各基类构造函数的执行顺序取决于定义派生类时所指定的基类顺序与派生类构造函数中所定义的成员初始化列表顺序没有关系。

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

（6）多继承的析构函数：

析构函数名同样与类名相同，无返回值、无参数，而且其定义方式与基类中的析构函数的定义方式完全相同。

●功能是在派生类中对新增的有关成员进行必要的清理工作。

●析构函数的执行顺序与多继承方式下构造函数的执行顺序完全相反，首先对派生类新增的数据成员进行清理，再对派生类对象成员进行清理，最后才对基类继承来的成员进行清理

赋值兼容规则：

（1）概念：在程序中需要使用基类对象的任何地方，都可以用公有派生类的对象来替代。

（2）其所指的替代包括以下几种情况：

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

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

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

 （3）可行性：

通过公有继承，派生类得到了除了构造、析构函数以外的所有成员且这些成员的访问控制属性也和基类完全相同。这样，它便具备了基类的所有功能。

  （4）例：下面声明两个类：

1. class Base
2. {
3. …
4. };
5. class Derived: public Base
6. {
7. …
8. };

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

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;

（5）特点：
在替代之后，派生类对象就可以作为基类的对象使用，但只能使用从基类继承的成员。

（6）应注意的问题：

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

       classB  {…}；

       class D：private B  {…}；

       B b1，*pb1；Dd1；

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

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

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

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

二、心得体会

通过对继承的学习，我们可以更好地精简代码。所谓继承，顾名思义，是一个类继承另一个类的部分，如果我们想要实现的两个类的部分功能或成员是相同的，那么我们就可以通过继承来缩减代码。

当然，想要熟练地使用继承，首先我们应该有良好的逻辑关系，因为继承是两个类之间的联系，所以这就要求我们在平时的学习中多思考，理清类与类之间的关系，而不是糊里糊涂。其次，是对其具体知识的熟练掌握，这就要求我们课下多练习用继承来巩固基础知识。