Compiler Explorer

Source code

#include <iostream>

struct TestA {
    virtual void foo1() {
        std::cout << "TestA.foo1\n";
    }
    virtual void foo2() {
        std::cout << "TestA.foo2\n";
    }
    void foo3() {
        std::cout << "TestA.foo3\n";
    }
    long arr[3];
};

struct TestB : TestA {
    virtual void foo1() {
        std::cout << "TestB.foo1\n";
    }
    virtual void foo3() {
        std::cout << "TestB.foo3\n";
    }
    long arr[3];
};

struct TestC : TestB {
    virtual void foo4() {
        std::cout << "TestC.foo4\n";
    }
};

struct TestD : TestA, TestB, TestC {
    void foo1() {
        std::cout << "TestD.foo1\n";
    }
};

// 理解这个需要理解 虚函数继承的实现方式和类对象的内存结构
struct TestAMemory {
    struct TestATable {
        void (*foo1)(); // 指向 TestA.foo1 函数 (offset=16)
        void (*foo2)(); // 指向 TestA.foo2 函数
    };
    TestATable *vptr;
    long arr[3];
};

// 普通继承的内存结构
// 优先定义基类，再定义派生类
struct TestBMemory {
    struct TestBTable {
        void (*foo1)(); // 指向 TestB.foo1 函数 (offset=16)
        void (*foo2)(); // 指向 TestA.foo2 函数 (这里可以看到虚表会拷贝基类全部的虚函数，不管是否重写)
        void (*foo3)(); // 指向 TestB.foo3 函数 (添加自己的虚函数)
    };
    TestBTable *vptr;
    // TestA.arr
    long arra[3];
    // TestB.arr
    long arrb[3];
};

typedef void (*VoidFunc)();

VoidFunc GetVoidFunc(void *ptr, int offset) {
    long *pptr = (long *)ptr;
    long *table = (long *)(*pptr);
    long *func = table + offset;
    return (VoidFunc)(*func);
}

void test() {
    TestA *a = new TestB();
    a->foo1(); // TestB.foo1
    a->foo2(); // TestA.foo2
    a->foo3(); // TestA.foo3

((TestB *)a)->foo1(); // TestB.foo1
    ((TestB *)a)->foo2(); // TestA.foo2
    ((TestB *)a)->foo3(); // TestB.foo3

// TestB的内存结构，这个参考就行了 ... (实际上TestB成员函数地址拿不到的，因为他是编译信息.)
    TestBMemory *bb = (TestBMemory *)(a);
    bb->vptr->foo1(); // TestB.foo1
    bb->vptr->foo2(); // TestA.foo2
    bb->vptr->foo3(); // TestB.foo3

// 修改成员变量
    bb->arra[0] = 111;
    bb->arrb[0] = 222;

// 当基类和派生类定义类相同的字段/函数，那么主要是看当前指针的类型是什么，类型是基类那么就是基类的函数，否则派生类的函数
    std::cout << "(TestA)arr[0]: " << a->arr[0] << "\n";            // (TestA)arr[0]: 111
    std::cout << "(TestB)arr[0]: " << ((TestB *)a)->arr[0] << "\n"; // (TestB)arr[0]: 222

// 同上
    TestAMemory *aa = (TestAMemory *)(new TestA());
    aa->vptr->foo1(); // TestA.foo1
    aa->vptr->foo2(); // TestA.foo2
}

int main() {
    // 多继承vptr会有偏移量
    // 这种继承是不合法的，越是不合法理解越南
    TestD d;

// vptr偏移量0 (基类为TestA)
    GetVoidFunc(&d, 0)(); // TestD::foo1
    GetVoidFunc(&d, 1)(); // TestA::foo2

// vptr偏移量32(基类为TestB)
    GetVoidFunc(((long *)&d) + 4, 0)(); // TestD.foo1
    GetVoidFunc(((long *)&d) + 4, 1)(); // TestA.foo2
    GetVoidFunc(((long *)&d) + 4, 2)(); // TestB.foo3

// vptr偏移量88(基类为TestC)
    GetVoidFunc(((long *)&d) + 11, 0)(); // TestD.foo1
    GetVoidFunc(((long *)&d) + 11, 1)(); // TestA.foo2
    GetVoidFunc(((long *)&d) + 11, 2)(); // TestB.foo3
    GetVoidFunc(((long *)&d) + 11, 3)(); // TestC.foo4

test();
}