用C语言实现面向对象的编程方式

主要利用结构体和函数指针，实现面向对象编程中的封装、继承和多态；

//base.h

typedef struct BaseClass

{

    int m_Data;

 void *pComponentPrivate; //指向子类结构体的指针

 

 void (*GetComponentVersion)();

//声明虚函数  

//指针参数，相当于C++成员函数隐含的this指针

    int (*GetParameter)(void* hComponent);

  

    void (*SetParameter)(void* hComponent, int nData);

    void (*ComponentDeInit)(void* hComponent);

}BaseClass;

//对于父类中声明的每个虚函数

//都定义一个具体的实现宏，以实现

//对不同子类的实现函数的统一调用方式

#define ClassGetComponentVersion(hComponent)      ((BaseClass*)hComponent)->GetComponentVersion()

#define ClassGetParameter(hComponent)   ((BaseClass*)hComponent)->GetParameter(hComponent)    /* Macro End */

#define ClassSetParameter(hComponent, nData)  ((BaseClass*)hComponent)->SetParameter(hComponent,nData)    /* Macro End */

//构造函数

void ClassGetHandle(void **pHandle, const char *cComponentName);

//析构函数

void ClassFreeHandle(void *hComponent);

void BaseGetComponentVersion(void);

//base.cpp

#include "stdafx.h"

#include <stdlib.h>

#include <string.h>

#include <stdio.h>

#include "derivedclasstable.h"

#include "base.h"

static int GetParameter(void* hComponent)

{

    BaseClass * pComponent = NULL;    

    pComponent = (BaseClass *)hComponent;

 return pComponent->m_Data;

}

static void SetParameter(void* hComponent, int nData)

{

    BaseClass * pComponent = NULL;    

    pComponent = (BaseClass *)hComponent;

 pComponent->m_Data = nData;

}

void BaseComponentInit(void *hComponent)

{

    BaseClass* pHandle = (BaseClass *)hComponent;

     

 pHandle->m_Data = 3;

 pHandle->pComponentPrivate = NULL;

 pHandle->GetParameter = GetParameter;

    pHandle->SetParameter = SetParameter;

}

//类对象的初始化函数(构造函数)

void ClassGetHandle(void **pHandle, const char *cComponentName)

{

 

    int i = 0;

 BaseClass *pComponent = NULL;

   

    while (NULL != ClassComponentList[i].cComponentName) 

 {

        if (strcmp(cComponentName, ClassComponentList[i].cComponentName) == 0) 

  {

            

            /* Component found */

            break;

        }

        i++;

    }

    

    /* Allocate memory for the component handle which is of the type 

     * OMX_COMPONENTTYPE and fill in the size and version field of the 

     * structure

     */

    *pHandle = NULL;

     //为每一个子类的对象分配内存

    *pHandle = (BaseClass *)malloc (sizeof(BaseClass));

 pComponent = (BaseClass *)(*pHandle);

    pComponent->GetComponentVersion = BaseGetComponentVersion;

   

    //调用子类的初始化函数

    ClassComponentList[i].pComponentInit(*pHandle);   

}

//类的析构函数

void ClassFreeHandle(void *hComponent)

{

    BaseClass* pHandle = (BaseClass *)hComponent;

 if (pHandle->pComponentPrivate != NULL)

 {       

  /* Call the ComponentDeInit function */

    //调用子类的析构函数

  pHandle->ComponentDeInit(hComponent);

 }

    

    free(hComponent);

 pHandle = NULL;

}

void BaseGetComponentVersion()

{

 printf("Version 1.0\n");

}

//derivedclasstable.h

//描述类的结构体数组

typedef struct ClassCOMPONENTLIST 

{

    

    char *  cComponentName;

    

    /* The exported ComponentInit function of the component */

    void  (*pComponentInit)(void * hComponent);

    

} ClassCOMPONENTLIST;

/* external definition for the ComponentTable */

extern ClassCOMPONENTLIST ClassComponentList[];

//derivedclasstable.cpp

#include "stdafx.h"

#include "derivedclasstable.h"

/* Add extrnal ComponentInit function declaration here */

extern void BaseComponentInit(void * hComponent);

extern void Derived1ComponentInit(void * hComponent);

extern void Derived2ComponentInit(void * hComponent);

ClassCOMPONENTLIST ClassComponentList[] = 

{

 {"Base", &BaseComponentInit},

    {"Derived1", &Derived1ComponentInit},

    {"Derived2", &Derived2ComponentInit},

    {NULL, NULL}

};

//derived1.h

//子类的声明

typedef struct DERIVED1_COMPONENT_PRIVATETYPE

{

    int m_Data1;

}DERIVED1_COMPONENT_PRIVATETYPE;

//derived1.cpp

#include "stdafx.h"

#include <stdlib.h>

#include <stdio.h>

#include "base.h"

#include "derived1.h"

static int GetParameter(void* hComponent)

{

 DERIVED1_COMPONENT_PRIVATETYPE* pPrivateStruct;

    BaseClass * pComponent;   

    pComponent = (BaseClass *)hComponent;

 pPrivateStruct = (DERIVED1_COMPONENT_PRIVATETYPE*)pComponent->pComponentPrivate;

 return pPrivateStruct->m_Data1;

}

static void SetParameter(void* hComponent, int nData)

{

 DERIVED1_COMPONENT_PRIVATETYPE* pPrivateStruct;

    BaseClass * pComponent;   

    pComponent = (BaseClass *)hComponent;

 pPrivateStruct = (DERIVED1_COMPONENT_PRIVATETYPE*)pComponent->pComponentPrivate;

 pPrivateStruct->m_Data1 = nData;

}

static void ComponentDeInit(void *hComponent)

{

    BaseClass* pHandle = (BaseClass *)hComponent;

    free(pHandle->pComponentPrivate);

 pHandle->pComponentPrivate = NULL;  

}

void Derived1ComponentInit(void *hComponent)

{

    BaseClass* pHandle = (BaseClass *)hComponent;

    DERIVED1_COMPONENT_PRIVATETYPE* pPrivateStruct;

     

    /* if need any private data, allocate here  */

    pHandle->pComponentPrivate = NULL;

    //TODO: Need more clarity _disibledevent= NULL;

 return 0;

}