C++多态

• C++的多态性是通过虚函数来实现的，虚函数允许子类重新定义成员函数，子类重新定义父类的做法被称为覆盖或者重写
  （重写：重写成员函数，重写虚函数才能体现C++多态性）

• 多态与非多态：实质区别是函数地址是早绑定还是晚绑定，如果函数的调用在编译器编译期间就可以确定函数的调用地址，并生成代码是静态的，就说地址是早绑定的，而如果函数调用的地址不能在编译期期间确定，需要在运行时才确定，这就属于晚绑定。

• 封装可以使得代码模块化，继承可以扩展已存在的代码，目的都是为了代码重用，而多态的目的是为了接口重用，即，不论传递过来的究竟是哪个类的对象，函数都能通过同一个接口调用到适应各自对象的实现方法。

• 常见用法：声明基类指针，利用该指针指向任意一个子类对象，调用相应的虚函数，可以根据指向的子类的不同而实现不同的方法，如果没有使用虚函数的话，即没有利用C++多态性，当使用基类指针调用相应的函数的时候，将总被限制在基类函数本身，而无法调用到子类中被重写过的函数。因为没有多态性，函数调用的地址是一定的，而固定的地址将始终调用到同一个函数，就无法实现一个接口，多种方法的目的了。

#include <iostream>
using namespace std;

class A
{
public:
    void foo(){
        printf("1\n");
    }
    virtual void fun(){
        printf("2\n");
    }
};

class B : public A{
public:
    void foo(){
        printf("3\n");
    }
    void fun(){
        printf("4\n");
    }
};

int main(void){
    A a;
    B b;
    A *p = &a;//基类指针指向基类对象
    p->foo();
    p->fun();
    p = &b;//基类指针指向子类对象
    p->foo();//指向一个固定偏移量的函数
    /*
     *指向一个虚函数，每个虚函数都有个虚函数列表，通过虚函数列表找到相
     *应的函数地址，因此根据指向对象的不同，函数地址也不同。
     */
    p->fun();
    system("pause");
    return 0;
}

输出结果如下：

1. 第一个p->foo()和p->fun()的指针是基类指针，指向的又是基类对象，调用的都是基类本身的函数，因此输出结果就是1、2。

2. 第二个p->foo()和p->fun()则是基类指针指向子类对象，p->foo()的指针指向一个固定偏移量的函数，因此此时指向的就只能是基类的foo()函数的代码了，因此输出的结果还是1。而p->fun()指针是基类指针，指向的fun是一个虚函数，由于每个虚函数都有一个虚函数列表，此时p调用fun()并不是直接调用函数，而是通过虚函数列表找到相应的函数地址，因此根据指向的对象不同，函数地址也将不同，这里也将找到对应的子类的fun()函数的地址，因此输出的结果会是子类的结果4。

B *ptr=(B *)&a;
ptr->foo();
ptr->fun();

这是一个用子类的指针去指向一个强制转换为子类地址的基类对象，这两句的输出结果是3，2。

隐藏规则：“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：

1. 如果派生类的函数与基类的函数同名，但是参数不同，此时，不论有无virtual关键字，基类的函数都被隐藏（注意别与重载混淆）。
2. 如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字，此时，基类的函数被隐藏（注意别与覆盖混淆）。

//小结：1、有virtual才可能发生多态现象  
// 2、不发生多态（无virtual）调用就按原类型调用  
#include<iostream>
using namespace std;

class Base{
public:
    virtual void f(float x){
        cout << "Base::f(float)" << x << endl;
    }
    void g(float x){
        cout << "Base::g(float)" << x << endl;
    }
    void h(float x){
        cout << "Base::h(float)" << x << endl;
    }
};

class Derived : public Base{
public:
    virtual void f(float x){
        cout << "Derived::f(float)" << x << endl;//多态、覆盖  
    }
    void g(int x){
        cout << "Derived::g(int)" << x << endl;//隐藏  
    }
    void h(float x){
        cout << "Derived::h(float)" << x << endl;//隐藏  
    }
};

int main(void){

    Derived d;
    Base *pb = &d;
    Derived *pd = &d;
    // Good : behavior depends solely on type of the object  
    pb->f(3.14f);   // Derived::f(float) 3.14  
    pd->f(3.14f);   // Derived::f(float) 3.14  

    // Bad : behavior depends on type of the pointer  
    pb->g(3.14f);   // Base::g(float)  3.14  
    pd->g(3.14f);   // Derived::g(int) 3   

    // Bad : behavior depends on type of the pointer  
    pb->h(3.14f);   // Base::h(float) 3.14  
    pd->h(3.14f);   // Derived::h(float) 3.14  
    system("pause");
    return 0;
}