c++多态下的继承

什么是多态？

给定一个函数接口，实现多种不同的功能。

c++的多态分为两种

静态多态：在函数的编译器就决定了调用哪种调用。（静态绑定）
动态多态：在函数运行期间决定调用哪种方法。

实现多态的两个条件：

1基类中必须要有虚函数，派生类中必须要重写虚函数。
2用基类的指针或者引用去调用虚函数。

#include<iostream>  
using namespace std;  

class A                   //基类
{  
public:  
    void foo()  
    {  
        printf("1\n");  
    }  
    virtual void fun()    //虚函数
    {  
        printf("2\n");  
    }  
};  
class B : public A        //派生类
{  
public:  
    void foo()  
    {  
        printf("3\n");  
    }  
    void fun()            //重写虚函数
    {  
        printf("4\n");  
    }  
};  
int main(void)  
{  
    A a;  
    B b;  
    A *p = &a;  
    p->foo();  
    p->fun();  
    p = &b;             //用基类的 引用去指向派生类
    p->foo();           //不构成多态   调用基类的成员函数
    p->fun();           //满足 重写 和 基类引用调用两个条件   实现多态  调用自己重写的虚函数
    return 0;  
}  

虚函数的重写条件：

1基类中必须声明成虚函数
2在子类中重写的时候函数的原型不能变（返回值类型 函数名 参数列表）

纯虚函数：

用成员前加virtual关键字并在后面加上 =0.

class Base
{
public:
    virtual void fun() =0;
};

纯虚函数注意事项：
1含有纯虚函数的类是抽象类不能实力化出对象。
2纯虚函数在派生类中重写以后才能实例化出对象。

虚函数表：

class Base1
{
public:
    virtual void fun();
};
class Base2
{
public:
     void fun();
};

void funtest()
{
    cout<<sizeof(Base1)<<endl;
    cout<<sizeof(Base2)<<endl;
}
int main()
{
    funtest();

    system("pause");
    return 0;
}

为什么Base1的大小为4而Base2的大小为1？

为什么是1之前的博客说过，为了解决空类的占位问题。那Base1中也没有定义变量成员 ，为什么是4呢？因为Base1存在虚函数，所以对应的存在虚函数列表，而Base1中存在一个指针，指向了这张表，而一个指针的大小就是4，所以这个类的大小就是4。

class B
{
public:
    virtual void fun1();
    virtual void fun12();

private:
    int _b;

};

B的模型

监视窗口的内容

可以看出对象b中包含一个_vfptr（虚表指针），和一个_b(变量)，符合该对象大小为8。虚表指针又指向一个 指针数组 其中包含两个指针[0]和[1]，而这两个指针就是fun1和fun2.

多态继承

多态的单继承

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

    int _b;

};
class D:  public B
{
public:
    virtual void fun1()
    {
        //重写fun1    
        cout<<"D::fun1"<<endl;
    }
    virtual void fun3()
    {
        //新增fun3
        cout<<"D::fun3"<<endl;
    }
    int _d;

};
typedef void (*VF)();
void PrintVF(B& b)
{
    VF* VFptr =  (VF*)(*(int*)(&b));
    while (*VFptr)
    {
        (*VFptr)();
        ++VFptr;
    }
}
int main()
{
    B b;
    D d;
    cout<<sizeof(d)<<endl;
    PrintVF(d);
    system("pause");
    return 0;
}

程序运行结果：

多继承：

多继承模型和可以看成单继承的多次累加，不同的是 多继承的情况下当前类的虚函数时添加在第一个继承类的虚表后面。

虚拟单继承：

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

    int _b;

};
class D: public  virtual B   //改为虚拟继承
{
public:
    virtual void fun1()
    {
        //重写fun1    
        cout<<"D::fun1"<<endl;
    }
    virtual void fun3()
    {
        //新增fun3
        cout<<"D::fun3"<<endl;
    }
    int _d;

};
typedef void (*VF)();
void PrintVF(B& b)
{
    VF* VFptr =  (VF*)(*(int*)(&b));
    while (*VFptr)
    {
        (*VFptr)();
        ++VFptr;
    }
}
int main()
{
    B b;
    D d;
    cout<<sizeof(d)<<endl;
    PrintVF(d);
    system("pause");
    return 0;
}

看一下监视窗口

对象模型：

程序运行结果：

菱形继承：

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

    int _b;

};

class C1:public virtual B
{
public:
    virtual void fun3()
    {
        cout<<"C1::fun3"<<endl;
    }
    int _c1;
};

class C2:public virtual B
{
public:
    virtual void fun4()
    {
        cout<<"C1::fun4"<<endl;
    }
    int _c2;

};
class D: public C1,public C2
{
public:
    virtual void fun5()
    {
        cout<<"D::fun1"<<endl;
    }

    int _d;

};

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

对象d的大小为C1（12）+C2（12）+4 = 28

菱形虚拟继承：

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

    int _b;

};

class C1:public virtual  B  //虚拟继承
{
public:
    virtual void fun3()
    {
        cout<<"C1::fun3"<<endl;
    }
    int _c1;
};

class C2:public virtual B  //虚拟继承
{
public:
    virtual void fun4()
    {
        cout<<"C1::fun4"<<endl;
    }
    int _c2;

};
class D: public C1,public C2
{
public:
    virtual void fun5()
    {
        cout<<"D::fun1"<<endl;
    }

    int _d;

};

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

对象d的大小应为 C1（12）+C2（12）+_d(4)+B(8) = 36