C++：继承和多态的对象模型_c++ 多继承对象模型-优快云博客

本文深入探讨了C++中的虚函数表概念及其在不同继承情况下的应用，包括单继承、多继承、菱形继承等场景下的对象模型，并通过代码示例验证了虚函数表的具体内容。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

更多C++知识：c++目录索引

前言

之前两篇博客梳理了继承和多态基本的知识点，下来总结一下C++的对象模型；前两篇博客中提到的继承有单继承，多继承，菱形继承，虚继承，虚基表，虚函数，多态等概念，对于这些继承和多态的对象模型，我们逐步进行深究，在深究之前，先来熟悉一下虚函数表

虚函数表

1. 概念

虚函数表是一种数据结构，其为指针数组，数组当中存放的是虚函数的地址（注：不是真正的虚函数地址，后面进行验证），数组的最后一个元素为0

2. 验证虚表

class AA
{
public:
    AA(int a=0)
        :_a(a)
    {}
    virtual void Show()
    {
        cout << "virtual void Show()" << endl;
    }
private:
    int _a;
};

int main()
{
    AA a = 1;

    printf("%p\n", &a);
    int size = sizeof(AA);
    cout << "sizeof(AA):" << size << endl;

    system("pause");
    return 0;
}

这里写图片描述

3. 验证虚表中的内容

typedef void(*FUNC)();
class AA
{
public:
    AA(int a = 0)
        :_a(a)
    {}
    virtual void Show()
    {
        cout << "virtual void Show()" << endl;
    }
private:
    int _a;
};


void PrintVTable(int* vtable)
{
    int i = 0;

    //将虚函数表的内容打印，除最后一个元素
    //查看对应的地址存放的是不是虚函数
    for (i = 0; vtable[i] != 0; i++)
    {
        printf("vtable[%d]:%p-->", i, vtable[i]);
        FUNC f = (FUNC)vtable[i];
        f();
    }
    //验证虚函数表的最后一个元素为0
    printf("vtable[%d]:%p\n", i, vtable[i]);
}

int main()
{
    AA a = 1;

    PrintVTable((int*)(*(int*)&a));

    system("pause");
    return 0;
}

这里写图片描述

单继承下的对象模型

1. 虚函数不重写

/*单继承*/

typedef void(*FUNC)();
class AA
{
public:

    virtual void func1()
    {
        cout << "virtual void func1()" << endl;
    }

    int _aa;
};

class BB :public AA
{
public:

    virtual void func2()
    {
        cout << "virtual void func2()" << endl;
    }

    virtual void func3()
    {
        cout << "virtual void func3()" << endl;

    }

    int _bb;
};

void PrintVTable(int* vtable)
{
    int i = 0;

    //将虚函数表的内容打印，除最后一个元素
    //查看对应的地址存放的是不是虚函数
    for (i = 0; vtable[i] != 0; i++)
    {
        printf("vtable[%d]:%p-->", i, vtable[i]);
        FUNC f = (FUNC)vtable[i];
        f();
    }
    //验证虚函数表的最后一个元素为0
    printf("vtable[%d]:%p\n", i, vtable[i]);
}

int main()
{
    AA aa;
    BB bb;

    aa._aa = 1;
    bb._aa = 2;
    bb._bb = 3;

    PrintVTable((int*)(*(int*)&aa));

    cout << endl << endl;
    PrintVTable((int*)(*(int*)&bb));
    system("pause");
    return 0;
}

内存：

这里写图片描述

对象模型：

这里写图片描述

2. 构成重写

typedef void(*FUNC)();
class AA
{
public:

    virtual void func1()
    {
        cout << "virtual void func1()" << endl;
    }

    int _aa;
};

class BB :public AA
{
public:

    virtual void func1()
    {
        cout << "virtual void func1()" << endl;
    }

    virtual void func2()
    {
        cout << "virtual void func2()" << endl;

    }

    int _bb;
};

