虚函数表与动态绑定原理

#include <iostream>
#include <string>

// ========== 实际 C++ 代码（标准写法）==========

class Animal {
public:
    virtual ~Animal() = default;
    virtual std::string sound() const { return "动物叫声"; }
    virtual std::string category() const { return "动物"; }
};

class Dog : public Animal {
public:
    std::string sound() const override { return "汪汪"; }
    std::string category() const override { return "犬科"; }
};

class Cat : public Animal {
public:
    std::string sound() const override { return "喵喵"; }
    std::string category() const override { return "猫科"; }
};

class RobotDog : public Dog {
public:
    std::string sound() const override { return "电子汪汪"; }
    // category() 继承 Dog 的实现
};

// ========== vtable 原理模拟（手工实现动态绑定）==========

struct SimVTable {
    std::string (*sound)(void*);      // 函数指针
    std::string (*category)(void*);
};

struct SimAnimal {
    const SimVTable* vtable;
    std::string name;
};

std::string animal_sound(void* self) {
    return "动物叫声";
}
std::string animal_category(void* self) {
    return "动物";
}

const SimVTable animal_vtable = { animal_sound, animal_category };

std::string dog_sound(void* self) {
    return "汪汪";
}
std::string dog_category(void* self) {
    return "犬科";
}

const SimVTable dog_vtable = { dog_sound, dog_category };

std::string cat_sound(void* self) {
    return "喵喵";
}
std::string cat_category(void* self) {
    return "猫科";
}

const SimVTable cat_vtable = { cat_sound, cat_category };

std::string robot_sound(void* self) {
    return "电子汪汪";
}
// robot_category 不覆盖，用 Dog 的

const SimVTable robot_vtable = { robot_sound, dog_category };

void animal_make_sound(void* animal) {
    const SimVTable* vtable = *(const SimVTable**)animal;
    std::string s = vtable->sound(animal);
    std::string c = vtable->category(animal);
    std::cout << "动物说: " << s << " (类别: " << c << ")" << std::endl;
}

int main() {
    std::cout << "===== 真实 C++ 多态 =====" << std::endl;

    Animal* animals[] = { new Dog(), new Cat(), new RobotDog() };

    for (Animal* a : animals) {
        std::cout << a->sound() << " (类别: " << a->category() << ")" << std::endl;
    }

    for (Animal* a : animals) delete a;

    std::cout << "\n===== 手工 vtable 模拟 =====" << std::endl;

    SimAnimal sim_dog = { &dog_vtable, "旺财" };
    SimAnimal sim_cat = { &cat_vtable, "咪咪" };
    SimAnimal sim_robot = { &robot_vtable, "铁蛋" };

    animal_make_sound(&sim_dog);
    animal_make_sound(&sim_cat);
    animal_make_sound(&sim_robot);

    return 0;
}

#include <iostream>
#include <typeinfo>

class Base {
public:
    virtual ~Base() = default;
    virtual void f() { std::cout << "Base::f()" << std::endl; }
    virtual void g() { std::cout << "Base::g()" << std::endl; }
    int x_ = 10;
};

class Derived : public Base {
public:
    void f() override { std::cout << "Derived::f()" << std::endl; }
    virtual void h() { std::cout << "Derived::h()" << std::endl; }
    int y_ = 20;
};

int main() {
    std::cout << "===== 对象内存分析 =====" << std::endl;

    Base b;
    Derived d;

    std::cout << "sizeof(Base) = " << sizeof(Base)
              << " (vptr " << sizeof(void*)
              << " + int " << sizeof(int)
              << " + padding)" << std::endl;

    std::cout << "sizeof(Derived) = " << sizeof(Derived)
              << " (vptr + Base::int + Derived::int + padding)" << std::endl;

    std::cout << "\n===== 对象地址 =====" << std::endl;
    std::cout << "Base 对象地址: " << &b << std::endl;
    std::cout << "Base::x_ 地址: " << &b.x_ << std::endl;
    std::cout << "Derived 对象地址: " << &d << std::endl;
    std::cout << "Derived::x_ 地址: " << &d.x_ << std::endl;
    std::cout << "Derived::y_ 地址: " << &d.y_ << std::endl;

    std::cout << "\n===== RTTI 类型信息 =====" << std::endl;
    Base* ptr = &d;
    std::cout << "ptr 静态类型: " << typeid(decltype(*ptr)).name() << std::endl;
    std::cout << "ptr 动态类型: " << typeid(*ptr).name() << std::endl;
    std::cout << "ptr == &d? " << (ptr == &d ? "是" : "否") << std::endl;

    return 0;
}