zoukankan      html  css  js  c++  java
  • C++ 一篇搞懂继承的常见特性

    微信公众号:「小林coding」
    用简洁的方式,分享编程小知识。

    继承和派生

    01 继承和派生的概念

    继承:

    • 在定义一个新的类 B 时,如果该类与某个已有的类 A 相似(指的是 B 拥有 A 的全部特点),那么就可以把 A 作为一个基类,而把B作为基类的一个派生类(也称子类)。

    派生类:

    • 派生类是通过对基类进行修改和扩充得到的,在派生类中,可以扩充新的成员变量和成员函数。
    • 派生类拥有基类的全部成员函数和成员变量,不论是private、protected、public。需要注意的是:在派生类的各个成员函数中,不能访问基类的private成员。

    02 需要继承机制的例子

    程序猿种类有很多种,如 C/C++ 程序猿,Java 程序猿,Python 程序猿等等。那么我们要把程序猿设计成一个基类, 我们则需要抽出其特有的属性和方法。

    所有程序猿的共同属性(成员变量):

    1. 姓名
    2. 性别
    3. 职位

    所有的程序猿都有的共同方法(成员函数):

    1. 是否要加班?
    2. 是否有奖励?

    而不同的程序猿,又有各自不同的属性和方法:

    • C++ 程序猿:是否是音视频、网游领域
    • Java 程序猿:是否是微服务领域
    • Python 程序猿:是否是人工智能、大数据领域

    03 派生类的写法

    继承的格式如下:

    class 派生类名:public 基类名
    {
        
    };
    

    程序猿 Coder 基类:

    class Coder
    {
    public:
        bool isWorkOvertime(){}        // 是否要加班
        
        bool isReward(){}              // 是否有奖励
        
        void Set(const string & name)  // 设置名字
        {
            m_name = name;
        }
        
        ...
        
    private:
        string m_name; // 姓名
        string m_post; // 职位
        int m_sex;     // 性别
    };
    

    Python 程序猿 PythonCoder 派生类:

    class PythonCoder : public Coder
    {
    public:
        bool isAIField(){}      // 是否是人工智能领域
        bool isBigDataField(){} // 是否是大数据领域
    };
    

    04 派生类对象的内存空间

    派生类对象的大小 = 基类对象成员变量的大小 + 派生类对象自己的成员变量的大小。在派生类对象中,包含着基类对象,而且基类对象的存储位置位于派生类对象新增的成员变量之前,相当于基类对象是头部。

    class CBase
    {
        int a1;
        int a2;
    };
    
    class CDerived : public CBase
    {
        int a3;    
    };
    


    继承关系和复合关系

    01 类之间的两种关系

    继承的关系是「是」的关系:

    • 基类 A,B 「是」基类 A 的派生类。
    • 逻辑上要求:一个 B 对象也「是」一个 A 对象。

    继承的关系是「有」的关系:

    • C 类中「有」成员变量 i,i 成员变量是 D 类的,则 C 和 D 是复合关系。
    • 逻辑上要求:D 对象是 C 对象的固有属性或组成部分。

    02 继承关系的使用

    假设已经存在了 Man 类表示男人,后面需要些一个 Women 类来表示女人。Man 类和 Women 类确实是有共同之处,那么就让 Women 类继承 Man 类,是否合适?

    我们先想想继承的逻辑要求,假设 Women 类继承 Man 类后的逻辑就是:一个女人也是一个男人。很明显,这显然不成立!

    所以,好的做法是概括男人和女人的共同特点,抽象出一个 Human 类表示人,然后 Man 和 Woman 都继承 Human 类。

    03 复合关系的使用

    假设要写一个小区养狗管理系统:

    • 需要写一个「主人」类。
    • 需要些一个「狗」类。

    假定狗只有一个主人,但是一个主人可以最多有 10 条狗,应该如何设计和使用「主人」类 和「狗」类呢?我们先看看下面几个例子:

    例子一:

    • 为主人类设一个狗类的成员对象数组
    • 为狗类设一个主人类的成员对象
    class CDog;
    class CMaster // 主人类
    {
        CDog dogs[10]; // 狗类的成员对象数组
    };
    
    class CDog  // 狗类
    {
        CMaster m;   // 主人类的成员对象
    };
    

    例子一可以发现是:

    • 主人类会构造 10 个狗对象
    • 狗类会构造 1 个主人对象

    相当于人中有狗,狗中有人:

    这样是不好的,因为会产生循环不断的构造,主人类构造狗对象,狗类又构造主人对象....

    例子二:

    • 为狗类设一个主人类的成员对象
    • 为主人类设一个狗类的对象指针数组
    class CDog;
    class CMaster // 主人类
    {
        CDog * pDogs[10]; // 狗类的对象指针数组
    };
    
    class CDog  // 狗类
    {
        CMaster m;   // 主人类的成员对象
    };
    

    这样又变成狗中有人,人去指向「狗中有人」的狗,关系就会显得很错乱,如下图:

    例子三:

    • 为狗类设一个主人类的对象指针
    • 为主人类设一个狗类的对象数组
    class CDog;
    class CMaster // 主人类
    {
        CDog  dogs[10]; // 狗类的对象数组
    };
    
    class CDog  // 狗类
    {
        CMaster * pm;   // 主人类的对象指针
    };
    

    这样就会变成,人中有狗,人里面的狗又会指向主人,虽然关系相对好了一点,但是同样还是会绕晕,效果如下图:

    例子四:

    • 为狗类设一个主人类的对象指针
    • 为主人类设一个狗类的对象指针数组
    class CDog;
    class CMaster // 主人类
    {
        CDog  * pDogs[10]; // 狗类的对象指针数组
    };
    
    class CDog  // 狗类
    {
        CMaster * pm;   // 主人类的对象指针
    };
    

    这个是正确的例子,因为相当于人和主人是独立的,然后通过指针的作用,使得狗是可以指向一个主人,主人也可以同时指向属于自己的 10 个狗,这样会更灵活。

    04 指针对象和对象的区别

    如果不用指针对象,生成 A 对象的同时也会构造 B 对象。用指针就不会这样,效率和内存都是有好处的。

    比如:

    class Car
    {
        Engine engine; // 成员对象
        Wing * wing;   // 成员指针对象
    };
    

    定义一辆汽车,所有的汽车都有 engine,但不一定都有 wing
    这样对于没有 wing 的汽车,wing 只占一个指针,判断起来也很方便。

    • 空间上讲,用指针可以节省空间,免于构造 B 对象,而是只在对象中开辟了一个指针,而不是开辟了一个对象 B 的大小。
    • 效率上讲,使用指针适合复用。对象 B 不但 A 对象能访问,其他需要用它的对象也可以使用。
    • 指针对象可以使用多态的特性,基类的指针可以指向派生链的任意一个派生类。
    • 指针对象,需要用它的时候,才需要去实例化它,但是在不使用的时候,需要手动回收指针对象的资源。

    派生类覆盖基类成员

    01 覆盖

    派生类(子类)可以定义一个和基类(父类)成员同名的成员,这叫「覆盖」。在派生类(子类)中访问这类成员时,默认的情况是访问派生类中定义的成员。要在派生类中访问由基类定义的同名成员时,要使用作用域符号::

    下面看具体的例子:

    // 基类
    class Father
    {
    public:
        int money;
        void func();
    };
     
     // 派生类
    class Son : public Father // 继承
    {
    public:
        int money;   // 与基类同名成员变量
        void func(); // 与基类同名成员函数
        
        void myFunc(); 
    };
    
    void Son::myFunc()
    {
        money = 100;         // 引用的是派生类的money
        Father::money = 100; // 引用的是基类的money
        
        func();           // 引用的是派生类的
        Father::func();   // 引用的是基类的
    }
    

    相当于 Son 对象占用的存储空间:


    类的保护成员

    我们都知道基类的 public 成员,都是可以被派生类成员访问的,那么基类的 protected、private 成员,分别可以被派生类成员访问吗?带着这个问题,我们可以先看下面的栗子:

    class Father
    {
    public:
        int nPublic;   // 公有成员
    protected:
        int nProtected; // 保护成员
    private:
        int nPrivate;   // 私有成员
    };
    
    class Son : public Father
    {
        void func()
        {
            nPublic = 1;     // OK
            nProtected = 1;  // error
            nPrivate =1;     // ok,访问从基类继承的protected成员
            
            Son a;
            a.nProtected = 1; // error,a不是当前对象
        }
        
    };
    
    int main()
    {
        
        Father f;
        Son s;
        
        f.nPublic;  // OK
        s.nPublic;  // OK
        
        f.nProtected; // error
        s.nProtected; // error
        
        f.nPrivate;  // error
        s.nPrivate;  // error
    }  
    

    基类的 protected、private 成员对于派生类成员的权限说明:

    基类的 protected 成员 基类的 private 成员
    派生类的成员函数可以访问当前对象的基类的保护成员 不能被派生类成员访问

    派生类的构造函数

    通常在初始化派生类构造函数时,派生类构造函数是要实现初始化基类构造函数的。那么如何在派生类构造函数里初始化基类构造函数呢?

    class Bug {
    private :
        int nLegs; int nColor;
    public:
        int nType;
        Bug (int legs, int color);
        void PrintBug (){ };
    };
    
    class FlyBug : public Bug  // FlyBug 是Bug 的派生类
    {
        int nWings;
    public:
        FlyBug( int legs,int color, int wings);
    };
    
    Bug::Bug( int legs, int color)
    {
        nLegs = legs;
        nColor = color;
    }
    
    // 错误的FlyBug 构造函数
    FlyBug::FlyBug ( int legs,int color, int wings)
    {
        nLegs = legs;   //  不能访问
        nColor = color; //  不能访问
        nType = 1;      // ok
        nWings = wings;
    }
    
    // 正确的FlyBug 构造函数:
    FlyBug::FlyBug ( int legs, int color, int wings):Bug( legs, color)
    {
        nWings = wings;
    }
    
    int main() 
    {
        FlyBug fb ( 2,3,4);
        fb.PrintBug();
        fb.nType = 1;
        fb.nLegs = 2 ; // error. nLegs is private
        return 0;
    }
    

    在上面代码例子中:

    第24-30行的派生类构造函数初始化基类是错误的方式,因为基类的私有成员是无法被派生类访问的,也就无法初始化。

    第33-36行代码是正确派生类构造函数初始化基类构造函数的方式,通过调用基类构造函数来初始化基类,在执行一个派生类的构造函数
    之前,总是先执行基类的构造函数。

    从上面的例子中我们也得知构造派生对象前,是先构造基类对象,那么在析构的时候依然依据“先构造,后初始化”的原则,所以派生类析构时,会先执行派生类析构函数,再执行基类析构函数。

    如下栗子:

    class Base 
    {
    public:
        int n;
        
        Base(int i) : n(i)
        {
            cout << "Base " << n << " constructed" << endl;
        }
        
        ~Base()
        { 
            cout << "Base " << n << " destructed" << endl; 
        }
    };
    
    class Derived : public Base 
    {
    public:
        Derived(int i) : Base(i)
        { 
            cout << "Derived constructed" << endl; 
        }
        
        ~Derived()
        { 
            cout << "Derived destructed" << endl;
        }
    };
    
    int main() 
    { 
        Derived Obj(3); 
    
    return 0; 
    }
    

    输出结果:

    Base 3 constructed
    Derived constructed
    Derived destructed
    Base 3 destructed
    

    继承的赋值兼容规则

    01 public 继承

    // 基类
    class Base {};
    
    // 派生类
    class Derived : public Base {};
    
    Base b;    // 基类对象
    Derived d; // 派生类对象
    
    1. 派生类的对象可以赋值给基类对象
    b = d;
    
    1. 派生类对象可以初始化基类引用
    Base & br = d;
    
    1. 派生类对象的地址可以赋值给基类指针
    Base * pb = & d;
    

    注意:如果派生方式是 private 或 protected,则上述三条不可行

    02 protected 和 private 继承

    // 基类
    class Base {};
    
    // 派生类
    class Derived : protected Base {};
    
    Base b;    // 基类对象
    Derived d; // 派生类对象
    
    • protected 继承时,基类的 public 成员和 protected 成员成为派生类的 protected 成员;
    • private 继承时,基类的 public 成员成为派生类的 private 成员,基类的 protected 成员成
      为派生类的不可访问成员;
    • protected 和 private 继承不是「是」的关系。

    所以派生方式是 private 或 protected,则是无法像 public 派生承方式一样把派生类对象赋值、引用、指针给基类对象。

    03 基类与派生类的指针强制转换

    public 派生方式的情况下,派生类对象的指针可以直接赋值给基类指针

    Base *ptrBase = & objDerived;
    
    • ptrBase 指向的是一个 Derived 派生类(子类)的对象
    • *ptrBase 可以看作一个 Base 基类的对象,访问它的 public 成员直接通过 ptrBase 即可,但不能通过 ptrBase 访问 objDerived 对象中属于 Derived 派生类而不属于基类的成员。

    通过强制指针类型转换,可以把 ptrBase 转换成 Derived 类的指针

    Base * ptrBase = &objDerived;
    Derived *ptrDerived = ( Derived * ) ptrBase;
    

    程序员要保证 ptrBase 指向的是一个 Derived 类的对象,否则很容易会出错。

  • 相关阅读:
    一道Twitter面试题
    聊下并发和Tomcat线程数(错误更正)
    Entity Framework系列教程汇总
    SqlServer基础汇总
    .Net Core中间件和过滤器实现错误日志记录
    快速掌握mongoDB(六)——读写分离的副本集实现和Sharing介绍
    快速掌握mongoDB(五)——通过mongofiles和C#驱动操作GridFS
    快速掌握mongoDB(四)—— C#驱动MongoDB用法演示
    快速掌握mongoDB(三)——mongoDB的索引详解
    快速掌握mongoDB(二)——聚合管道和MapReduce
  • 原文地址:https://www.cnblogs.com/xiaolincoding/p/12130945.html
Copyright © 2011-2022 走看看