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 );
}