继承



继承总结

1. 概念

   1. 继承：在已有类的基础上创建新类的过程

一个 B 类继承A类，或称从类 A 派生类 B

     类 A 称为基类（父类），类 B 称为派生类（子类）

2 语法形式

类继承关系的语法形式

         class 派生类名 : 基类名表

        {                       

              数据成员和成员函数声明

        };

 

基类名表  构成

         访问控制 基类名₁， 访问控制 基类名₂ ，… ， 访问控制 基类名_n

 

访问控制 表示派生类对基类的继承方式，使用关键字：

       public                 公有继承

        private              私有继承

       protected         保护继承

 

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

3. 派生类的生成过程

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

(二) 改造基类成员

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

(三) 添加派生类新成员

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

4. 派生类对象结构

#include <iostream>

using namespace std;

class A{

public:

   inta;

int b;

private:

   intc;

protected:

   intd;

};

class B: public A

{       int c;      };

main( ){

   cout<< ” size of A is” << sizeof(A);

   cout<< ” size of B is” << sizeof(B); }

 

5.继承方式

--------公有继承

 

 

#include<iostream>

using namespace std ;

class A

{ public :

     void  get_XY()   { cout << "Enter two numbers ofx, y : " ;  cin >> x >>y ; }

     void  put_XY()    { cout << "x = "<< x<< ", y = " << y << '\n' ; }

  protected:    int x, y ;

};

class B : publicA

{ public :

     int  get_S() { return s ; };

     void  make_S()  { s = x * y ; };    // 使用基类数据成员x，y

  protected:   int s;

};

class C : publicB

{ 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 ;

   BobjB ;

   CobjC ;

   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 ;

 

 

6.重名成员

   派生类定义了与基类同名的成员，在派生类中访问同名成员时屏蔽了基类的同名成员

   在派生类中使用基类的同名成员，显式地使用类名限定符：

类名 :: 成员

 

------重名数据成员

class  base

  { public :

           int a ,  b; 

  } ;

class  derived : public  base

  { public : 

         int b , c ;

  } ;

void  f ()

{derived  d ;

   d . a = 1 ;

   d . base :: b = 2 ;

   d . b = 3 ;

   d . c = 4 ;

};

二.

(一).派生类中访问静态成员

 基类定义的静态成员，将被所有派生类共享（基类和派生类共享基类中的静态成员）

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

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

(二)基类的初始化

  1.派生类构造函数声明为

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

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

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

三.

(一).派生类构造函数和析构函数的定义规则

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

(二) 派生类的构造函数的定义

调用基类构造函数对基类成员进行初始化。

1. 基类有构造函数且含有参数时使用

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

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

     {

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

     }

   (三). 派生类析构函数

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

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

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

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

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

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

 

四. 继承的应用实例

classPoint

{   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类的数据成员

};

classCircle : 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;        //数据成员，半径

};

classCylinder:public Circle

{    friend ostream &operator<<(ostream &, const Cylinder &);    // 友元函数

   public:

     Cylinder(double h=0.0, double r=0.0, intx=0, int y=0);      // 构造函数

     void setHeight(double);    /* 置高度值*/         

 double getHeight() const;         /* 返回高度值*/

     double area() const;           /* 返回面积*/          

 double volume() const;      /* 返回体积*/

   protected:    

doubleheight; // 数据成员，高度

};

五.多继承

一个类有多个直接基类的继承关系称为多继承

  多继承声明语法

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

    {

         数据成员和成员函数声明

    }；

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

 

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

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

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

 

1. 多继承的构造函数

    

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

      {

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

       }

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

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

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

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

4.多继承的析构函数

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

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

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

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

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

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

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

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

6. 赋值兼容的可行性

(1)通过公有继承，

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

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

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

(2)利用赋值兼容规则

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

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

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

 

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

(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;

8. 特点

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

9.问题

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

    class B {…}；

    class D：private B  {…}；

    B b1，*pbl；D d1；

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

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

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

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

 

 

 

学习心得

继承大大减少了程序中的重复率,使得程序更加简洁,而且节约了写作时间