多态

在类的定义中，前面有virtual关键字的成员函数就是虚函数。

virtual关键字只用在类定义里的函数声明中，写函数体时不用。

构造函数和静态成员函数不能是虚函数。

基类指针指向派生类

派生类的指针可以赋给基类指针。

通过基类指针调用基类和派生类中的同名虚函数时：

(1)若该指针指向一个基类的对象，那么被调用的是基类的虚函数。

(2)若该指针指向一个派生类的对象，那么被调用的是派生类的虚函数。

这种机制叫做"多态"。

    class CBase
    {
    public:
        virtual void SomeVirtualFunction(){}
    };
    class CDerived :public CBase
    {
    public:
        virtual void SomeVirtualFunction() {}
    };
    int main()
    {
        CDerived ODerived;
        CBase*p = &ODerived;
        p->SomeVirtualFunction();//调用哪个函数取决于p指向哪个类的对象。
        return 0;
    }

基类引用派生类对象

派生类的对象可以赋给基类引用

通过基类引用调用基类和派生类中的同名虚函数时:

(1)若该引用引用的是一个基类的对象，那么被调用的基类的虚函数。

(2)若该引用引用的是一个派生类的对象，那么被调用的是派生类的虚函数。

这种机制也叫做“多态”。

    class CBase
    {
    public:
        virtual void SomeVirtualFunction(){}
    };
    class CDerived :public CBase
    {
    public:
        virtual void SomeVirtualFunction() {}
    };
    int main()
    {
        CDerived ODerived;
        CBase&r = ODerived;
        r.SomeVirtualFunction();//调用哪个函数取决于r引用哪种类型的对象。
        return 0;
    }

非构造函数和非析构函数中调用虚函数

    class Base
    {
    public:
        void fun1() { this->fun2; }
        virtual void fun2() { cout << "Base::fun2()" << endl; }
    };
    class Derived :public Base
    {
    public:
        virtual void fun2() { cout << "Derived::fun2()" << endl; }
    };
    int main()
    {
        Derived d;
        Base*pBase = &d;
        pBase->fun1();//输出Derived::fun2(),调用哪一个fun2，取决于指向的对象类型。
        return 0;
    }

在非构造函数和非析构函数中调用虚函数，所调用的虚函数是哪一个取决于其指向的对象类型或者其引用的对象类型。

注意：在析构函数和构造函数中调用虚函数不是多态。编译时即可确定，调用的函数是自己的类或基类中定义的函数，不会等到运行时才决定调用自己的还是派生类的函数。

另外，多态要保证派生函数的形式参数要和基类的相同，派生类的函数可以virtual不进行声明，但是基类的函数如果是用来实现多态的话一定要用virtual声明。

动态的关键在于通过基类指针或引用调用一个虚函数时，编译时不确定到底调用的是基类还是派生类的函数，运行时来确定----这叫“动态联编”。

虚函数表

每一个有虚函数的类(或有虚函数的类的派生类)都有一个虚函数表，该类的任何对象中都放在虚函数表的指针。虚函数表中列出了该类的虚函数地址。

每一个有虚函数的类都会多出来4个字节（具体取决于机器字长），这些多出来的字节就是来放虚函数表的地址的（通常放在类的存储空间的头部）。

多态的函数调用语句被编译成一系列根据基类指针所指向的（或基类引用所引用的）对象中存放的虚函数表的地址，在虚函数表中查找虚函数地址，并调用虚函数的指令。

多态的实现需要额外付出一些时间和空间上的开销。

通过改变虚函数表地址来改变多态时指向的虚函数（帮助理解多态的实现原理）

    #include<iostream>
    using namespace std;
    class A
    {
    public:
        virtual void Func() { cout <<"A::Func" << endl; }
    };

    class B:public A
    {
    public:
        virtual void Func() { cout << "B::Func" << endl; }
    };

    int main(void)
    {
        A a;
        A*pa = new B;
        pa->Func();
        //64位程序指针为8字节
        long long *p1 = (long long*)&a;
        long long *p2 = (long long *)pa;
        *p2 = *p1;
        pa->Func();
        system("pause");
    }

输出结果为:

B::Func

A::Func

这里第二个Func的调用的是A中的Func只是因为我们使用了指针改变了该对象的虚函数表地址。

通过基类的指针删除派生类对象时，通常情况下只调用基类的析构函数，但是删除一个派生类的对象时，应该先调用派生类的析构函数，然后调用基类的析构函数。

解决方法是把基类的析构函数声明为virtual：

派生类的析构函数可以virtual不进行声明

通过基类的指针删除派生类的析构函数，然后调用基类的析构函数。

一般来说，一个类如果定义了虚函数，则应该将析构函数也定义成虚函数。或者，一个类打算作为基类使用，也应该将析构函数定义成虚函数。