第49课多态的概念和意义

本文内容来自于对狄泰学院 唐佐林老师 C++深度解析 课程的学习总结

---

多态的概念和意义

面向对象中期望的行为：

根据实际的对象类型判断如何调用重写函数

父类指针（引用）指向

父类对象则调用父类中定义的函数
子类对象则调用子类中定义的重写函数

面向对象中的多态的概念

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

C++ 语言直接支持多态的概念

通过使用 virtual 关键字对 多态 进行支持
被 virtual 声明的函数 被重写后具有多态特性
被 virtual 声明的函数叫做 虚函数

通过上一次课的学习，我们知道 子类对象存在赋值兼容 问题，那么通过多态可以很好的解决这个问题
实验代码：

将父类中的 printf 函数加上 virtual 关键字，实现多态特性

#include <iostream>

using namespace std;

class Parent
{
public:
    virtual void printf()
    {
        cout << "I'm Parent" << endl;
    }
};

class Child : public Parent
{
public:
    int m_i;
    void printf()
    {
        cout << "I'm Child" << endl;
    }
};


void print(Parent *p)
{
    p->printf();
}


int main()
{
    Child cc;
    Parent pp;

    print(&pp);
    print(&cc);

    return 0;
}

运行结果

实现结果，通过虚函数实现了多态的特性

多态的意义

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

理论中的概念

实验代码1
测试静态联编和动态联编

#include <iostream>

using namespace std;

class Parent
{
public:
    int m_i;
    virtual void func(int i, int j)
    {
        m_i = i + j;
        cout << "Parent func(int i, int j)" << endl;
    }
    void func(int i)
    {
        m_i = i;
         cout << "Parent func(int i)" << endl;
    }
};

class Child : public Parent
{
public:
   int m_i;
   void func(int i, int j)
   {
       m_i = i + j;
       cout << "Child func(int i, int j)" << endl;
   }

   void func(int i, int j, int m)
   {
       m_i = i + j + m;
       cout << "Child func(int i, int j, int m)" << endl;
   }
};


void func(Parent *p)
{
    p->func(1, 2);    /*动态联编，多态特性*/
}


int main()
{
    Parent pp;

    pp.func(10);    /* 静态联编 */

    Child cc;

    cc.func(10, 20, 30);   /* 静态联编 */

    func(&pp);
    func(&cc);

    return 0;
}

运行结果

实验代码2

#include <iostream>

using namespace std;

class Boss
{
public:
    int BossFightKill(void)
    {
        int ret = 10;
        cout << "Boss kill: " << ret << endl;
        return ret;
    }
};

class Master
{
public:
    virtual int MasterFightKill(void)
    {
        int ret = 8;
        cout << "Master kill: " << ret << endl;
        return ret;
    }
};

class NewMaster : public Master
{
public:
    int MasterFightKill(void)
    {
        int ret = 2 * Master::MasterFightKill();
        cout << "NewMaster kill : " << ret << endl;
        return ret;
    }
};


void BossMasterPK(Boss *b, Master *m)
{
    int b_kill = b->BossFightKill();
    int m_kill = m->MasterFightKill();

    if(b_kill > m_kill)
    {
        cout << "Boss kill Master" << endl;
    }
    else
    {
        cout << "Master kill Boss" << endl;
    }
    
}

int main()
{
    Boss b;
    Master m;

    BossMasterPK(&b, &m);

    NewMaster nm;

    BossMasterPK(&b, &nm);

    return 0;
}

运行结果

---

小结

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