c++：多态

什么是多态？

多态性（polymorphism）据说最早源自希腊语，从字面上理解就是多种形态，多种形式。具体到C++这种面向对象（OOP）的语言中，其实就是“一种接口，多种实现（方法）”。 
多态可分为静态多态和动态多态，具体的分类情况如下：

静态多态和动态多态的区别其实只是在什么时候将函数实现和函数调用关联起来，是在编译时期还是运行时期，即函数地址是早绑定还是晚绑定的？ 
静态多态是指在编译期间就可以确定函数的调用地址，并生产代码，这就是静态的，也就是说地址是早早绑定的，静态多态也往往被叫做静态联编。 
动态多态则是指函数调用的地址不能在编译器期间确定，必须需要在运行时才确定，这就属于晚绑定，动态多态也往往被叫做动态联编。 
静态多态往往通过函数重载和模版（泛型编程）来实现，具体可见下面代码：

//两个函数构成重载
int add(int a, int b)
{
    return a + b;
}
double add(double a, double b)
{
    return a + b;
}


//函数模板（泛型编程）
template <typename T>           //template <class T>
T add(T a, T b)
{
    return a + b;
}

为什么要有多态？

我们知道C++有封装，继承和多态等几大特性，封装可以使得代码模块化，继承可以在原有的代码基础上扩展，他们的目的都是为了代码重用。而多态则是为了接口重用。也就是说，不论传递过来的究竟是哪个类的对象，函数都能够通过同一个接口调用到适应各自对象的实现方法。 
在具体讲多态之前，我们来看看下面的代码：

class Base {
public:
    void fun()
    {
        cout << "Base::fun()" << endl;
    }
};

class Derived : public Base {
public:
    //void fun()
    //{
    //  cout << "Derived::fun()" << endl;
    //}

};

void FunTest()
{
    Base b;
    Derived d;
    b.fun();//调用基类的fun()打印Base::fun()
    d.fun();//子类继承了基类的fun()且子类本身没有fun(),因此此处还是调用基类的fun()打印Base::fun()
}

int main()
{
    FunTest();
    return 0;
}

此时我们放开了子类中fun函数的注释：

class Base {
public:
    void fun()
    {
        cout << "Base::fun()" << endl;
    }
};

class Derived : public Base {
public:
    void fun()
    {
        cout << "Derived::fun()" << endl;
    }

};

void FunTest()
{
    Base b;
    Derived d;
    b.fun();//调用基类的fun()打印Base::fun()
    d.fun();//子类虽然继承了基类的fun()但是子类本身中fun(),此时构成了重定义，即基类中的fun()被隐藏，因此调用的是子类的fun()打印Derived::fun()
    d.Base::fun();//若想调用基类的fun()需要加类的作用域限定符，打印Base::fun()
}

int main()
{
    FunTest();
    return 0;
}

依旧保持上面的类定义不变，我们试试用指针来调用：

void FunTest()
{
    Base b;
    Derived d;
    Base* pb = &b;
    Derived* pd = &d;
    pb->fun();//pb指向基类，打印Base::fun()
    pd->fun();//pd指向子类，打印Derived::fun()

    pb = &d; pb->fun();//pb指向子类，却打印Base::fun()
    //同理引用也是
    Base& rb = b;
    Derived& rd = d;
    rb.fun();//rb引用基类，打印Base::fun()
    rd.fun();//rd引用子类，打印Derived::fun()

    Base& rd2 = d;//rd2引用子类，却打印Base::fun()
    rd2.fun();
}

int main()
{
    FunTest();
    return 0;
}

我们知道，C++继承中有赋值兼容，即基类指针可以指向子类，那么为什么还会出现基类指针指向子类或者基类对象引用子类对象，却调用基类自己的fun函数打印Base::fun()呢？这就是我们上面讲的静态联编，在编译时期就将函数实现和函数调用关联起来，不管是引用还是指针在编译时期都是Base类的自然调用Base类的fun()。为了避免这种情况，我们引入了动态多态。 
所谓的动态多态是通过继承+虚函数来实现的，只有在程序运行期间(非编译期)才能判断所引用对象的实际类型，根据其实际类型调用相应的方法。具体格式就是使用virtual关键字修饰类的成员函数时，指明该函数为虚函数，并且派生类需要重新实现该成员函数，编译器将实现动态绑定。 
在上面的代码如果我们在基类的fun函数前加virtual即可实现动态绑定：

class Base {
public:
    virtual void fun()
    {
        cout << "Base::fun()" << endl;
    }
};

