用C进行面向对象编程 (用C模拟继承，多态)

最近在开发浏览器，编程语言是C。由于DOM明显是有层次结构，如：

node <---------------textNode

/|/

|

|

elment

用面向过程的C来开发，有点吃力。所以决定牺牲部分性能，用C模拟面向对象的开发，使程序的结构更加清晰一点。

要考虑到问题:

1. 如何定义一个类 (包括考虑继承性的问题，如何定义接口，如何定义成员)

2. 对象的创建与销毁 (构造函数，析构函数)

3. 多态 (定义虚接口)

花了一天实现了几个相对比较简单的接口，但是对我们的项目组而已，已经足够。

下面的demo

1. 定义图形类

/** 图形类接口实现 **/
static void graphicType (OBJ obj, int argN, DATA* argL)
{
printf ("this is graphic %d %d/n", argL[0], argL[1]);
}

/** 图形类接口 **/
if_attribute graphicIfs[] = {
{"type", graphicType, 2}
};

/** 图形类成员 **/
mem_attribute graphicMember[] = {
{"positionX"}
};

/** 定义图形类 **/
class_attribute graphic = {
"CGraphic",
NULL,
NULL,
1,
NULL,
graphicIfs, 1,
graphicMember, 1
};

2.定义圆类，继承 图形类

/** 圆形类构造函数 **/
void CCircle (OBJ obj, int argN, DATA* argL)
{
printf ("构造函数被调用 argN :%d/n", argN);
printf ("参数值: %d %d/n", argL[0], argL[1]);
}

/** 圆形类析构函数 **/
void DCCircle (OBJ obj)
{
printf ("析构函数被调用 DCCircle/n");
}

/** 圆形类接口实现 **/
static void circleType (OBJ obj, int argN, DATA* argL)
{
printf ("this is circle %d %d/n", argL[0], argL[1]);
}

/** 圆形类接口定义 **/
if_attribute circleIfs[] = {
{"type", circleType, 2}
};

/** 圆形类成员定义 **/
mem_attribute circleMembers[] = {
{"positionX"},
{"postionY"}
};

/** 定义圆形类 **/
class_attribute circle = {
"CCircle",          /* 类名 */
"CGraphic",         /* 父类 */
CCircle,            /* 构造函数 */
2,
DCCircle,           /* 析构函数 */
circleIfs, 1,       /* 接口 */
circleMembers, 2    /* 成员 */
};

3.

int main ()
{
OBJ c;

/** 定义类 **/
defineClass (&graphic);
defineClass (&circle);

/** 创建对象 **/
c = newObj ("CCircle", 1000, 21,9000);

/** 证明接口 'type'的多态性 **/
callInterface (c, "type", 20, 20);

/** 调用祖先的接口 **/
callAncestorInterface (c, "CGraphic", "type", 400, 800);

/**访问数据成员 **/
setMember (c, "positionX", 10);
setAncestorMember (c, "CGraphic", "positionX", 20);
printf ("子类成员 %d/n", getMember (c, "positionX"));
printf ("父类成员 %d/n", getAncestorMember (c, "CGraphic", "positionX"));

/** 销毁对象 **/
delObj (c);
return 0;
}

执行完打印出

构造函数被调用 argN :2
参数值: 1000 21
this is circle 20 20
this is graphic 400 800
子类成员 10
父类成员 20
析构函数被调用 DCCircle

总结:

1. 实现了接口的多态

2.实现了数据,接口的继承

3.只能定义堆上的对象，不能定义栈上对象

实现:

头文件 simCpp.h

/******************************************************
/* simCpp.h
/*
/* author: 阿雅
/*
/* about:
/* CPP模拟接口
/*
/******************************************************/
#ifndef SIMCPP_H_2009_4_13
#define SIMCPP_H_2009_4_13

/***  类型定义 ***/
typedef void* OBJ;
typedef void* PRIVATE;
typedef void* DATA;

