继承

 一.继承：在已有类的基础上创建新类的过程。
  一个 B 类继承A类，或称从类 A 派生类 B，则 类 A 称为基类（父类），类 B 称为派生类（子类）

  二 .基类和派生类

• 类继承关系的语法形式
   class 派生类名 : 基类名表 
    {
         数据成员和成员函数声明
    };
• 基类名表 的构成
   访问控制  基类名1， 访问控制  基类名2 ，… ， 访问控制  基类名n
• 访问控制 表示派生类对基类的继承方式，使用关键字：
     public  公有继承
    private  私有继承
     protected 保护继承
• 注意：不论以哪种方式继承基类，派生类都不能直接使用基类的私有成员。

1. 派生类的生成过程

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

       ●改造基类成员 ：通过在派生类中定义同名成员（包括成员函数和数据成员）来屏蔽（隐藏）在派生类中不起作用的部分基类成员。
       ●添加派生类新成员：仅仅继承基类的成员是不够的，需要在派生类中添加新成员，以保证派生类自身特殊属性和行为的实现。

    2.公有继承

例子：

#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            // 公有继承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 ;

 

注意：在派生类里调用继承于基类的成员函数访问继承于基类的私有数据成员
3.重名成员

• 若派生类定义了与基类同名的成员，在派生类中访问同名成员时屏蔽（hide）了基类的同名成员
• 在派生类中如果仍使用基类的同名成员，则需显式地使用类名限定符：类名 :: 成员

例1：重名数据成员

class  base
  { public :
           int  a ,  b ;                                 base ： a
  } ;
class  derived : public  base //公有继承base类；         derived: a b  b c
  { public :  
         int  b ,  c ; 
  } ;
void  f ()
{  derived  d ;
   d . a = 1 ;
   d . base :: b = 2 ;   //重名数据成员；
   d . b = 3 ;
   d . c = 4 ;
};

例2：同名成员函数

#include<iostream>	
using namespace std ;
class A
{ public:	  
       int a1, a2 ;
      A( int i1=0, int i2=0 ) { a1 = i1; a2 = i2; }
      void print() 
         { cout << "a1=" << a1 << '\t' << "a2=" << a2 << endl ; }
};
class B : public A
{ public:	
       int b1, b2 ;
       B( int j1=1, int j2=1 ) { b1 = j1; b2 = j2; }
       void print()		//定义同名函数,同时屏蔽了基类的同名函数；
         { cout << "b1=" << b1 << '\t' << "b2=" << b2 << endl ; }
void printAB()
        { A::print() ;		//派生类对象调用基类版本同名成员函数
           print() ;		//派生类对象调用自身的成员函数
       }
};
int main()
{ B  b ;        b.A::print();	b.printAB();  }

例2结果显示：

4.派生类中访问静态成员

 

•  基类定义的静态成员，将被所有派生类共享（基类和派生类共享基类中的静态成员）
•  根据静态成员自身的访问特性和派生类的继承方式，在类层次体系中具有不同的访问性质 
•  派生类中访问静态成员，用以下形式显式说明：类名 :: 成员  或通过对象访问 对象名 . 成员

#include<iostream>
using namespace std ;
class B
{ public:
    static void Add() { i++ ; }
    static int i;
    void out() { cout<<"static i="<<i<<endl; }
};
int B::i=0;
class D : private B
{ public:    
      void f() 
       { i=5;
         Add();
         B::i++;
         B::Add();
       }
};
int main()
{ B x;  D y;
  x.Add();
  x.out();
  y.f();
  cout<<"static i="<<B::i<<endl;   //通过派生类访问基类静态成员；
  cout<<"static i="<<x.i<<endl;   //通过派生类的对象访问基类静态成员；
}

 

5.基类的初始化

 

 

• 在创建派生类对象时用指定参数调用基类的构造函数来初始化派生类继承基类的成员
•   派生类构造函数声明为

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

•  构造函数执行顺序：基类 ->对象成员-> 派生类
• 派生类的数据成员既包括基类的数据成员，也包括派生类新增数据成员。

#include<iostream>
using namespace std ;
class  parent_class
{     int  data1 , data2 ;
   public :
       parent_class ( int  p1 , int  p2 ) { data1 = p1; data2 = p2; }
       int  inc1 () { return  ++ data1; }
       int  inc2 () { return  ++ data2 ; }
       void  display  ()  {cout << "data1=" << data1 << " , data2=" << data2 << endl ; }
};
class  derived_class : private  parent_class
{     int  data3 ;               //自身数据成员；
       parent_class  data4 ;     //对象成员；
   public:
       derived_class ( int  p1 , int  p2 , int  p3 , int  p4 , int  p5 ): parent_class ( p1 , p2 ) , data4 ( p3 , p4 )
           { data3 = p5 ; }          //初始化顺序；
       int  inc1 ( ) { return  parent_class :: inc1 ( ) ; }
       int  inc3 ( ) { return  ++ data3 ; }
       void  display ( )
          { parent_class :: display ( ) ;   data4.display ( ) ;
             cout << "data3=" << data3 << endl ;
          }
} ;
int main ( )
{ derived_class  d1 ( 17 , 18 , 1 , 2 , -5 ) ;   d1 . inc1 ( ) ;     d1 . display ( ) ;  }

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

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

