用C语言语言实现C++语言面向对象中的继承和多态

#include <stdio.h>
#include "demo.h"

void run(Demo* p,int v)
{
     int r=Demo_Add(p,v);

     printf("r=%d\n",r);
}

int main()
{
    Demo* d=Demo_Create(1,2);
    Derived* p=Derived_Create(1,22,333);

    run(d,3);
    run(p,3);

    Demo_Free(d);
    Demo_Free(p);

    return 0;
}

#ifndef _DEMO_H_
#define _DEMO_H_

typedef void Demo;
typedef void Derived;

Demo* Demo_Create(int i,int j);
int Demo_GetI(Demo* pThis);
int Demo_GetJ(Demo* pThis);
int Demo_Add(Demo* pThis,int value);
void Demo_Free(Demo* pThis);


Derived* Derived_Create(int i,int j,int k);
int Derived_GetK(Derived* pThis);
int Derived_Add(Derived* pThis,int value);

#endif

#include <malloc.h>
#include "demo.h"

static int g_Demo_Virtual_Add(Demo* pThis,int value);
static int g_Derived_Virtual_Add(Derived* pThis,int value);

struct VTable  //2.虚函数表，存放父类虚函数和子类虚函数的地址，体现在函数里面就是函数名
{
     int (*pAdd)(void*,int);
};

struct ClassDemo
{
    struct VTable* vptr; //1.虚函数指针 ==>指向虚函数表
    int mi;
    int mj;
};

struct ClassDerivedDemo
{
    struct ClassDemo d;
    int mk;
};

static struct VTable g_Demo_vtbl={ g_Demo_Virtual_Add} ; //父类虚函数地址

static struct VTable g_Derived_vtbl={ g_Derived_Virtual_Add }; //子类虚函数地址


Demo* Demo_Create(int i,int j)
{
    struct ClassDemo* ret=(struct ClassDemo*)malloc(sizeof(struct ClassDemo));

    if(ret!=NULL)
    {
        ret->vptr=&g_Demo_vtbl; //父类在创建的时候，虚函数表指针指向父类的虚函数
        ret->mi=i;
        ret->mj=j;
    }

    return ret;
}

int Demo_GetI(Demo* pThis)
{
   struct ClassDemo* ret=(struct ClassDemo*)(pThis);

   return ret->mi;
}

int Demo_GetJ(Demo* pThis)
{
   struct ClassDemo* ret=(struct ClassDemo*)(pThis);

   return ret->mj;
}

int Demo_Add(Demo* pThis,int value)
{
    struct ClassDemo* ret=(struct ClassDemo*)(pThis);

    return ret->vptr->pAdd(pThis,value);
}

static int g_Demo_Virtual_Add(Demo* pThis,int value)
{
    struct ClassDemo* ret=(struct ClassDemo*)(pThis);

    return ret->mi+ret->mj+value;
}

Derived* Derived_Create(int i,int j,int k)
{
    struct ClassDerivedDemo* ret=(struct ClassDerivedDemo*)malloc(sizeof(struct ClassDerivedDemo));

    if(ret!=NULL)
    {
        ret->d.vptr=&g_Derived_vtbl; //子类在创建的时候，虚函数表指针指向，子类的虚函数
        ret->d.mi=i;
        ret->d.mj=j;
        ret->mk=k;
    }

    return ret;
}

int Derived_GetK(Derived* pThis)
{
    struct ClassDerivedDemo* ret=(struct ClassDerivedDemo*)pThis;

    return ret->mk;
}

static int g_Derived_Virtual_Add(Derived* pThis,int value)
{
    struct ClassDerivedDemo* ret=(struct ClassDerivedDemo*)pThis;

    return ret->mk+value;
}


void Demo_Free(Demo* pThis)
{
    free(pThis);
}