/***  函数定义 ***/
typedef void (*CONSTRUCT)(OBJ obj, int argN, DATA* argL);
typedef void (*DESTRUCT) (OBJ obj);
typedef void (*VIRTUALIF)(OBJ obj, int argN, DATA* argL);

/** 成员定义 **/
typedef struct mem_attribute {
char* name;
}mem_attribute;

/** 接口定义 **/
typedef struct if_attribute {
char* name;
VIRTUALIF ifBody;
int paramN;
}if_attribute;

/** 类定义 **/
typedef struct class_attribute {
char* name;                 /** 类名 **/
char* father;               /** 父类名称 **/
CONSTRUCT construct;        /** 构造函数 **/
int paramN;                 /** 构造函数参数个数 **/
DESTRUCT destruct;          /** 析构函数 **/
if_attribute* interfaces;   /** 接口集合 **/
int interfaceN;             /** 接口数目 **/
mem_attribute* members;     /** 成员集合 **/
int memberN;                /** 成员数目 **/
}class_attribute;

/*****************************
* 定义一个类
*
* 参数:
* classAttr  [in]      类属性
* 返回:
* 成功返回0，失败返回-1
**/
int defineClass (class_attribute* classAttr);

/*****************************
* 创建新的对象
*
* 参数:
* name  [in]      对象名
* 返回:
* 成功返回对象
**/
OBJ newObj (char* name, ...);

/*****************************
* 销毁对象
*
* 参数:
* obj  [in]      对象
**/
void delObj (OBJ obj);

/*****************************
* 调用接口
*
* 参数:
* obj      [in]      对象
* ifName   [in]      接口名
**/
int callInterface (OBJ obj, char* ifName, ...);

/*****************************
* 调用接口
*
* 参数:
* obj      [in]      对象
* ifName   [in]      接口名
**/
int callAncestorInterface (OBJ obj, char* className, char* ifName, ...);

/*****************************
* 设置私有数据
*
* 参数:
* obj  [in]      对象
**/
void setPrivate (OBJ obj, PRIVATE data);

/*****************************
* 获取私有数据
*
* 参数:
* obj  [in]      对象
**/
PRIVATE getPrivate (OBJ obj);

/*****************************
* 设置数据成员
*
* 参数:
* obj      [in]      对象
* ifName   [in]      成员名
* data     [in]      数据
**/
void setMember (OBJ obj, char* member, DATA data);

/*****************************
* 设置父亲的数据成员
*
* 参数:
* obj      [in]      对象
* father   [in]      父亲
* ifName   [in]      成员名
* data     [in]      数据
**/
void setAncestorMember (OBJ obj ,char* father, char* member, DATA data);

/*****************************
* 访问数据成员
*
* 参数:
* obj      [in]      对象
* ifName   [in]      成员名
**/
DATA getMember (OBJ obj, char* member);

/*****************************
* 访问父亲的数据成员
*
* 参数:
* obj      [in]      对象
* father   [in]      父亲
* ifName   [in]      成员名
**/
DATA getAncestorMember (OBJ obj, char* father, char* member);

/** 嫌接口太长，调用下面这些吧 **/
#define SET_M(o,n,v)    setMember(o,n,(DATA)v)
#define SET_AM(o,a,n,v) setAncestorMember (o ,a, n, (DATA)v)
#define M               getMember
#define AM              getAncestorMember
#define IF              callInterface
#define AIF             callAncestorInterface
#endif

源文件 simCpp.c

/******************************************************
/* simCpp.c
/*
/* author: 阿雅
/*
/* about:
/* CPP模拟接口
/*
/******************************************************/
#include "simCpp.h"
#include "stringKit.h"
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>

struct class_define;

/*** 接口内部定义 ***/
typedef struct if_define {
char* name;
int nameHash;
VIRTUALIF ifBody;
int paramN;
struct if_define* next;
}if_define;

