继承与多态---上 --- 函数重写、多态、虚函数、覆盖、隐藏

函数重写

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

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

如下图所示：

下面调用这两个prinft函数：

当函数重写遇上赋值兼容性原则：

问题所在：
1、C++与C相同，是静态编译型语言。即编译时变量和类型必须非常清晰。
2、在编译时，编译器自动根据指针的类型判断指向的是一个什么样的对象。
3、所以编译器认为父类指针指向的是父类对象（根据赋值兼容性原则，这个假设合理）。
4、由于编译的时候程序没有运行，所以不可能知道父类指针指向的具体是父类对象还是子类对象。
5、从程序安全的角度，编译器假设父类指针只指向父类对象，因此编译的结果为调用父类的成员函数，编译器认为最安全的做法是编译到父类的print函数。

下图所示：

上面的程序中，后面两个print都是父类中的函数，输出的内容都是I’m Parent，因为编译器把后面两个绑定到父类的成员函数上。
在编译这个函数的时候，编译器不可能知道指针 pp 究竟指向了什么。但是编译器没有理由报错。于是，编译器认为最安全的做法是编译到父类的print函数。

多态的本质

面向对象的新需求：
1、根据实际的对象类型来判断重写函数的调用，而不是像上面那样编译器调用父类的函数。
2、如果父类指针指向的是父类对象则调用父类中定义的函数。
3、如果父类指针指向的是子类对象则调用子类中定义的重写函数。

虚函数

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

当需要根据实际的对象类型来判断调用的是父类的重写函数还是子类的重写函数时，需要使用虚函数，在父类和子类的重写函数前加上virtual关键字，在父类的重写函数前加上了virtual，子类的可以省略。

基类的成员函数设为virtual，其派生类的相应的函数也会自动变为虚函数。

举例说明：

#include <cstdlib>
#include <iostream>

using namespace std;

class Boss
{
private:
    static Boss* cInstance;   //单例对象 
    Boss()
    {
    }
public:
    static Boss* GetInstance()
    {
        if( cInstance == NULL )
        {
             cInstance = new Boss();
        }
        return cInstance;
    }
    int fight()
    {
        cout<<"Boss::fight()"<<endl;
        return 10;
    }
};

Boss* Boss::cInstance = NULL;//初始化 

class Master
{
public:
    virtual int eightSwordKill()//虚函数 
    {
        cout<<"Master::eightSwordKill()"<<endl;
        return 8;
    }
};

class NewMaster : public Master
{
public:
    virtual int eightSwordKill()//虚函数 
    {
        cout<<"NewMaster::eightSwordKill()"<<endl;
        return Master::eightSwordKill() * 2;
    }
};

void fieldPK(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;
    }
    cout<<endl;
}

int main(int argc, char *argv[])
{
    Boss* boss = Boss::GetInstance();

    cout<<"Master vs Boss"<<endl;
    Master master;
    fieldPK(master, boss);

    cout<<"New Master vs Boss"<<endl;   
    NewMaster newMaster;
    fieldPK(newMaster, boss);

    cout << "Press the enter key to continue ...";
    cin.get();
    return EXIT_SUCCESS;
}

小结

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