学习多重继承和虚继承

多重继承：

• 非虚函数，两个基类存在满足覆盖条件的函数时，派生类无法调用其中任何一个函数。该条件只有一个要求：重名。无论返回值、参数、const类型如何，只要重名，即满足覆盖条件。

虚继承：

1. 伴随虚继承衍生出来了虚基类的概念，当一个B虚继承了A时，A就是B的虚基类，虚基类的概念只存在于虚继承关系两个类之间，当此时C正常继承A时，A相对于C就不是虚基类。
2. 无论虚继承还是虚基类，都与虚函数无关。
3. 使用虚继承时，两个中间类都必须是虚继承于最基类，否则无论虚函数还是非虚函数，都会产生两份函数。

正常使用方法：

1. 两个中间类虚继承与最基类，之后最派生类正常继承于两个中间类；
2. 两个中间类必须保证不同时覆盖某个虚函数或同时覆盖某个非虚函数，否则会造成最派生类调用函数不明确；
3. 此时，最派生类对象会根据这两个中间类的函数实现情况，去选择应该调用的函数，如（2）中所述，最近基类必须无冲突。
4. 其实，此时最派生类所继承的是两个中间类的合集，如下图所示：

非虚继承时对象的结构，虚继承对于对象结构的影响：

非虚继承的类图：

非虚继承的实例的数据结构：

虚继承的类图：

虚继承的实例的数据结构：

输出结果分析：

程序代码：

#include <stdlib.h>

/***
* @author:zanzan101
*/

class A
{
private:
    int data1;
public:
    A():data1(1){}
    void do_something()
    {
        printf("A
");
    }
    virtual void foo()
    {
        printf("A:foo
");
    }
    virtual void func()
    {
        printf("A:func
");
    }
};

class B
{
private:
    int data2;
public:
    B():data2(2){}
    virtual void func(){}
    void do_something(int)
    {
        printf("B
");
    }
};

class C: public A
{
private:
    int data31;
public:
    C():data31(31), A(){}
    virtual void foo()
    {
        printf("C:foo
");
    }
    virtual void to_string()
    {
        printf("this is a C
");
    }
};

class D: public A
{
private:
    int data32;
public:
    D():data32(32), A(){}
    virtual void func()
    {
        printf("D:foo
");
    }    
};

class E: public C, public D
{
private:
    int data33;
public:
    E():data33(33), C(), D(){}
};

class F: public virtual A
{
protected:
    int data4;
public:
    F(): data4(4){}
    void func()
    {
        printf("F:func
");
    }
};

class G: public virtual A
{
private:
    int data5;
public:
    G(): data5(5){}
    void do_something()
    {
        printf("G
");
    }
};

class H: public F, public G
{
private:
    int data6;
    int data7;
    int data8;
public:
    H(): data6(6), data7(7), data8(8){}
    void foo()
    {
        printf("H:foo
");
    }
};
int _tmain(int argc, _TCHAR* argv[])
{
    C c;
    // c.do_something(); 非法！


    E e;
    // 非虚继承时：下面三种调用都是非法的！因为“访问不明确”
    // e.do_something();
    // e.foo();
    // e.func();

    void* buff[10];
    memcpy(buff, &e, sizeof(E));

    printf(">> 查看对象结构：
");
    for(int i = 0; i < sizeof(E)/4; i++)
        printf("%d
", (unsigned int)(buff[i]));
    printf("<< 结束！
");
    
    H h;
    h.do_something();
    h.foo();
    h.func();

    memcpy(buff, &h, sizeof(H));

    printf(">> 查看对象结构：
");
    for(int i = 0; i < sizeof(H)/4; i++)
        printf("%d
", (unsigned int)(buff[i]));
    printf("<< 结束！
");

    A* ptr = &h;
    ptr->do_something();
    ptr->foo();
    ptr->func();

    system("pause");
    return 0;
}

输出结果：

>> 查看对象结构：
4282340
1
31
4282308
1
32
33
<< 结束！
G
H:foo
F:func
>> 查看对象结构：
4282608
4
4283120
5
6
7
8
0
4283140
1
<< 结束！
A
H:foo
F:func
请按任意键继续. . .