C++程序设计【六】之多态与虚函数

迷南。 2022-11-03 11:13 7阅读 0赞

> 感谢内容提供者：[金牛区吴迪软件开发工作室][Link 1]  
> 接上一篇：[C++程序设计【五】之 类的继承与派生][C_]

### 文章目录 ###

*  第六章：多态与虚函数
 *   *  一、多态的基本概念
     *   *  1.多态
         *  2.虚函数
         *  3.通过基类指针实现多态
         *  4.通过基类引用实现多态
         *  5.多态的实现原理
     *  二、多态实例
     *  三、多态的使用
     *  四、虚析构函数
     *  五、纯虚函数和抽象类
     *   *  1.纯虚函数
         *  2.抽象类
         *  3.虚基类

# 第六章：多态与虚函数 #

## 一、多态的基本概念 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70]

### 1.多态 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 1]

### 2.虚函数 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 3]

### 3.通过基类指针实现多态 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 4]

#include<iostream>
    
    using namespace std;
    
    class A { 
    public:
        virtual void Print() {   // 虚函数
            cout << "A::Print" << endl;
        }
    };
    
    class B : public A {  // 公有继承
    public:
        virtual void Print() {   // 虚函数
            cout << "B::Print" << endl;
        }
    };
    
    class D : public A {  // 公有继承
    public:
        virtual void Print() {   // 虚函数
            cout << "D::Print" << endl;
        }
    };
    
    class E : public B {  // 公有继承
    public:
        virtual void Print() {   // 虚函数
            cout << "E::Print" << endl;
        }
    };
    
    int main() { 
        A a;
        B b;
        D d;
        E e;
        A *pa = &a;  // 基类pa指针指向基类对象a
        B *pb = &b;  // 派生类指针pa指向派生类对象b
        pa->Print();    // 多态，目前指向基类对象，调用a.Print(),输出A::Print
        pa = pb;    // 派生类指针赋给基类指针，pa指向派生类对象b
        pa->Print();    // 多态，目前指向派生对象，调用b.Print(),输出B::Print
        pa = &d;    // 基类指针pa指向派生类对象d
        pa->Print();    // 多态，目前指向派生对象，调用d.Print(),输出D::Print
        pa = &e;    // 基类指针pa指向派生类对象e
        pa->Print();    // 多态，目前指向派生对象，调用e.Print(),输出E::Print
        return 0;
    }

### 4.通过基类引用实现多态 ###

#include<iostream>
    
    using namespace std;
    
    class A { 
    public:
        virtual void Print() {   // 虚函数
            cout << "A::Print" << endl;
        }
    };
    
    class B : public A {  // 公有派生
    public:
        virtual void Print() {   // 虚函数
            cout << "B::Print" << endl;
        }
    };
    
    void PrintInfo(A &r) { 
        r.Print();  // 多态,使用基类引用调用哪个Print()取决于r引用了哪个类的对象
    }
    
    int main() { 
        A a;
        B b;
        PrintInfo(a);  // 使用基类对象，调用基类中的函数，输出A::Print
        PrintInfo(b);  // 使用基类对象，调用派生类中的函数，输出B::Print
        return 0;
    }

### 5.多态的实现原理 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 5]

## 二、多态实例 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 6]

## 三、多态的使用 ##

![在这里插入图片描述][20210228150610856.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 7]

#include<iostream>
    
    using namespace std;
    
    class CBase {    // 基类
    public:
        void func1() {   // 不是虚函数
            cout << "CBase::func1()" << endl;
            func2();    // 在成员函数中调用虚函数
            func3();
        }
    
        virtual void func2() {   // 虚函数
            cout << "CBase::func2()" << endl;
        }
    
        void func3() {   // 不是虚函数
            cout << "CBase::func3()" << endl;
        }
    };
    
    class CDerived : public CBase {    // 派生类
    public:
        virtual void func2() {   // 虚函数
            cout << "CDerived:func2()" << endl;
        }
    
        void func3() { 
            cout << "CDerived:func3()" << endl;
        }
    };
    
    int main() { 
        CDerived d;
        d.func1();  // 调用的基类中的成员函数
        return 0;
    }

## 四、虚析构函数 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 8]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 9]

