1.c++多态的概念

多态是c++的特征之一

多态的分类：静态多态（静态联编）、动态多态（动态联编）

静态多态（静态联编）：函数入口地址 是在 编译阶段 确定（运算符重载、函数重载）

动态多态（动态联编）：函数入口地址 是在 运行阶段 确定（虚函数）

2.什么是向上类型转换

即：定义一个父类引用或指针指向子类对象，通过父类指针或 引用来操作子类对象

示例代码如下：

#include <iostream>
using namespace std;

class Animal
{
public:
    void sleep(void)
    {
        cout<<"animal 动物在睡觉"<<endl;
    }
};

class Cat:public Animal
{
public:
    void sleep(void)
    {
        cout<<"Cat 猫在睡觉!! 喵喵"<<endl;
    }
};
int main()
{
    //用基类（指针或引用） 保存 子类对象（向上转换）
    Animal *p = new Cat;
    p‐>sleep();//调用的是基类的sleep

    Cat cat;
    Animal &ob = cat;
    ob.sleep();//调用的是基类的sleep
    return 0;
}

可见两次都是打印的基类中的sleep函数，而不是子类中的sleep函数。

 上图也解释了为什么只能打印基类中的sleep函数，因为这个基类指针（引用）只能操作Cat中的基类部分，而不能访问到Cat部分。

3.想用基类指针（引用）访问子类对象中的成员 要使用虚函数

虚函数允许子类重新定义父类中的成员函数，这种方法称为覆盖。即在父类中声明这个函数的时候

使用virtual关键字修饰。

如果一个函数在基类中被声明为 virtual，那么在所有派生类中它都是 virtual 的.

#include <iostream>

using namespace std;
class Animal
{
public:
    //虚函数 本质 是一个函数指针变量
    virtual void sleep(void)
    {
        cout<<"animal 动物在睡觉"<<endl;
    }
};
class Cat:public Animal
{
public:
    virtual void sleep(void)
    {
        cout<<"猫在睡觉!!喵喵"<<endl;
    }
};
int main()
{
    Animal *p = new Cat;
    p‐>sleep();//调用的是cat中sleep
    return 0;
}

 这样就能访问父类中的sleep函数。原因如下：

当一个基类中有虚函数时，里面会产生虚指针，同时会产生一个虚函数表；

没有涉及到继承的时候，虚函数表里面存储的就是当前类里的虚函数入口地址；

当涉及到继承时，子类会继承父类中的虚指针和虚函数表，编译器会自动将子类中的虚函数放入虚函数表中，于是这个虚指针遍历虚函数表时，拿到的就是子类中的虚函数地址；

上图中定义了基类指针 Animal *p = new Cat，然后p‐>sleep()调用函数，此时p的访问也是没有越界的，访问的仍然是Cat中的基类部分，只不过此时虚函数表中保存的是子类sleep函数地址，所以访问的是子类sleep函数。

• :C++的动态捆绑机制是怎么样的？

首先，我们看看编译器如何处理虚函数。 当编译器发现我们的类中有虚函数的时候，编译器会

创建一张虚函数表，把虚函数 的函数入口地址放到虚函数表中，并在类中秘密增加一个虚指针，

这个指针就是 vpointer(缩写 vptr)，这个指针是指向对象的虚函数表。在多态调用的时候，根据 

vptr指针，找到虚函数表来实现动态绑定。

4.虚函数的应用案例（基类指针、引用 作为函数的参数）

 示例代码：

#include <iostream>

using namespace std;
class Base
{
public:
    //虚函数 本质 是一个函数指针变量
    virtual void sleep()
    {
        cout<<"父亲在睡觉"<<endl;
    }
};
class Son1:public Base
{
public:
    void sleep()
    {
        cout<<"Son1在安静睡觉"<<endl;
    }
};
class Son2:public Base
{
public:
    void sleep()
    {
        cout<<"Son2在轻度睡觉"<<endl;
    }
};
class Son3:public Base
{
public:
    void sleep()
    {
        cout<<"Son3在雨声睡觉"<<endl;
    }
};
class Son4:public Base
{
public:
    void sleep()
    {
        cout<<"Son4在鼾声如雷睡觉"<<endl;
    }
};
//以基类指针作为函数参数 函数就可以操作所有子类
void sleepFun(Base &ob)
{
    ob.sleep();
}

int main(int argc, char *argv[])
{
    Son1 ob1;    //初始化子类对象
    Son2 ob2;
    Son3 ob3;
    Son4 ob4;
    sleepFun(ob1);
    sleepFun(ob2);
    sleepFun(ob3);
    sleepFun(ob4);
    return 0;
}