多态的C语言实现版本

   #ifndef _51_2_H
   #define _51_2_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<stdio.h>
   #include"51-2.h"
   #include<malloc.h>
   //定义父子类的虚函数
   static int Demo_virtual_add(Demo*pthis,int value);
   static int Derived_virtual_add(Derived*pthis,int value);
   //2。确定虚函数表的类型，虚函数表的结构体,用来创建虚函数表，存储虚函数地址
   //目的是为了实现add函数的多态
   struct vtbl{
      int(*padd)(Derived*,int);//3。函数指针的定义
  };
  struct classdemo{
      struct vtbl* vptr;//1。定义虚函数表指针，指针的类型
      int mi;
      int mj;
  };
  static struct vtbl g_Demo_vtbl = {
      Demo_virtual_add
  };//4。全局虚函数表变量,static关键字将该变量隐藏在此文件中,外部不能访问
  static struct vtbl g_Derived_vtbl = {
      Derived_virtual_add
  };
  struct classderived{
      struct classdemo d;
      int mk;
  };
  Demo* Demo_create(int i,int j){
      struct classdemo* ret = (struct classdemo*)malloc(sizeof(struct classdem    o));//分配空间
      if(ret != NULL){
          ret->vptr = &g_Demo_vtbl;//5。将虚函数表和具体对象关联起来
          ret->mi = i;
          ret->mj = j;
      }
      return ret;
  }
  int Demo_geti(Demo*pthis){//具体实现函数  强制类型转换
      struct classdemo* obj = (struct classdemo*)pthis;
      return obj->mi;
  }
  int Demo_getj(Demo*pthis){
      struct classdemo* obj = (struct classdemo*)pthis;
      return obj->mj;
  }
  //6。分析、实现具体的虚函数
  static int Demo_virtual_add(Demo*pthis,int value){
      struct classdemo* obj = (struct classdemo*)pthis;
      return obj->vptr->padd(pthis,value);
  }
  int Demo_add(Demo*pthis,int value){
      struct classdemo* obj = (struct classdemo*)pthis;
      return obj->mi + obj->mj + value;
  }
  void Demo_free(Demo*pthis){
      free(pthis);
  }
  Derived*Derived_create(int i,int j,int k){
      struct classderived* ret = (struct classderived*)malloc(sizeof(struct cl    assderived));
      if(ret != NULL){
          ret->d.vptr = &g_Derived_vtbl;//关联到子类的虚函数表上去
          ret->d.mi = i;
          ret->d.mj = j;
          ret->d.mi = i;
          ret->d.mj = j;
          ret->mk = k;
      }
      return ret;
  }
  int derived_getk(Derived* pthis){
      struct classderived* obj = (struct classderived*)pthis;
      return obj->mk;
  }
  static int Derived_virtual_add(Derived*pthis,int value){
      struct classderived* obj = (struct classderived*)pthis;
      return obj->mk + value;
  }
  int Derived_add(Derived*pthis,int value){
      struct classderived* obj = (struct classderived*)pthis;
      return obj->d.vptr-> padd(pthis,value);
  }

   #include<stdio.h>
   #include"51-2.h"
   void run(Demo*p,int v){
       int r = Demo_add(p,v);
       printf("r=%d\n",r);
   }
   int main(){
       Demo* pb = Demo_create(,);
       Demo* pd = Derived_create(,,);

      printf("Demo_add(3)=%d\n",Demo_add(pb,));
      printf("Derived_add(3)=%d\n",Derived_add(pd,));

      run(pb,);
      run(pd,);
      Demo_free(pb);
      Demo_free(pd);
      return ;
  }