/*** 成员内部定义 ***/
typedef struct mem_define {
char* name;
int nameHash;
struct mem_define* next;
struct class_define* releted;
}mem_define;

/*** 成员实体定义 ***/
typedef struct mem_entity {
char* name;
int nameHash;
DATA data;
struct mem_entity * next;
struct class_define* releted;
}mem_entity;

/*** 类内部定义 ***/
typedef struct class_define {
char* name;
int nameHash;
CONSTRUCT construct;
int paramN;
DESTRUCT destruct;
if_define* interfaces;          /** 接口集合  **/
mem_define* members;            /** 成员集合  **/
struct class_define* inherited; /** 代表父类  **/
struct class_define* next;
}class_define;

/*** 对象内部定义 ***/
typedef struct obj_define {
class_define* related;
DATA privateData;
mem_entity* member;
}obj_define;

/** 函数预声明 **/
static void addNewClass (class_define*);
static void addNewIf (class_define*, if_attribute*, int);
static void addNewMember (class_define*, mem_attribute*, int);
static void delIf (class_define*, char* ifName);
static void inheriteInterface (class_define*, class_define*);
static void constructMember (obj_define*, class_define*);
static void destructMember (obj_define*);
static void copyString (char**, int*, char*);
static if_define* findIf (class_define*, char*);
static class_define* findClass (char*);

/*** 类定义列表 ***/
static class_define* gClassList = NULL;

/*****************************
* 定义一个类
*
* 参数:
* classAttr  [in]      类属性
* 返回:
* 成功返回0，失败返回-1
**/
int defineClass (class_attribute* classAttr)
{
class_define* define = NULL;
class_define* inherited = NULL;

if (classAttr->father) {
/** 查找父类 **/
inherited = findClass (classAttr->father);
if (!inherited) {
return -1;
}
}

/** 初始化类定义 **/
define             = malloc (sizeof (class_define));
define->inherited  = inherited;
define->interfaces = NULL;
define->members    = NULL;
define->destruct   = classAttr->destruct;
define->construct  = classAttr->construct;
define->paramN     = classAttr->paramN;

copyString (&define->name, &define->nameHash, classAttr->name);

if (inherited) {
/** 继承父类的接口 **/
inheriteInterface (define, inherited);
}

/** 定义接口 **/
addNewIf (define, classAttr->interfaces, classAttr->interfaceN);

/** 定义成员 **/
addNewMember (define, classAttr->members, classAttr->memberN);

/** 增加类定义到类列表中 **/
addNewClass (define);
return 0;
}

/*****************************
* 创建新的对象
*
* 参数:
* name  [in]      对象名
* 返回:
* 成功返回对象
**/
OBJ newObj (char* name, ...)
{
obj_define* objDefine = NULL;
class_define* classDefine = NULL;

classDefine = findClass (name);
if (!classDefine) {
return NULL;
}

objDefine = malloc (sizeof (obj_define));
objDefine->privateData = NULL;
objDefine->related = classDefine;
objDefine->member = NULL;

/** 构建对象的成员 **/
constructMember (objDefine, classDefine);

/** 调用用户自定义构造函数 **/
if (classDefine->construct) {
int x = 0;

DATA* argL = NULL;
va_list argl;
va_start (argl, name);
argL = malloc (sizeof (DATA) * classDefine->paramN);

for (x = 0; x < classDefine->paramN; ++x)
{
argL[x] = va_arg (argl, DATA);
}

classDefine->construct (objDefine, classDefine->paramN, argL);
va_end (argl);
free (argL);
}
return objDefine;
}

/*****************************
* 销毁对象
*
* 参数:
* obj  [in]      对象
**/
void delObj (OBJ obj)
{
obj_define* objDefine = obj;
class_define* classDefine = objDefine->related;

if (classDefine->destruct) {
classDefine->destruct (obj);
}

/** 销毁数据成员 **/
destructMember (objDefine);
free (obj);
}

