c++的多态

什么是多态？

多态：一词最初来源于希腊语，意思是具有多种形式或形态的情形， 在C++语言中多态有着更广泛的含义

这要先从对象类型说起

class Base  
{};  

class Derived1 : public Base  
{};  

class Derived2 : public Base  
{};  

int main()  
{  
    Derived1 pd1 = new Derived1; //pd1的静态类型为Derived1，动态类型为Derived1  
    Base *pb = pd1; //pb的静态类型为Base，动态类型现在为Derived1  
    Derived2 pd2 = new Derived2; //pd2的静态类型为Derived2，动态类型现在为Derived2  
    pb = pd2; //pb的静态类型为Base，动态类型现在为Derived2  

    return 0;  
}  

多态的分类

静态多态：：编译器在编译期间完成的，编译器根据函数实参的类型(可能会进行隐式类型转换)，可推 断出要调用那个函数，如果有对应的函数就调用该函数，否则出现编译错误。

动态多态：动态绑定：在程序执行期间(非编译期)判断所引用对象的实际类型，根据其实际类型调用相应的方 法。
使用virtual关键字修饰类的成员函数时，指明该函数为虚函数，派生类需要重新实现，编译器将实 现动态绑定。

【动态绑定条件】
1、必须是虚函数
2、通过基类类型的引用或者指针调用虚函数(派生类必须对基类的虚函数重写)

说到重写，我们就要知道到底什么是重写

协变：返回值类型不同，基类返回基类的指针或引用，派生类返回派生类的指针或引用。（注意返回值必须是指针/引用，如果只是int/char等类型的话是不构成重写的）

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

虚表

对于有虚函数的类，编译器都会维护一张虚表，对象的前四个字节就是指向虚表的指针

class CTest 
{ 
public:       
    CTest()
    { 
        iTest = 10; 
        cout << "this=" << this << endl;
    }       
    virtual ~CTest()
    {}; 
private:       
    int iTest; 
};
int main()
{
    CTest test;
    cout << sizeof(CTest) << endl;
    system("pause");
    return 0;
}

图中前4个字节保存的是虚表的指针。

在继承体系中：
虚表：
1.存虚函数—>与虚函数在基类中的声明次序有关
2.在基类中，与声明次序有关。在派生类中，先和基类虚函数的次序保持一致，然后如果派生类重写了基类中的某个虚函数，就会替换相同偏移量位置的基类虚函数。
3.如果派生类有新加的虚函数，则把虚函数放在最后的位置，同样的，他的次序也和在派生类的次序相同。
4.多重继承—>派生类新加的虚函数增加到先继承者的虚表后面。

多态的对象模型

多继承：

class B
{
public:
    virtual void FunTest1()//
    {
        cout << "B::FunTest1()" << endl;
    }

    virtual void FunTest2()
    {
        cout << "B::FunTest2()" << endl;
    }

    virtual void FunTest3()
    {
        cout << "B::FunTest3()" << endl;
    }

    int _b;
};

class B1
{
public:
    virtual void FunTest4()//
    {
        cout << "B1::FunTest4()" << endl;
    }

    virtual void FunTest5()
    {
        cout << "B1::FunTest5()" << endl;
    }

    virtual void FunTest6()
    {
        cout << "B1::FunTest6()" << endl;
    }

    int _b1;
};

class D :public B, public B1
{
public:

    void FunTest1()
    {
        cout << "D::FunTest1()" << endl;
    }

    virtual void FunTest4()
    {
        cout << "D::FunTest4()" << endl;
    }

    virtual void FunTest7()
    {
        cout << "D::FunTest7()" << endl;
    }

    int _d;
};

typedef void(*pFun)();//

void FunTest()
{
    D d;
    B& b = d;
    pFun* fun = (pFun*)(*(int*)&b);
    cout << "Base vptr:" << endl;
    while (*fun)
    {
        (*fun)();
        fun++;
    }

    cout << endl << endl;

    B1& b1 = d;
    fun = (pFun*)(*(int*)&b1);
    cout << "D vptr:" << endl;
    while (*fun)
    {
        (*fun)();
        fun++;
    }
}

int main()
{
    cout<<sizeof(D)<<endl;
    FunTest();
    system("pause");
    return 0;
}

菱形继承（虚拟继承）

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