c++多态总结

概述

Parent *p = new Child();//父类指针指向子类对象
p->print();//编译器为了安全会调用父类方法
我们希望父类对象调用父类方法，子类对象调用子类方法。因此，引入多态概念，使用虚函数，实现期望。

函数重写
在子类中定义与父类中原型相同的函数
函数重写只发生在父类与子类之间

class Parent
{
public:
    void print()
    {
        cout<<"Parent:print() do..."<<endl;
    }
};

class Child : public Parent
{
public:
     void print()
    {
        cout<<"Child:print() do..."<<endl;
    }
};
int main01()
{
    run00();

    /*
    Child child;
    Parent *p = NULL;
    p = &child;
    child.print();
    child.Parent::print();
    */

    system("pause");
    return 0;
}

父类中被重写的函数依然会继承给子类
默认情况下子类中重写的函数将隐藏父类中的函数
通过作用域分辨符::可以访问到父类中被隐藏的函数

/*
C/C++是静态编译型语言
在编译时，编译器自动根据指针的类型判断指向的是一个什么样的对象
*/
/*
1、在编译此函数的时，编译器不知道指针 p 究竟指向了什么。
2、编译器没有理由报错。
3、于是，编译器认为最安全的做法是编译到父类的print函数，因为父类和子类肯定都有相同的print函数。
*/

//需求
//如果传一个父类对象，执行父类的print函数
//如果传一个子类对象，执行子类的printf函数

#include <iostream>

using namespace std;

class Parent
{
public:
     void print()
    {
        cout<<"Parent:print() do..."<<endl;
    }
};

class Child : public Parent
{
public:
     void print()
    {
        cout<<"Child:print() do..."<<endl;
    }
};

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

void run00()
{
    Child child;
    Parent* pp = &child;
    Parent& rp = child;

    //child.print();

    //通过指针
    //pp->print();
    //通过引用
    //rp.print();

    howToPrint(&child);
}
int main01()
{
    run00();

    /*
    Child child;
    Parent *p = NULL;
    p = &child;
    child.print();
    child.Parent::print();
    */

    system("pause");
    return 0;
}

多态实现
如果父类指针指向的是父类对象则调用父类中定义的函数
如果父类指针指向的是子类对象则调用子类中定义的重写函数

C++中通过virtual关键字对多态进行支持
使用virtual声明的函数被重写后即可展现多态特性

#include "iostream"
using namespace std;

class HeroFighter 
{
public:

public:
    virtual int ackPower()
    {
        return 10;
    }
};

class AdvHeroFighter : public HeroFighter
{
public:
    virtual int ackPower()
    {
        return HeroFighter::ackPower()*2;
    }
};

class enemyFighter
{
public:
    int destoryPower()
    {
        return 15;
    }
};
void objPK(HeroFighter *hf, enemyFighter *enemyF)
{
    if (hf->ackPower() >enemyF->destoryPower())
    {
        printf("英雄打败敌人。。。胜利\n");
    }
    else
    {
        printf("英雄。。。牺牲\n");
    }
}

void main()
{
    HeroFighter hf;
    enemyFighter ef;

    objPK(&hf, &ef);

    AdvHeroFighter advhf;

    objPK(&advhf, &ef);
    system("pause");
}

多态成立的三个条件
1 要有继承
2 要有函数重写。。。C 虚函数
3 要有父类指针（父类引用）指向子类对象
多态是设计模式的基础，多态是框架的基础

多态的理论基础
1、C++与C相同，是静态编译型语言
2、在编译时，编译器自动根据指针的类型判断指向的是一个什么样的对象；所以编译器认为父类指针指向的是父类对象。
3、由于程序没有运行，所以不可能知道父类指针指向的具体是父类对象还是子类对象
从程序安全的角度，编译器假设父类指针只指向父类对象，因此编译的结果为调用父类的成员函数。这种特性就是静态联编。

重载、重写、多态
函数重载
必须在同一个类中进行
子类无法重载父类的函数，父类同名函数将被名称覆盖
重载是在编译期间根据参数类型和个数决定函数调用
函数重写
必须发生于父类与子类之间
并且父类与子类中的函数必须有完全相同的原型
使用virtual声明之后能够产生多态(如果不使用virtual，那叫重定义)
多态是在运行期间根据具体对象的类型决定函数调用

#include <cstdlib>
#include <iostream>

using namespace std;

class Parent01
{
public:
    Parent01()
    {
        cout<<"Parent01:printf()..do"<<endl; 
    }
public:
    virtual void func()
    {
        cout<<"Parent01:void func()"<<endl;
    }

    virtual void func(int i)
    {
        cout<<"Parent:void func(int i)"<<endl;
    }

    virtual void func(int i, int j)
    {
        cout<<"Parent:void func(int i, int j)"<<endl;
    }
};

class Child01 : public Parent01
{

public:

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

    void func(int i, int j, int k)
    {
        cout<<"Child:void func(int i, int j, int k)"<<" "<<i + j + k<<endl;
    }
};

void run01(Parent01* p)
{
    p->func(1, 2);
}

int main()
{
    Parent01 p;

    p.func();
    p.func(1);
    p.func(1, 2);

    Child01 c;
    //c.func(); 
    c.Parent01::func();
    c.func(1, 2);

    run01(&p);
    run01(&c);

    system("pause");
    return 0;
}

虚函数
1 构造函数不能是虚函数。建立一个派生类对象时，必须从类层次的根开始，沿着继承路径逐个调用基类的构造函数
2 析构函数可以是虚的。虚析构函数用于指引 delete 运算符正确析构动态对象