/*****************************
* 调用接口
*
* 参数:
* obj      [in]      类名
* ifName   [in]      接口名
**/
int callInterface (OBJ obj, char* ifName, ...)
{
obj_define* objDefine = obj;
if_define* ifDefine = NULL;
int x = 0;
DATA* argL = NULL;
va_list argl;

ifDefine = findIf (objDefine->related, ifName);
if (!ifDefine) {
return -1;
}

va_start (argl, ifName);
argL = malloc (sizeof (DATA) * ifDefine->paramN);
for (x = 0; x < ifDefine->paramN; ++x)
{
argL[x] = va_arg (argl, DATA);
}

ifDefine->ifBody (objDefine, ifDefine->paramN, argL);
va_end (argl);
free (argL);
return 0;
}

/*****************************
* 调用接口
*
* 参数:
* obj      [in]      对象
* ifName   [in]      接口名
**/
int callAncestorInterface (OBJ obj, char* className, char* ifName, ...)
{
class_define* classDefine = NULL;
obj_define* objDefine = obj;
if_define* ifDefine = NULL;
va_list argl;
DATA* argL = NULL;
int x = 0;

classDefine = findClass (className);
if (!classDefine){
return -1;
}

ifDefine = findIf (classDefine, ifName);
if (!ifDefine) {
return -1;
}

va_start (argl, ifName);
argL = malloc (sizeof (DATA) * ifDefine->paramN);
for (x = 0; x < ifDefine->paramN; ++x)
{
argL[x] = va_arg (argl, DATA);
}

ifDefine->ifBody (objDefine, ifDefine->paramN, argL);
va_end (argl);
free (argL);
return 0;
}

/*****************************
* 设置私有数据
*
* 参数:
* obj  [in]      对象
**/
void setPrivate (OBJ obj, PRIVATE data)
{
obj_define* objDefine = obj;
objDefine->privateData = data;
}

/*****************************
* 获取私有数据
*
* 参数:
* obj  [in]      对象
**/
PRIVATE getPrivate (OBJ obj)
{
obj_define* objDefine = obj;
return objDefine->privateData;
}

/*****************************
* 访问数据成员
*
* 参数:
* obj      [in]      对象
* ifName   [in]      成员名
**/
DATA getMember (OBJ obj, char* member)
{
obj_define* objDefine = obj;
mem_entity* entity = objDefine->member;
int memHash = 0;

HASH_STRING (member, memHash);

while (entity)
{
if ((entity->nameHash == memHash) && (entity->releted == objDefine->related)) {
if (!strcmp (entity->name, member)){
return entity->data;
}
}
entity = entity->next;
}

return NULL;
}

/*****************************
* 访问父亲的数据成员
*
* 参数:
* obj      [in]      对象
* ifName   [in]      成员名
**/
DATA getAncestorMember (OBJ obj, char* father, char* member)
{
obj_define* objDefine = obj;
class_define* classDefine = obj;
mem_entity* entity = objDefine->member;
int memHash = 0;

classDefine = findClass (father);
if (!classDefine)
{
return NULL;
}

HASH_STRING (member, memHash);

while (entity)
{
if ((entity->nameHash == memHash) && (entity->releted == classDefine)) {
if (!strcmp (entity->name, member)){
return entity->data;
}
}
entity = entity->next;
}

return NULL;
}

/*****************************
* 设置数据成员
*
* 参数:
* obj      [in]      对象
* ifName   [in]      成员名
* data     [in]      数据
**/
void setMember (OBJ obj, char* member, DATA data)
{
obj_define* objDefine = obj;
mem_entity* entity = objDefine->member;
int memHash = 0;

HASH_STRING (member, memHash);

while (entity)
{
if ((entity->nameHash == memHash) && (entity->releted == objDefine->related)) {
if (!strcmp (entity->name, member)){
entity->data = data;
return;
}
}
entity = entity->next;
}
}

