#include"iostream"
using namespace std;

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

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

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

// 虚表，包含了虚函数的指针
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 );
}