c++-多态的学习

多态的基本介绍

• 多态基础
  • 面向对象新求
  • C++编译器提供的多态解决方案
  • 多态意义、多态成立的是三个条件
  • 多态理论基础
• 多态面试题强化
  • 多态的理解
  • C++编译器如何实现多态
  • 重载重写重定义
  • 虚析构函数
  • 可否为每个类的普通成员函数定义为虚函数
  • 构造函数中调用虚函数，能实现多态吗？
  • 虚函数表指针vptr指针分步初始化
  • 父类指针和子类指针步长不一样 和 父类指针指向子类对象 两个不同的概念
• 多态原理探究
  • 总结记忆1：C++编译器提前布局，在类对象中增加vptr指针、虚函数入口地址存虚函数表
  • 总结记忆2： C++编译器并不是区分子类对象和父类对象，而是根据对象指针、找vptr指针，再找虚函数入口，实现迟绑定，支持了多态
• 多态发生的三个必要条件：
  • 要有继承。
  • 要有虚函数重写。
  • 父类指针或引用 指向 子类对象。

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 

using namespace std;


//岳不群
class Yuebuqun
{
public:
    Yuebuqun( string kongfu)
    {
        this->kongfu = kongfu;
    }

    virtual  void fight() //标识修饰一个成员方法是一个虚函数。
    {
        cout << "岳不群" << "使出了" << kongfu << "打人" << endl;
    }

    void print()
    {

    }

    string kongfu;
};

//林平之 继承了 岳不群
class Linpingzhi :public Yuebuqun
{
public:
    Linpingzhi(string kongfu) :Yuebuqun(kongfu)
    {

    }

    //如果说父类中有一个虚函数是fight（ ）， 子类如果去重写这个虚函数。
    void fight()
    {
        cout << "林平之" << "使出了" << kongfu << "打人" << endl;
    }

    void print()
    {

    }
};

class Linghuchong :public Yuebuqun
{
public:
    Linghuchong(string kongfu) :Yuebuqun(kongfu)
    {

    }

    void  fight()
    {
        cout << "令狐冲 " << "使用了" << kongfu << endl;
    }
};

//在全局提供一个打斗的方法
void fightPeople(Yuebuqun *hero)//Yuebuqun *hero = xiaopp;  Yuebuqun *hero = xiaoyy;
{
    cout << "调用打人的方法" << endl;
    hero->fight();//希望传递进来的如果是子类，调用子类的fight
                  //如果传递进来的是父类， 调用父类的fight
                    //这种行为就是 多态行为。
}



int main(void)
{
    Yuebuqun *xiaoyy = new Yuebuqun("葵花宝典");

    //xiaoyy->fight();



    Linpingzhi *xiaopp = new Linpingzhi("僻邪剑谱");
    //xiaopp->fight();

    Linghuchong *xiaoll = new Linghuchong("独孤九剑");

     
    fightPeople(xiaoyy);
    fightPeople(xiaopp);
    fightPeople(xiaoll);
    //编译器默认做了一个安全的处理。 编译认为 不管传递时子类对象还是父类对象，
    //如果统一执行父类d方法 那么是一定可以被成功执行。

    delete xiaoyy;
    delete xiaopp;
    delete xiaoll;

    return 0;
}

多态案例及其意义

#define _CRT_SECURE_NO_WARNINGS
#include 


using namespace std;

//英雄类
//1999
class Hero
{
public:
    virtual int getAd() {
        return 10;
    }
};

//1999
class AdvHero :public Hero
{
public:
    virtual int getAd()
    {
        return 1001;
    }
};

//怪兽类
//1999
class Monster
{
public:
    int getAd() {
        return 1000;
    }
};


//战斗方法
//1999 //写的架构函数，可以调用未来。
void playerFight(Hero *hp, Monster *mp)
{
    //多态对于编译器来讲的，也是一个动态联编，也是一个迟邦定。
    if (hp->getAd() > mp->getAd()) { //hp->getAd 发生了多态
        cout << "英雄胜利， 怪兽被打死" << endl;
    }
    else {
        cout << "英雄挂了，怪兽赢了" << endl;
    }
}

//2020年
class BugHero :public Hero
{
public:
    virtual int getAd()
    {
        cout << "调用了bugHero的方法" << endl;
        return 66666;
    }
};

int main(void)
{
    Hero h;

    Monster m;

    playerFight(&h, &m);


    AdvHero advH;

    playerFight(&advH, &m);


    BugHero bH;

    playerFight(&bH, &m);

    int a = 10;
    int b = 20;

    cout << a << endl;

    if (a > 10) { //迟邦定
        cout << "a>10" << endl;
    }
    else {
        cout << "a < 10" << endl;
    }


    return 0;
}