C语言模拟实现C++继承和多态

C++中的多态

我们知道的是在C++中会维护一张虚函数表，根据赋值兼容规则，我们知道父类的指针或者引用是可以指向子类对象的。如果一个父类的指针或者引用指向父类的对象，会调用父类的函数，如果该父类对象的指针或者引用指向的是子类的对象，而且该子类已经重写了父类的虚函数，则该指针会调用子类的已经重写的虚函数。

//c++中的多态

class A
{
public:
    virtual void fun()//虚函数实现
    {
        cout << "Base A::fun() " << endl;
    }
};

class B:public A
{
public:
    virtual void fun()//虚函数实现,子类中virtual关键字可以没有
    {
        cout << "Derived B::fun() " << endl;
    }
};

void Test1()
{
    A a;//基类对象
    B b;//派生类对象

    A* pa = &a;//父类指针指向父类对象
    pa->fun();//调用父类的函数

    pa = &b; //父类指针指向子类对象，多态实现
    pa->fun();//调用派生类同名函数
}

C语言实现多态
我们可以用一个结构体，这个结构体放的都是函数指针来模拟一个虚表，基类中有一个指向虚表的指针，子类中包含一个基类对象，相当于继承了基类。具体实现看代码：

struct table  //用函数指针去模拟实现一个虚表。
{
    void (*dance)();
    void (*jump)();
};


struct A
{
    struct table *vptr;  //一个虚表指针。
};

void base_dance()
{
    cout << "base dance"<<endl;
}

void base_jump()
{
    cout << "base jump"<<endl;
}

struct table base_table = { base_dance, base_jump};//基类的虚表

struct B
{
    struct A a;  //B中有一个A的对象,相当于继承了A。
};

void derive_dance()
{
    cout << "derive dance"<<endl;
}

void derive_jump()
{
    cout << "derive jump"<<endl;
}

struct table derive_table = { derive_dance, derive_jump }; //子类的虚表

void test()
{
    struct A a;
    a.vptr = &base_table;

    struct B b;
    b.a.vptr = &derive_table;


     struct A *pa;
//基类的指针指向基类，表现基类的动作  
     pa = &a;
     pa->vptr->dance();

//基类的指针指向子类，表现子类的动作  
     pa = (struct A *)&b;
     pa->vptr->dance();
}

int main()
{
    test();

    cout << "hello..."<<endl;
    return 0;
}