• 基类的构造函数和析构函数不能被继承
• 如果基类没有定义构造函数或有无参的构造函数， 派生类也可以不用定义构造函数
• 如果基类无无参的构造函数，派生类必须定义构造函数
• 如果派生类的基类也是派生类，则每个派生类只负责直接基类的构造
• 派生类是否定义析构函数与所属的基类无关
• 

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

      在C++中,派生类构造函数的一般格式为:
      派生类::派生类名(参数总表):基类名(参数表)
     {
             // 派生类新增成员的初始化语句
     }

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

（3）派生类析构函数

①当派生类中不含对象成员时
●在创建派生类对象时,构造函数的执行顺序是：基类的构造函数→派生类的构造函数；
●在撤消派生类对象时,析构函数的执行顺序是：派生类的析构函数→基类的析构函数。
②当派生类中含有对象成员时
●在定义派生类对象时，构造函数的执行顺序：基类的构造函数→对象成员的构造函数→派生类的构造函数；
●在撤消派生类对象时，析构函数的执行顺序：派生类的析构函数→对象成员的析构函数→基类的析构函数。

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()                                                 编译结果： B()
{                                                                     D()
    D d;                                                              ~D()
    return 0;                                                         ~B()
}

三.多继承

 

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

class  派生类名 : 访问控制  基类名1 ,  访问控制  基类名2 ,  … , 访问控制  基类名n
    {
         数据成员和成员函数声明

    }；

 

• 类 C 可以根据访问控制同时继承类 A 和类 B 的成员，并添加自己的成员
• 

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

 

• 多个基类的派生类构造函数可以用初始式调用基类构造函数初始化数据成员。
• 执行顺序与单继承构造函数情况类似。多个直接基类构造函数执行顺序取决于定义派生类时指定的各个继承基类的顺序。
•  一个派生类对象拥有多个直接或间接基类的成员。不同名成员访问不会出现二义性。如果不同的基类有同名成员，派生类对象访问时应该加以识别。 

（2）多继承的构造函数

派生类名(参数总表):基类名1(参数表1),基类名2(参数表2),…,基类名n(参数表n)
    {
           // 派生类新增成员的初始化语句

     } 

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

●先执行所有基类的构造函数
●再执行对象成员的构造函数

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

注意：

 

• 处于同一层次的各基类构造函数的执行顺序取决于定义派生类时所指定的基类顺序
• 与派生类构造函数中所定义的成员初始化列表顺序没有关系。内嵌对象成员的构造函数执行顺序与对象在派生类中声明的顺序一致

（4）多继承的析构函数 

 

• 析构函数名同样与类名相同，无返回值、无参数，而且其定义方式与基类中的析构函数的定义方式完全相同。
• 功能是在派生类中对新增的有关成员进行必要的清理工作。
• 析构函数的执行顺序与多继承方式下构造函数的执行顺序完全相反，首先对派生类新增的数据成员进行清理，再对派生类对象成员进行清理，最后才对基类继承来的成员进行清理。 

四.赋值兼容规则

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

 

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

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

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

（3）赋值兼容的可行性

①通过公有继承，派生类得到了除了构造、析构函数以外的所有成员，且这些成员的访问控制属性也和基类完全相同。这样，它便具备了基类的所有功能。
 ②利用赋值兼容规则
a 派生类的对象可以赋给基类对象(强制类型转换)
b 派生类的对象可以初始化基类的引用
c 派生类的对象的地址可以赋给基类类型的指针

例如,下面声明的两个类:
class Base
{  …  };
class Derived:public Base
{
…
};
    根据赋值兼容规则, 以下几种情况是合法的: 
(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; 

（4）赋值兼容规则的特点

 

• 在替代之后，派生类对象就可以作为基类的对象使用，但只能使用从基类继承的成员。
• 一个派生类对象也是一个基类对象，一个基类对象可派上用场的地方，派生类对象一样可派上用场。反之则不然。

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

①声明为指向基类的指针可以指向它的公有派生类的对象，但不允许指向它的私有派生类的对象。例如：
    class B  {…}；
    class D：private B  {…}；
    B b1，*pbl；D d1；
    pb1=&b1;        //合法，基类B的对象b1和B类的指针
    pb1=&d1;        //非法，不允许将基类指针指向它的私有派生类对象
②允许将一个声明为指向基类的指针指向其公有派生类对象，但是不能将一个声明为指向派生类对象的指针指向其基类的一个对象。
③  声明为指向基类对象的指针，当其指向公有派生类对象时，只能用它来直接访问派生类中从基类继承来的成员，而不能直接访问公有派生类的定义的成员。