用结构体模拟对象把

这是我写的一个简单的模拟

/***********************************************\
*  cclass.c  c语言模拟的继承和多态
\***********************************************/

#include <stdio.h>
#include <windows.h>

#pragma warning(disable:4113)
#pragma warning(disable:4133)

#define class struct
#define virtual
#define MAX_FUNC    8

typedef void (*PFUNC)(void);

typedef void (*vtable[MAX_FUNC])();

// 基类
class CBase
{
    class    CBase*    this;   // 指向自己的指针
    vtable    vptr;              // 虚拟函数表

    virtual void    (*SetValue)(int value);   // 虚拟函数
    virtual    void    (*ShowValue)();        // 虚拟函数
    int        m_data;                             // 成员变量
};

class CDerived
{
    class CBase*    pBase;    // 继承父类

    vtable    vptr;               // 虚拟函数表

    virtual void    (*SetValue)(int value);   // 虚拟函数
    virtual    void    (*ShowValue)();        // 虚拟函数

    virtual void    (*SetMsg)(char* pMsg);  // 虚拟函数
    virtual void    (*ShowMsg)();              // 虚拟函数
    char    m_msg[256];                          // 子类的成员变量

};

void ShowValue(class CBase* pBase)
{
    printf("%d\n", pBase->m_data);
}

void SetValue(int value, class CBase* pBase)
{
    pBase->m_data = value;
}

void SetMsg(char* pMsg, class CDerived* pDerived)
{
    wsprintf(pDerived->m_msg, "%s", pMsg);
}

void ShowMsg(class CDerived* pDerived)
{
    printf("%s\n", pDerived->m_msg);
}

// 基类构造函数
void CBase(class CBase* pBase)
{
    pBase->this = pBase;
    pBase->SetValue = SetValue;
    pBase->ShowValue = ShowValue;
    pBase->vptr[0] = pBase->SetValue;
    pBase->vptr[1] = pBase->ShowValue;
}

// 子类构造函数
void CDerived(class CDerived* pDerived)
{
    class CBase* pBase = (class CDerived*)pDerived;
    pDerived->pBase = (class CBase*)pDerived;
   
    CBase((class CBase*)pBase);
    pDerived->SetMsg = SetMsg;
    pDerived->vptr[2] = pDerived->SetMsg;
    pDerived->ShowMsg = ShowMsg;
    pDerived->vptr[3] = pDerived->ShowMsg;
}

int main(int argc, char* argv[])
{
      class CBase b1, b2;     
      class CDerived d1, d2;

       CBase(&b1);   // 基类对象1构造
       CBase(&b2);   // 基类对象2构造
       CDerived(&d1);  // 子类对象1构造
       CDerived(&d2);  // 子类对象2构造

       b1.SetValue(3);
       b1.ShowValue();

       b2.SetValue(4);
       b2.ShowValue();  // b1, b2 都调用ShowValue， 但结果不一样，呈现多态

       d1.SetValue(7);
       d1.ShowValue();

       d2.SetValue(8);
       d2.ShowValue();  // d1, d2 继承父类的SetValue, ShowValue， 结果也不一样， 呈现多态

       d1.SetMsg("This is d1.");
       d1.ShowMsg();
      
       d2.SetMsg("This is d2");
       d2.ShowMsg();    // SetMsg, ShowMsg是子类的虚函数，父类无法使用

       CBase(&d1);       // 用基类来构造子类对象
       d1.SetValue(10);
       d1.ShowValue();

       return 0;
}

程序运行结果：
3
4
7
8
This is d1.
This is d2
10

有个电子书你可以看一下，
《Object-Oriented Programming With ANSI-C》

http://www.planetpdf.com/codecuts/pdfs/ooc.pdf

很复杂的工程，以前好像看过：其实C的结构体非常类似于类，不过还是有几点差异：
（1）struct结构体的成员默认是公共的，而非私有
（2）难以实现多态（我个人看法）

各种域的访问，还是要自己来控制，看看当前的那么多脚本的代码就明了
Python等，不都是C编写的。可以研究一下

结构体。3楼代码的思路挺清晰的

linux的源代码里面就用到了大量的面向对象思想。