void PrintVTable(int* vtable)
{
    int i = 0;

    //将虚函数表的内容打印，除最后一个元素
    //查看对应的地址存放的是不是虚函数
    for (i = 0; vtable[i] != 0; i++)
    {
        printf("vtable[%d]:%p-->", i, vtable[i]);
        FUNC f = (FUNC)vtable[i];
        f();
    }
    //验证虚函数表的最后一个元素为0
    printf("vtable[%d]:%p\n", i, vtable[i]);
}

int main()
{
    AA aa;
    BB bb;

    aa._aa = 1;
    bb._aa = 2;
    bb._bb = 3;

    PrintVTable((int*)(*(int*)&aa));

    cout << endl << endl;
    PrintVTable((int*)(*(int*)&bb));




    system("pause");
    return 0;
}

内存：

这里写图片描述

对象模型：

这里写图片描述

多继承下的对象模型

typedef void(*FUNC)();
class A
{
public:
    virtual void func1()
    {
        cout << "virtual void func1()" << endl;
    }
    int _a;
};

class B 
{
public:
    virtual void func2()
    {
        cout << "virtual void func2()" << endl;
    }
    int _b;

};

class C :public A,public B
{
public:
    virtual void func3()
    {
        cout << "virtual void func3()" << endl;
    }
    int _c;

};


void PrintVTable(int* vtable)
{
    int i = 0;


    for (i = 0; vtable[i] != 0; i++)
    {
        printf("vtable[%d]:%p-->", i, vtable[i]);
        FUNC f = (FUNC)vtable[i];
        f();
    }

    printf("vtable[%d]:%p\n", i, vtable[i]);
}


int main()
{
    A a;
    B b;
    C c;

    a._a = 1;
    b._b = 2;
    c._c = 3;

    PrintVTable((int*)(*(int*)&a));
    cout << endl << endl;


    PrintVTable((int*)(*(int*)&b));
    cout << endl << endl;


    PrintVTable((int*)(*(int*)&c));
    cout << endl << endl;

    PrintVTable((int*)(*(int*)&c) + 4);

    system("pause");
    return 0;

}

内存：

这里写图片描述

对象模型：

这里写图片描述

菱形继承下的对象模型

关于菱形继承没有虚函数的情况，在这里不在画图，在c++:继承中已经探索过，这里只看含有虚函数的菱形继承

class A
{
public:
    virtual void fun1()
    {
        printf("A::virtual void fun(int n)\n");
    }
    int _a;
};

class B :virtual public A//虚继承
{
public:
    virtual void fun2()
    {
        printf("B::virtual void fun(int n)\n");
    }
    int _b;
};

class C :virtual public A//虚继承
{
public:
    virtual void fun3()
    {
        printf("C::virtual void fun(int n)\n");
    }
    int _c;
};

class D :public B, public C
{
public:
    int _d;
};

int main()
{
    A a;
    B b;
    C c;
    D d;

    d._a = 1;
    d._b = 2;
    d._c = 3;
    d._d = 4;
    system("pause");
    return 0;
}

内存：

这里写图片描述

对象模型：

这里写图片描述

关于虚函数的几点总结

单继承：不构成重写

父类和子类各自有个虚表，子类的虚表内包括父类虚表内所有的指针
单继承：构成重写
父类和子类各自有个虚表，子类的虚表内的指针与父类虚表内都不相同
这也是多态能根据指针指向的对象类型决定调用的成员虚函数的原因
多继承：非菱形继承
1. 如果父类都有虚表，则子类会继承所有父类的虚表，并且，先继承哪个父类，子类的虚函数指针就会放在哪个父类对应的虚表中
2. 考虑构成重写的情况时，多继承的重写和单继承的重写规则一样
多继承：菱形继承
1. 虚函数虚继承
  
  如果是虚继承的话，子类的虚表内容只包含自己的虚函数指针，把父类的虚函数指针放在了公共区，并把这个公共区的地址放在了对象的里
2. 菱形继承
  
  ①有几个“含有虚表的父类”，子类就有几个虚表
  
  ②有几个“虚继承同一个类的父类”，子类就有几个虚基表指针
  
  ③子类还包含一个”虚函数虚继承产生的公共区的指针“