软件开发-用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.0n”);

}

//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;