c++-多态的学习

多态的基本介绍

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

#define _crt_secure_no_warnings
#include <iostream>
#include <string>

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 <iostream>


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;
}