c++：多态

多态

从定义来讲，多态按字面意思就是“多种形态”

在面向对象语言中，接口的多种不同的实现方式即为多态。

静态多态&多态多态

静态联编&动态联编

联编：程序调用函数，编译器决定使用那个可执行代码块

静态联编实际上就是函数重载和运算符重载，是在编译过程中进行联编的

动态联编就是在程序运行过程中才动态的确定操作对象。

使用虚函数，在内存与执行速度是需要付出代价的。

• 每个对象都会增大，增大量为虚函数表的空间
• 对每个类，编译器都需要创建一个虚函数地址表。
• 每个函数调用都需要不断地寻址，所以效率不如普通函数调用高。

虚函数

虚函数就是指在基类中声明为virtual并在一个或多个派生类中被重新定义的成员函数

class Base
{
public:
    int b;
    virtual void Fun()
    {
        cout<<"Base"<<endl;
    }
};
class Derive:public Base
{
public:
    int d;
    void Fun()
    {
        cout<<"Derive"<<endl;
    }
};

虚函数重写：当在子类中定义了一个与父类完全相同的虚函数时，则称 子类的这个函数重写也就是覆盖了父类的这个虚函数

比如说在以下场景：

我们买票时，一般都分为成人票和儿童票，我们定义一个成人类，继承一个儿童类，代码如下：

#include <iostream>
using namespace std;
class Person
{
public:
    virtual void BuyTickets()
    {
        cout << "全票"<< endl;
    }
};
class Student:public Person
{
public:
    virtual void BuyTickets()
    {
        cout << "半票" << endl;
    }
};
void Fun(Person& p)
{
    p.BuyTickets();
}
int main()
{
    Person p;
    Student s;
    Fun(p);
    Fun(s);
    system("pause");
    return 0;
}

总结：

当使用基类的指针或引用调用重写的虚函数时，指向父类的调用就是父类的虚函数，指向子类的调用的就是子类的虚函数

实际上可以这样理解，普通函数的调用与类型有关，而多态的调用和对象有关，你是哪一种类的对象就调用该类的虚函数。

多态的条件

• 虚函数的重写
• 是父类的指针或引用

几个注意事项

1. 基类中定义了虚函数，在派生类中该函数始终保持虚函数的特性。规范起见，子类的虚函数也写上virtual。
2. 只有类的成员函数才能被定义为虚函数，静态成员函数不能被定义为虚函数。
3. 如果在类外面定义虚函数，只能在类里面声明时写上virtual，类外定义函数时不能加virtual。
4. 构造，拷贝构造，赋值运算符的重载都不能定义为虚函数，析构函数建议定义为虚函数。
   
   • 原因是：析构函数定义为虚函数，能够保证正确调用自己的析构函数。
5. 友元不能是虚函数，因为友元不是成员函数。
6. 在成员函数的形参后面写上=0，则成员函数为纯虚函数。包含纯虚函数的类叫做抽象类，抽象类并不能实例化出对象。子类继承之后必须强制重写，才能实例化对象。

重写&重定义

• 重写（覆盖）
  
  • 不在同一作用域内，分别在基类与派生类中。
  • 函数名相同/参数相同/返回值相同（协变除外）
  • 基类函数必须有virtual关键字
  • 访问修饰符可不同
• 重定义（隐藏）：
  
  • 不在同一作用域内，分别在基类与派生类中。
  • 函数名相同
  • 在基类和派生类中只要不构成重写就是重定义。
• 重载
  
  • 在同一作用域内
  • 函数名相同
  • 返回值可以不同

单继承对象模型

我们使用虚函数时，可以直接使用，但是底层的事情都是编译器帮我们做了，那么编译器是如何实现的？

给每个对象添加一个隐藏成员

这个隐藏的成员实际上是一个指向函数指针数组的指针。这个函数指针数组指的就是虚函数表。

虚函数表中存储了为类对象进行声明的虚函数的地址。

• 基类对象包含了一个指针，该指针指向基类中所有虚函数的虚函数表。派生类对象将包含一个指向自己的虚函数表的指针。
• 如果派生类重写了虚函数，该虚函数表将保存新函数的地址；没有重写，该虚函数表将保存父类的该虚函数地址。
• 如果派生类定义了自己的虚函数，则该虚函数地址也被加入到自己的虚函数表。

例子：

class Base
{
public:
    int b;
    virtual void Fun1()
    {
        cout << "Base::Fun1()" << endl;
    }
    virtual void Fun2()
    {
        cout << "Base::Fun2()" << endl;
    }
};
class Derive : public Base
{
public:
    int d;
    virtual void Fun3()
    {
        cout << "Derive::Fun3()" << endl;
    }
    virtual void Fun4()
    {
        cout << "Derive::Fun4()" << endl;
    }
};
int main()
{
    Base b;
    b.b = 1;
    Derive d;
    d.b = 1;
    d.d = 2;
    return 0;
}

可以看到，子类与父类各有一张虚函数表，但是这张图可以看到，子类虽然继承了父类的虚函数表，但是自己定义的虚函数并没有被放入虚函数表，原因是因为在该平台(VS2013)下编译器做了优化，导致我们看不到，可以写代码看到：

父类的虚函数表：

子类的虚函数表：

下来我们实验以下重写后的虚函数表：

子类的虚函数表：

可以看到重写了Fun1，继承了Fun2，还有定义自己的虚函数3和4.

多重继承模型

class Base1
{
public:
    int b;
    virtual void Fun1()
    {
        cout << "Base1::Fun1()" << endl;
    }
    virtual void Fun2()
    {
        cout << "Base1::Fun2()" << endl;
    }
};

class Base2
{
public:
    int b2;
    virtual void Fun1()
    {
        cout << "Base2::Fun1()" << endl;
    }
    virtual void Fun2()
    {
        cout << "Base2::Fun2()" << endl;
    }
};
class Derive : public Base1,public Base2
{
public:
    int d;
    virtual void Fun1()
    {
        cout << "Derive::Fun1()" << endl;
    }

    virtual void Fun3()
    {
        cout << "Derive::Fun3()" << endl;
    }
};

子类继承了父类1和父类2，将父类的虚表各自拷贝了一份，重写的就修改。