/*****************************
* 设置父亲的数据成员
*
* 参数:
* obj      [in]      对象
* father   [in]      父亲
* ifName   [in]      成员名
* data     [in]      数据
**/
void setAncestorMember (OBJ obj ,char* father, char* member, DATA data)
{
obj_define* objDefine = obj;
class_define* classDefine = NULL;
mem_entity* entity = objDefine->member;
int memHash = 0;

classDefine = findClass (father);
if (!classDefine)
{
return;
}

HASH_STRING (member, memHash);

while (entity)
{
if ((entity->nameHash == memHash) && (entity->releted == classDefine)) {
if (!strcmp (entity->name, member)){
entity->data = data;
break;
}
}
entity = entity->next;
}
}

/**************************** 内部接口 *********************************/
/** 查找类定义 **/
static class_define* findClass (char* name)
{
int nameHash = 0;
class_define* define = NULL;
HASH_STRING (name, nameHash);

define = gClassList;
while (define)
{
if (define->nameHash == nameHash) {
if (!strcmp (define->name, name)) {
return define;
}
}

define = define->next;
}
return NULL;
}

/** 增加新的类定义 **/
static void addNewClass (class_define* define)
{
define->next = gClassList;
gClassList = define;
}

/** 查找接口 **/
static if_define* findIf (class_define* classDefine, char* ifName)
{
if_define* ifDefine = NULL;
int nameHash = 0;
HASH_STRING (ifName, nameHash);
ifDefine = classDefine->interfaces;
while (ifDefine)
{
if (ifDefine->nameHash == nameHash) {
if (!strcmp (ifName, ifDefine->name)) {
return ifDefine;
}
}

ifDefine = ifDefine->next;
}
return NULL;
}

/** 继承父类接口 **/
static void inheriteInterface (class_define* define, class_define* inherited)
{
if_define* src = NULL;
if_define* dst = NULL;
int x = 0;

src = inherited->interfaces;
while (src) {
dst = malloc (sizeof (if_define));
dst->name     = strdup (src->name);
dst->nameHash = src->nameHash;
dst->ifBody   = src->ifBody;
dst->paramN = src->paramN;
dst->next = define->interfaces;
define->interfaces = dst;
src = src->next;
}
}

/** 增加新的接口定义 **/
static void addNewIf (class_define* classDefine, if_attribute* ifL, int ifN)
{
int x = 0;
int y = 0;
if_define* ifDefine = NULL;
for (x = 0; x < ifN; ++x)
{
if (findIf (classDefine, ifL[x].name)) {
delIf (classDefine, ifL[x].name);
}

ifDefine = malloc (sizeof (if_define));
ifDefine->ifBody = ifL[x].ifBody;
ifDefine->paramN = ifL[x].paramN;
copyString (&ifDefine->name, &ifDefine->nameHash, ifL[x].name);

/** 插入到接口集合中 **/
ifDefine->next = classDefine->interfaces;
classDefine->interfaces = ifDefine;
}
}

/** 删除接口 **/
static void delIf (class_define* classDefine, char* ifName)
{
if_define* ifDefine = NULL;
if_define* pre = NULL;
int nameHash = 0;

HASH_STRING (ifName, nameHash);
ifDefine = classDefine->interfaces;

while (ifDefine)
{
if (ifDefine->nameHash == nameHash) {
if (!strcmp (ifDefine->name, ifName)) {
if (pre) {
pre->next = ifDefine->next;
} else {
classDefine->interfaces = ifDefine->next;
}

free (ifDefine->name);
free (ifDefine);
break;
}
}

pre = ifDefine;
ifDefine = ifDefine->next;
}
}