其他不变，在FunTest函数中就达到我们想要的效果：

void FunTest()
{
    Derived d;

    Base* pb = &d;
    pb->fun();//基类指针pb指向子类，可以打印Derived::fun()
    Base& rb = d;
    rb.fun();//基类对象pb引用子类，可以打印Derived::fun()
}

int main()
{
    FunTest();
    return 0;
}

需要注意的是：【动态绑定条件】 
1、必须是虚函数 
2、通过基类类型的引用或者指针调用虚函数 
缺一不可！！！

另外补充一点：

我们知道C++中虚函数允许子类重新定义成员函数，而子类重新定义父类的做法称为覆盖(override)，或者称为重写。在这里我觉得有必要要明白几个概念的区别：即重载，重写（覆盖），以及重定义（同名隐藏）。 
所谓重载是指在同一作用域中允许有多个同名函数，而这些函数的参数列表不同，包括参数个数不同，类型不同，次序不同，需要注意的是返回值相同与否并不影响是否重载。比如int fun()和void fun()不构成重载，连编译都不过去，给出的提示是无法重载仅按返回类型区分的函数。 
而重写（覆盖）和重定义（同名隐藏）则有点像，区别就是在写重写的函数是否是虚函数，只有重写了虚函数的才能算作是体现了C++多态性，否则即为重定义，在之前的代码中，我们看到子类继承了基类的fun()函数，若是子类没有fun函数，依旧会调用基类的fun函数，若是子类已重定义，则调用自己的fun函数，这就叫做同名隐藏，当然此时如果还想调用基类的fun函数，只需在调用fun函数前加基类和作用域限定符即可。综上他们的关系和区别如下图表明：

纯虚函数

在成员函数的形参后面写上=0，则成员函数为纯虚函数。包含纯虚函数的类叫做抽象类（也叫接口类），抽象类不能实例化出对象。纯虚函数必须在派生类中重新定义以后，派生类才能实例化出对象。

class Person
{
public:
    virtual void Display() = 0; // 纯虚函数
private:
    string _name; // 姓名
};
class Student : public Person
{
    void Display()
    {
        cout << "Student" << endl;
    }
};

int main()
{
    //Person p;不能用抽象类实例化
    Student stu;
}

抽象类往往用于这样的情况，它可以方便我们使用多态特性，且在很多情况下，基类本身生成对象是不合情理的，我们知道所有的对象都是通过类来描绘的，但是反过来却不是这样。并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就要使用抽象类，就像一个水果类可以派生出橘子香蕉苹果等等，但是水果类本身定义对象并不合理也没有必要。

要点

1、派生类重写基类的虚函数实现多态，要求函数名、参数列表、返回值完全相同。(协变除外) 
2、基类中定义了虚函数，在派生类中该函数始终保持虚函数的特性。 
3、只有类的非静态成员函数才能定义为虚函数，静态成员函数和友元函数不能定义为虚函数。 
4、如果在类外定义虚函数，只能在声明函数时加virtual关键字，定义时不用加。 
5、构造函数不能定义为虚函数，虽然可以将operator=定义为虚函数，但最好不要这么做，使用时容 
易混淆。 
6、不要在构造函数和析构函数中调用虚函数，在构造函数和析构函数中，对象是不完整的，可能会 
出现未定义的行为。 
7、最好将基类的析构函数声明为虚函数。(析构函数比较特殊，因为派生类的析构函数跟基类的析构 
函数名称不一样，但是构成覆盖，这里编译器做了特殊处理)。 
8、虚表是所有类对象实例共用的。

最后看一组代码：

class A
{
public:
    virtual void Display()
    {}
};
class B
{
public:
    void Display()
    {}
};

int main()
{
    cout << sizeof(A) << endl;//4
    cout << sizeof(B) << endl;//1
    getchar();
}

我们知道一个空类占一个字节，那为什么加了virtual关键字就变成了4？ 
这是因为每个有虚函数的类或者虚继承的子类，编译器都会为它生成一个虚拟函数表（简称：虚表），表中的每一个元素都指向一个虚函数的地址。（注意：虚表是从属于类的） 
此外，编译器会为包含虚函数的类加上一个成员变量，是一个指向该虚函数表的指针（常被称为vptr），每一个由此类别派生出来的类，都有这么一个vptr。虚表指针是从属于对象的。也就是说，如果一个类含有虚表，则该类的所有对象都会含有一个虚表指针，并且该虚表指针指向同一个虚表。因此这里的4是指针的大小。