#include<iostream>
    
    using namespace std;
    
    class ABase {    // 基类
    public:
        ABase() { 
            cout << "ABase构造函数" << endl;
        }
        virtual  ~ABase() { 
            cout << "ABase::析构函数" << endl;
        }
    };
    
    class Derived : public ABase {    // 派生类
    public:
    public:
        int w,h;    // 俩个成员
        Derived() { 
            cout << "Derived构造函数" << endl;
            w = 4;
            h = 7;
        }
        ~Derived() { 
            cout << "Derived::析构函数" << endl;
        }
    };
    
    int main() { 
        ABase *p = new Derived();
        // 使用基类指针指向new创建的派生类对象
        delete p;
        return 0;
    }

## 五、纯虚函数和抽象类 ##

### 1.纯虚函数 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 10]

### 2.抽象类 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 11]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 12]

#include<iostream>
    
    using namespace std;
    
    class A { 
    private:
        int a;
    public:
        virtual void print() = 0;   // 纯虚函数
        void func1() { 
            cout << "func1" << endl;
        }
    };
    
    class B : public A { 
    public:
        void print();
    
        void func1() { 
            cout << "B_func1" << endl;
        }
    };
    
    void B::print() { 
        cout << "B_Print" << endl;
    }
    
    int main() { 
        // A a; // 错误，抽象类不能实例化
        // A *p = new A; // 错误，不能创建类A的示例
        // A b[2]; // 错误，不能声明抽象类的数组
        A *pa;  // 正确，可以声明抽象类的指针
        A *pb = new B;  // 使用基类指针指向派生类对象
        pb->print();    // 调用的是类B中的函数，多态，输出B——print
        B b;
        A *pc = &b;
        pc->func1();    // 因为不是虚函数，调用的是类A中的函数，输出func1
        return 0;
    }

### 3.虚基类 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 13]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 14]

#include<iostream>
    
    using namespace std;
    
    class A { 
    public:
        int a;
    
        void showa() { 
            cout << "a=" << a << endl;
        }
    };
    
    class B : virtual public A {  // 对A进行了虚继承
    public:
        int b;
    };
    
    class C : virtual public A {  // 对A进行了虚继承
    public:
        int c;
    };
    
    class D : public B, public C { 
        // 派生类D的俩个基类B、C具有共同的基类A
        // 采用了虚继承，从而使类D的对象中只包含着类A的1个实例
    public:
        int d;
    };
    
    int main() { 
        D Dobj; // 说明派生类D的对象
        Dobj.a = 11;    // 若不是虚继承，此行会出错！因为 "D::a" 具有二义性
        Dobj.b = 22;
        // 若不是虚继承，下面行会出错！因为 "D::showa" 具有二义性
        Dobj.showa();   // 输出 a=11
        cout << "Dobj.b=" << Dobj.b << endl;    // 输出Dobj.b=22
        return 0;
    }

下一篇：[C++程序设计【七】之 输入/输出流][C_ 1]

[Link 1]: http://wdstudio.top/
[C_]: https://wudi98.blog.csdn.net/article/details/114065904
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70]: /images/20221024/d7e4252b67ec4e8787a5d80da4e102f9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 1]: /images/20221024/c5253251cfed4143b77c3505186e8b46.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 2]: /images/20221024/4da7fa162c3843b4b520d4ed9a83eb30.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 3]: /images/20221024/a2641ab2344749bb8492856b3fc56361.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 4]: /images/20221024/13cf252aeca64ee880565afa9a8f20b9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 5]: /images/20221024/094fc376ce31499aa259157a370c700f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 6]: /images/20221024/11da8544faac45d291f17c5c1083e0fe.png
[20210228150610856.png]: /images/20221024/10d8a5a7c56146f69a079bfbae544c71.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 7]: /images/20221024/774a2a89ef394a069bd679b37b659423.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 8]: /images/20221024/3791df0c483449b09dcac7a8fb6ca7a0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 9]: /images/20221024/4b08d842020a41ceba1e53092337d551.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 10]: /images/20221024/19ea2ab3879348cba57231b7efb2df1d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 11]: /images/20221024/4bfc8cbb553f4e90ae22ac03d6d07c2d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 12]: /images/20221024/06502764c33243e9b9dbb4a58b8c1b85.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 13]: /images/20221024/fbc09435423140e2bfb313a29a2f2524.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzYwNjE1OA_size_16_color_FFFFFF_t_70 14]: /images/20221024/4adf3f5c6ae64d16a64292d5b0c672fd.png
[C_ 1]: https://wudi98.blog.csdn.net/article/details/114240364