/** 增加新成员 **/
static void addNewMember (class_define* classDefine, mem_attribute* memL, int memN)
{
class_define* inherited = classDefine->inherited;
mem_define* memDefine = NULL;
mem_define* memInheirted = NULL;
int x = 0;

/** 继承父亲的成员 **/
if (inherited)
{
memInheirted = inherited->members;
while (memInheirted)
{
memDefine = malloc (sizeof (mem_define));
memDefine->releted = memInheirted->releted;
memDefine->next = classDefine->members;
classDefine->members = memDefine;
copyString (&memDefine->name, &memDefine->nameHash, memInheirted->name);
memInheirted = memInheirted->next;
}
}

for (x = 0; x < memN; ++x)
{
memDefine = malloc (sizeof (mem_define));
memDefine->releted = classDefine;
memDefine->next = classDefine->members;
classDefine->members = memDefine;
copyString (&memDefine->name, &memDefine->nameHash, memL[x].name);
}
}

/** 构建对象的成员 **/
static void constructMember (obj_define* objDefine, class_define* classDefine)
{
mem_entity* entity = NULL;
mem_define* memDefine = classDefine->members;

while (memDefine)
{
entity = malloc (sizeof (mem_entity));
entity->name = memDefine->name;
entity->nameHash = memDefine->nameHash;
entity->data = NULL;
entity->next = objDefine->member;
entity->releted = memDefine->releted;
objDefine->member = entity;
memDefine = memDefine->next;
}
}

/** 销毁对象的成员 **/
static void destructMember (obj_define* objDefine)
{
mem_entity* tmp = NULL;
mem_entity* mem_entity = objDefine->member;

while (mem_entity)
{
tmp = mem_entity;
mem_entity = mem_entity->next;
free (tmp);
}
}

static void copyString (char** str, int* hash, char* src)
{
int strHash = 0;
*str = strdup (src);
HASH_STRING (src, strHash);
*hash = strHash;
}

辅助文件 stringKit.h

/******************************************************
/* ministring.h
/*
/* author:aya
/*
/* 字符串相关操作
/******************************************************/
#ifndef MINISTRING_H_2008_12_10
#define MINISTRING_H_2008_12_10
#include <string.h>
#include <stdlib.h>
#include <stdio.h>

#ifdef WIN32
#pragma warning(disable:4996)
#define MINI_SNPRINTF    _snprintf
#define strcasecmp       stricmp
#else
#define MINI_SNPRINTF    snprintf
#endif

/******************************************************
/* 将字符串转成小写
/*/
#define MINI_TO_LOWER(str)/
do/
{/
size_t l = strlen (str);/
size_t x = 0;/
for (x = 0; x < l; ++x)/
{/
if (('A' <= str[x]) && ('Z') >= str[x])/
{/
str[x] = 'a' + (str[x] - 'A');/
}/
}/
}while(0)

/******************************************************
/* 将字符串转成大写
/*/
#define MINI_TO_UPPER(str)/
do/
{/
size_t l = strlen (str);/
size_t x = 0;/
for (x = 0; x < l; ++x)/
{/
if (('a' <= str[x]) && ('z') >= str[x])/
{/
str[x] = 'A' + (str[x] - 'a');/
}/
}/
}while(0)

/* 判断是否空格字符 */
#define IS_WHITE_SPACE(c)/
(((c)==' ')||((c)=='/t')||((c)=='/n')||((c)=='/r'))

/* 判断是否字母或数字 */
#define IS_CHARACTER(c)/
((((c)>='a')&&((c)<='z'))||(((c)>='A')&&((c)<='Z')))

/* 判断是否数字 */
#define IS_NUMBER(c)/
(((c)>='0')&&((c)<='9'))

/* 将字符串转成32位的hash值 */
#define HASH_STRING(str,hash)/
do/
{/
int g = 0;/
char *start = str;/
char *end = str + strlen(str);/
hash = 0;/
while (start < end)/
{/
hash = (hash << 4) + *start++;/
g = (hash & 0xF0000000);/
if (0 != g)/
{/
hash = hash ^ (g >> 24);/
hash = hash ^ g;/
}/
}/
}while(0)

#endif