【C++】 49_多态的概念和意义

我不是女神ヾ 2022-03-02 18:52 69阅读 0赞

# 函数重写回顾 #

>  *  父类中被重写的函数依然会继承给子类
>  *  子类中重写的函数将覆盖父类中的函数
>  *  通过作用域分辨符 (::) 可以访问到父类中的函数

void code()
    {
        Child c;
        Parent* p = &c;
        
        c.Parent::print();    // 从父类中继承
        c.print();            // 从子类中重写
        
        p->print();           // 从父类中定义
    }

思考：  
为什么要重写父类中的成员函数呢？

答：  
父类中提供的成员函数版本不能满足需求

# 多态的概念和意义 #

>  *  面向对象中期望的行为
>     
>      *  **根据实际的对象类型判断如何调用重写函数**
>  *  父类指针（ 引用 ）指向
>     
>      *  父类对象则调用父类中定义的函数
>      *  子类对象则调用子类中定义的函数

--------------------

>  *  面向对象中多态的概念
>     
>      *  **根据实际的对象类型决定函数调用的具体目标**
>      *   **同样的调用语句在实际运行时有多种不同的表现形态**

![clipboard.png][]

>  *  C++ 语言直接支持多态的概念
>     
>      *  通过 virtual 关键字对多态进行支持
>      *  被 virtual 声明的函数**被重写后具有多态性**
>      *  被 virtual 声明的函数叫做**虚函数**

## 编程实验： 多态初体验 ##

#include <iostream>
    
    using namespace std;
    
    class Parent
    {
    public:
        virtual void print()
        {
            cout << "I'm Parent." << endl;
        }
    };
    
    class Child : public Parent
    {
    public:
        void print()          // 因为继承， 子类中 void print() 也是虚函数
        {
            cout << "I'm Child." << endl;
        }
    };
    
    void how_to_print(Parent* p)
    {
        p->print();          // 展现多态的行为
    }
    
    int main()
    {
        Parent p;
        Child  c;
        
        how_to_print(&p);    // Expected to print: I'm Parent 
        how_to_print(&c);    // Expected to print: I'm Child 
        
        return 0;
    }

输出：
    I'm Parent.
    I'm Child.

>  *  多态的意义
>     
>      *  在程序运行过程中展现出动态的特性
>      *  **函数重写必须多态实现**，否则没有意义
>      *  多态是面向对象组件化程序设计的基础特性

--------------------

>  *  理论中的概念
>     
>      *  静态联编
>         
>          *  在程序的编译期间就能确定具体的函数调用
>             
>              *  如： 函数重载
>      *  动态联编
>         
>          *  在程序实际运行后才能确定具体的函数调用
>             
>              *  如： 函数函数重写

## 实例分析： 动态联编与静态联编 ##

#include <iostream>
    
    using namespace std;
    
    class Parent
    {
    public:
        virtual void func()
        {
            cout << "void func()" << endl;
        }
        virtual void func(int i)
        {
            cout << "void func(int i) : " << i << endl;
        }
        virtual void func(int i, int j)
        {
            cout << "void func(int i, int j)" << "(" << i << ", " << j << ")" << endl;
        }
    };
    
    class Child : public Parent
    {
    public:
        void func(int i, int j)
        {
            cout << "void func(int i, int j) : " << i + j << endl;
        }
    
        void func(int i, int j, int k)
        {
            cout << "void func(int i, int j, int k) : " << i + j + k << endl;
        }
    };
    
    void run(Parent* p)
    {
        p->func(1, 2);          // 展现多态的行为
                                // 动态联编
    }                    
    
    int main()
    {
        Parent p;
        
        p.func();                // 静态联编
        p.func(1);               // 静态联编
        p.func(1, 2);            // 静态联编
        
        cout << endl;
        
        Child c;
        
        c.func(1, 2);             // 静态联编
        
        cout << endl;
        
        run(&p);
        run(&c);
        
        return 0;
    }

输出：
    void func()
    void func(int i) : 1
    void func(int i, int j)(1, 2)
    
    void func(int i, int j) : 3
    
    void func(int i, int j)(1, 2)
    void func(int i, int j) : 3

## 编程实验： 江湖恩怨 ##

#include <iostream>
    #include <string>
    
    using namespace std;
    
    class Boss
    {
    public:
        int fight()
        {
            int ret = 10;
            
            cout << "Boss::fight() : " << ret << endl;
            
            return ret;
        }
    };
    
    class Master
    {
    public:
        virtual int eightSwordKill()
        {
            int ret = 8;
            
            cout << "Master::eightSwordKill() : " << ret << endl;
            
            return ret;
        }
    };
    
    class NewMaster : public Master
    {
    public:
        int eightSwordKill()
        {
            int ret = Master::eightSwordKill() * 2;
            
            cout << "Master::eightSwordKill() : " << ret << endl;
            
            return ret;
        } 
    };
    
    void field_pk(Master* master, Boss* boss)
    {
        int k = master->eightSwordKill();
        int b = boss->fight();
        
        if( k < b )
        {
            cout << "Master is killed... " << endl;
        }
        else
        {
            cout << "Boss is killed... " << endl;
        }
    }
    
    int main()
    {
        Master master;
        Boss boss;
        
        cout << "Master vs Boss" << endl;
        
        field_pk(&master, &boss);
        
        cout << "NewMaster vs Boss" << endl;
        
        NewMaster newMaster;
        
        field_pk(&newMaster, &boss);
    
        return 0;
    }

输出：
    aster vs Boss
    Master::eightSwordKill() : 8
    Boss::fight() : 10
    Master is killed...
    NewMaster vs Boss
    Master::eightSwordKill() : 8
    NewMaster::eightSwordKill() : 16
    Boss::fight() : 10
    Boss is killed...

# 小结 #

>  *  函数重写只可能发生在父类与子类之间
>  *  根据实际对象的类型确定调用的具体函数
>  *  virtual 关键字是 C++ 中支持多态的唯一方式
>  *  被重写的虚函数可表现出多态的特性

以上内容参考狄泰软件学院系列课程，请大家保护原创！

[clipboard.png]: /images/20220302/3330f6d0ccd642e68a691c3e7616644d.png