C模擬實現C++的多態

#include"iostream"
using namespace std;

void foo1()
{
 printf( "基類 foo1 \r\n" );
}

void foo2( int i )
{
 cout<<"foo2"<<endl;
}

void foo3( int i, int j )
{
 cout<<"foo3"<<endl;
}

// 虛表，包含了虛函數的指針
typedef struct Vtbl
{
 void (*pf1)();
 void (*pf2)( int );
 void (*pf3)( int, int );
}Vtbl;

// 類的虛表,初始化
Vtbl g_vtbl = { foo1, foo2, foo3};

// 基類，開始處是虛表指針，
// 後面是結構成員。
typedef struct Anything
{
 //Vtbl *pvtbl;
 void *pvtbl;
 int field1;
 int field2;
}Anything;

// 構造函數，是一個普通的成員函數，需要一個this指針
void InitAnything( Anything *p )
{
 p->pvtbl = &g_vtbl;
 p->field1 = 0x1234;
 p->field2 = 0x5678;
}

// 子類中的虛函數，重載了父類中的同類型函數
void Sfoo1()
{
 printf( "子類 foo1 \r\n" );
}

void Sfoo4( char *s )//子類新增的虛函數
{
 printf( "子類 hello %s\r\n", s );
}

// 子類中的虛函數表，因為內存布局是一樣的， 直接使用父類的
typedef struct SVtbl
{
 Vtbl vtbl;
 void (*pf4)( char * );
}SVtbl;

SVtbl g_svtbl = { { Sfoo1, foo2, foo3}, Sfoo4};//子類的虛表，初始化

// 某個子類，包含父類的內容（繼承）

typedef struct Something
{
 Anything a;//包含父類的內容（繼承）
 int field3;// 自己的成員
}Something;

// 子類的構造函數，是一個普通的成員函數，需要一個this指針
void InitSomething( Something *p )
{
 InitAnything( (Anything*)p );
 
 p->a.pvtbl = &g_svtbl;
 p->field3 = 0xabcd;
}

void TestPolymorphism( Anything *p )
{
// 雖然使用的是父類型的指針，但虛函數最終會根據對象的真實類型調用。
// (*((Vtbl*)p->pvtbl)->pf1)();
 ((Vtbl*)p->pvtbl)->pf1(); //用函數指針調用函數，2種方法
}

//void TestVtbl()
void main()
{
 Something s;// 子類的一個對象
 Anything *p = 0;//基類指針

 // 初始化
 InitSomething( &s );//子類的構造函數

 p = (Anything*)&s;//子類的指針強制轉為基類指針

 // 調用Sfoo4
 ((SVtbl*)p->pvtbl)->pf4( "Sfoo4" );

 // 測試多態
 TestPolymorphism( (Anything*)&s );
}