C++对象模型-虚函数

• • 虚函数实现原理
  • RTTI (run time type identification)
  • 参考

虚函数实现原理

基本的实现原理可以参考链接，不同编译器实现可以不同。

gcc version 11.2.0 (Homebrew GCC 11.2.0)测试

1. 多重继承并且改写父类中的虚函数

#include <iostream>

class A1 {
public:
    virtual void a() { std::cout << "A1::a" << std::endl; }
    virtual void b() { std::cout << "A1::b" << std::endl; }
    virtual void c() { std::cout << "A1::c" << std::endl; }
    int a1 = 1;
};
class A2 {
public:
    virtual void d() { std::cout << "A2::d" << std::endl; }
    virtual void e() { std::cout << "A2::e" << std::endl; }
    int a2 = 2;
};
// A1::a B::b A1::c [[B::f B::g]]
// B::d  A2::e
// ==>
// A1::a [B::b] A1::c [B:d B:e] [[B:f B:g]]
// thunk:B:d  thunk:B:e
class B : public A1, public A2 {
public:
    virtual void b() { std::cout << "B::b" << std::endl; }
    virtual void d() { std::cout << "B::d" << std::endl; }
    virtual void e() { std::cout << "B::e" << std::endl; }
    virtual void f() { std::cout << "B::f" << std::endl; }
    virtual void g() { std::cout << "B::g" << std::endl; }
    int b3 = 3;
};

int main() {
    B b;
    long *pvptr = (long *)&b;
    long *vptr = (long *)*pvptr;
    typedef void (*pfunc)();
    for (unsigned i = 0; i < 7; ++i) {
        std::cout << std::hex << vptr + i << "  " << vptr[i] << std::endl;
        pfunc pfun = pfunc(vptr[i]);
        pfun();
    }

    std::cout << "---------------------" << std::endl;
    long *vptr2 = (long *)*(long *)((char *)&b + sizeof(A1));
    for (unsigned i = 0; i < 2; ++i) {
        std::cout << std::hex << vptr2 + i << "  " << vptr2[i] << std::endl;
        pfunc pfun = pfunc(vptr2[i]);
        pfun();
    }
    return 0;
}

汇编后，类B的虚函数表结构：

vtable for B:
		.quad   0
		.quad   typeinfo for B
		.quad   A1::a()
		.quad   B::b()
		.quad   A1::c()
		.quad   B::d()
		.quad   B::e()
		.quad   B::f()
		.quad   B::g()
		.quad   -16
		.quad   typeinfo for B
		.quad   non-virtual thunk to B::d()
		.quad   non-virtual thunk to B::e()

其中虚函数表中指向的B类 typeinfo 结构：

typeinfo for B:
		.quad   vtable for __cxxabiv1::__vmi_class_type_info+16
		.quad   typeinfo name for B
		.long   0
		.long   2
		.quad   typeinfo for A1
		.quad   2
		.quad   typeinfo for A2
		.quad   4098

在 GCC 实现中：

• 继承多个有虚函数的父类，派生类就有多个虚表指针，每个虚函数指针都位于基类存储位置中的起始地址(派生类对象中)。所以使用派生类对象向上转型的基类指针可以方便地调用虚函数-找到对应的虚指针。

• 虚表指针指向的虚函数表大致是连续的，每个虚表指针指向的前一个元素是type_info结构体指针，用于实现RTTI(类名和子类信息)，两个表之间是分隔元素(编译器决定)这里是-16。

• 第一个虚表指针指向的虚函数表很重要

  • 存储对应基类(第一个基类)的虚函数，如果子类改写第一个基类的虚函数则代替对应的槽位置(代替为改写的虚函数地址)；
  • 此外，改写其他基类的虚函数也会添加在第一个虚表，派生类新添加的虚函数也会添加到第一个虚表中。

• 其余虚表类似，包含没有被覆盖的虚函数，如果其虚函数被改写了，对应槽位置是一个 thunk 函数，作用是跳转到改写的虚函数地址执行；

想一想为什么这么实现：

可以方便地使用基类的指针来调用虚函数，在派生类被再次继承时，只需要修改它的第一个虚表的内容就作为新的派生类的虚表，实现更加方便。

注意：

存在多个基类时，直接使用派生类指针向上转型时，指针会赋值到该派生对象中该基类的起始地址，因此调用虚函数时，会找到它的虚表指针对应的虚表中的对应位置，如果被override改写会跳转到真实的函数地址实现多态效果。这里的多个虚表指针可以便捷编译器确定在该基类指针下找到对应函数的下标位置(生成虚表时就可以确定)，进而可以调用到实际的函数。

由派生类对象地址向上转型可以确定基类的起始地址，从而可以调用对应的虚函数。如果使用：

void* p = &b; // 派生类地址赋值给void*
A1* pa = p;   // 再赋值给基类指针

这样会使得基类指针指向的位置直接变成派生类的起始地址，如果不是单继承或者第一个基类会出现问题，必须直接使用派生类地址向上转型得到对应基类地址指针。

• 内存对齐问题

在继承体系中，派生类会保存基类的原始布局(包括大小)；如果在满足每个基类的内存对齐情况下gcc允许紧密布局，例如上述类B占用32个字节。

// A1: vptr:8B + sizeof(a1):4B + padding:4B  total:16B
// A2: vptr:8B + sizeof(a2):4B + [sizeof(b3)] total:16B
// B: total:32B (b3直接和A2中的数据紧密布局)

哪些函数不能定义为虚函数？

• 友元函数，它不是类的成员函数

• 全局函数

• 静态成员函数，它没有this指针

• 构造函数，拷贝构造函数以及赋值运算符重载（可以但是一般不建议作为虚函数）

构造函数/析构函数中可以调用虚函数吗？

RTTI (run time type identification)

RTTI，即运行时类型检查，其主要作用：

• 向下类型转换：将父类指针转换为子类指针
  • 异常处理
  • 数据存储

相关的运算符：

1. typeid: 返回type_info结构体的对象（如果没有虚函数实现多态，返回的是静态类型而不是运行时类型的type_info结构体）

2. dynamic_cast: 向下类型转换，成功返回子类指针，失败返回nullptr（如果没有实现多态，编译器报错）

#include <iostream>

class Base {
public:
    virtual ~Base() {}
};
class Derive : public Base {};

int main() {
    Base* pBase = new Derive();
    std::cout << typeid(*pBase).name() << std::endl;

    Derive* pDerive = nullptr;
    if ((pDerive = dynamic_cast<Derive*>(pBase)) != nullptr) {
        std::cout << "dynamic_cast success" << std::endl;
    } else {
        std::cout << "dynamic_cast failed" << std::endl;
    }
    return 0;
}

RTTI的实现原理

虚函数表中vptr[-1]是type_info结构体指针，dynamic_cast也要依据type_info运行，所以使用typeid和dynamic_cast都要有虚函数表，也就是虚函数。

参考

C++在gcc下的单继承，多继承，虚继承的内存布局_LupinLeo的博客-CSDN博客
一览本文目的gcc下不同继承方式的存储模型单继承单继承无重写：单继承重写多重继承多继承无重写：多继承重写：虚继承多重继承无法解决的模型真正的菱形继承尾语本文目的   最近看了《深入探索c++
https://blog.csdn.net/shichao1470/article/details/91563282