如何使用C语言实现面向对象的设计

要是C语言实现面向对象，我们需要做到如下特性：

1，定义一个类：含有属性和方法

2，定义构造函数和析构函数

3，实现继承

4，实现虚函数及多态

上面第一条类体现了面向对象的思想，而后三条是体现面向对象的三个特性：封装，继承，多态。

相信很多人第一次看到这个问题，脑海中一下子没有思路，但仔细想想能想到会用结构体来封装属性，但是把方法放到结构体中似乎在Ｃ语言中是不允许的，那么我们又必须把方法封装进去，这时进一步我们又想到了使用函数指针，然后通过某个函数将函数名赋给这些函数指针就可以给结构体对象调用了。至此我们可以完成第一个任务---定义一个含有属性和方法的类，由于是结构体实现，我们就叫它结构体类。

然后构造函数和析构函数如何实现呢？

既然我们可以定义一个类，并将方法传进去，构造函数是在类声明的时候自动调用的，我们采取指针的形式：

使用C语言实现面向对象的设计 一

一． 使用结构体实现类的功能。
1．1， 封装
#define CLASSNAMEID 100; // 类名对应的ID，在内存管理中使用
struct __classname
{
int classnameID; //该数值必须位于第一
int (*classname_getclassID) ( ); //得到类名对应的ID函数。该函数指针必须位于第一
int (* newclassname) (__classname* classname_this); //建构函数
//功能函数指针：
type (*classname_function1) (arguments, __classname* classname_this);
type (*classname_function2) (arguments, __classname* classname_this);
//type: 数据类型arguments：参数
//属 性变量。
type* classname_property1; //属 性。
type classname_property2;
__classname * classname_this; //每个类中必须包含的指向自身的指针
void (* delclassname) (__classname* this); //析 构函数
}
#typedef __classname classname;
#define CLASSNAME() \ //该宏将在继承中使用。
int classnameID; \
int (*newclassname)(classname*); \
int (*classname_function1)(int,classname*); \
int (*classname_function2)(int,classname*);\
int classname_property2;\
int* classname_property1; \
__classname * classname_this;\
void (* delclassname) (classname*);\
int (*classname_function3) (int,classname*);\

这些用结构体实现的类，我给它取名为结构类。
1.1. 1建构函数的实现
在结构类中的建构函数指针bool (*newclassname) （），其所对应的建构函数的函数名为该建构函数指针的大写形 式，即：
//建构函数执行初始化指针，属性等动 作。
int NEWCLASSNAME(classname* point)
{
point->classname_this= point;
point->classname_function1=Classname_function1;//function指针对应的函数，即为它的首大写
point->classname_property1=malloc(sizeof (type) ) ;
if(point->classname_property1==NULL) return 0; //失败
point->classname_getclassID=Classname_getclassID;
point->classname_property2=…;
point->classname_delclassname=Delclassname;
point->classnameID=CLASSNAMEID;
return 1; //成功
}


使用C语言实现面向对象的设计 二
1.1.2 功能函数的实现
在结构类中的功能函数指针,其所对应的函数名为该函数指针的大写形式。
type Classname_function1 (….,classname* classname_this )
{
classname_this ->classname_property2=…….;
……..
}
1.1.3 析构函数的实现
在结构类中的析构函数指针,其所对应的函数名为该函数指针的大写形式
void Delclassname(classname* classname_this) //执行释放内存的操作。。
{ free(classname_this->classname_property1);
……..
}
1.1.4 得到类的ID函数的实现
void Classname_getclassID( )
{ return CLASSNAMEID; //返回类的ID；
}
1．2 继承
命名规则：子类名_父类名的前三个字符加上最后一个字符_父类名…
同 时从多个父类继承则取各个父类的前三个字符合在一起。
如果前三个字符有相同的，则取第1，2，4个字符，如果第4个还相同，取1，2，5，如果第5个还想同，取1，2，6，依此类推，直到取到不相同的。
例如：从baseclass 继承，派生出childclass,则可以命名为childclass_bass;
如 果从childclass_bass派生 boyclass,则 可以命名为boyclass_chis_bass;
如 果同时从baseclass, childclass_bass, boyclass_chis_bass派生johnclass,则可以命名为johnclass_baschiboy;
有结构类classname,从该类继承一个子类childclass.则该子类可以这样实现


使用C语言实现面向对象的设计 三
＃define CHILDCLASS_CLAEID 101
struct __childclass_clae
{
int childclass_claeID; //该数值必须位于第一
int (*childclass_getclassID) ( ) ; //得到类的ID函数,该函数指针必须位于第一
CLASSNAME( ); //从结构类classname继承。
int (* newchildclass_bass) (__childclass_clae * childclass_clae_this); //建构函数
//功能函数指针：
type (*__childclass_clae _function3) (arguments, __childclass_clae * childclass_clae_this);
type (*__childclass_clae_function4) (arguments, __childclass_clae * childclass_clae_this);
//type: 数据类型arguments：参数
//属 性变量。
type* __childclass_clae _property1; //属 性。
type __childclass_clae _property2;
__childclass_clae * childclass_clae_this;
//每个类中必须包含的指向自身的指 针
void (* delchildclass_clae) (__childclass_clae * childclass_clae_this); //析 构函数
}
typedef __childclass_clae childclass_clae;
int Newchildclass_clae(childclass_clae * point)
{
//对父类classname 进行初始化。
Point->classnameID=CLASSNAMEID;
point->classname_this=(classname*) (&(point->classnameID));
if( ! INITIAL ( point->classname_this ); return 0;
//INITIAL在后面的内存管理2.3中有定义。

//对自身进行初始化
point->childclass_clae_property1=(type*)malloc sizeof(type));
point->childclass_clae_function3=Childclass_clae_function3;
point->childclass_clae_function4=Childclass_clae_function4;
Point->delchidclass_clae=Delchildclass_clae;
………
}
void Delchildclass_clae(childclass_clae * childclass_clae)
{
//释放父类的内存
(*childclass_clae ->delclassname)(childclass_clae->classname_this)
//释放自身的内存
free(childclass_clae->childclass_cale_property1);
…….
}
#define CHILDCLASS_CLAE() \ //该宏将在继承中使用
int childclass_claeID; \
int (*childclass_getclassID) ( ) ;\
CLASSNAME( ); \ //从 结构类classname继承。
int (* newchildclass_bass) (__childclass_clae * childclass_clae_this);\
type(*__childclass_clae_function3)(arguments,__childclass_clae*\
childclass_clae_this); \
type (*__childclass_clae_function4) (arguments, __childclass_clae *\ childclass_clae_this); \
type* __childclass_clae _property1; \
type __childclass_clae _property2; \
__childclass_clae * childclass_clae_this;\
void (* delchildclass_clae) (__childclass_clae * childclass_clae_this);\


使用C语言实现面向对象的设计 四
1． 3多态。
在C语言中的不可能实现真正的多态，可以依靠在函数名上的变化，也 可以通过无参数指针指向有参数函数来实现。
例如，有这个函数int function(int ,char*) ， 可以将之命名为functionicp, i和cp 表示参数为int,char*.依此类推。
function(int,int ,int),命名为functioniii;
所以声明函数就变成如下形式
int classname_functioniii (int,int ,int );
int classname_functionicp (int ,char*);
int classname_functioniicp (int,int,char*);
二． 内存管理
2． 1建立内存分配的全局函数。
void* NEW (int CLASSNAMEID)
{
void* tem;
switch(CLASSNAMEID)
{
case CLASSA:
{
tem=malloc( sizeof (classa) );
(classa*)tem->newclassa=Newclassa;
classa* temp=tem;
if( !( (*(temp->newclassa)) ( (classa*) tem ) ) //调用建构函数
{
free(tem);
return NULL;
}
return tem;
}
case CLASSB:
{
tem=malloc ( sizeof(classb) );
(classb*)tem->newclassa=Newclassa;
classb temp=tem;
if( ! (* (temp->newclassb)) ((classa*) tem ) )
{
free(tem);
return NULL;
}
return tem;
}
case …..
….
}
}


使用C语言实现面向对象的设计 五
2，2建立内存释放的全局函数。
void DELETE(void* object)
{
if ( object == NULL ) return;
switch( *(int* ) object ) //调用classnameID
{
case CLASSA:
{
Delclassa ( ((classa*)object)->delclassa );
//调用析构函数
break;
}
case CLASSB:
{
Delclassb((( classb*)object)->classa_this);
break;
}
case…..
……..
}
free(object); //释放对象
object=NULL;
}
2.3 初始化变量的全局函数
void INITIAL(void* object)
{
if(object == NULL) return ;
switch(*(int*)object)
{
case CLASSA:
{
((classa*)object)->newclassa=Newclassa;
if(!Newclassa((classa*)object)) return 0;
break;
}
case CLASSB:
{
((classb*)object)->newclassb=Newclassb;
if(!Newclassb((class*)object)) return 0;
break;
}
case…….
………..
}
}


使用C语言实现面向对象的设计 六
三 ，示例。
下面有一个完整的例子。在vc.net,win2000 server的环境下编译通过，运行正确。
///
//testchild.cpp.
//
//this code is compiled in Visual c++ .net 2002 .
//run in windows2000 server.
//
//made in 2004.8.8 by Feng
/

#include <stdio.h>
#include <stdlib.h>

int INITIAL(void* object);
void* NEW(int CLASSID);
void DELETE(void* object);

#define CLASSNAMEID 100 // 类名对应的ID，在内存管理中使用
struct __classname
{
int classnameID;
int (* classname_getclassID)(void);

int (* newclassname) (__classname* classname_this);

int (*classname_function1) (int i);
int (*classname_function2) (__classname* classname_this);

int* classname_property1;
int classname_property2;
__classname * classname_this;
void (* delclassname) (__classname* classname_this);
} ;
typedef __classname classname;
int Classname_getclassID()
{
return CLASSNAMEID;
}
int Classname_function1(int i)
{
printf("%d",i);
return 1;
}

int Classname_function2(classname* classname_this)
{
printf("%d",classname_this->classname_property2);
return 1;
}
void Delclassname(classname* classname_this)
{
free((classname_this->classname_property1));
printf("free is ok");

}
int Newclassname(classname* point)
{
point->classname_this=point;
point->classname_function1=Classname_function1;
point->classname_function2=Classname_function2;
point->classname_property2=100;
point->classname_property1=(int*)malloc(sizeof(int)*100);
if(!point->classname_property1) return 0;
point->classname_getclassID=Classname_getclassID;
point->delclassname=Delclassname;
point->classnameID=CLASSNAMEID;

return 1;
}

使用C语言实现面向对象的设计 七
#define CLASSNAME() \
int classnameID;\
int (*classname_getclassID)();\
int (*newclassname)(classname* point);\
int (*classname_function1)(int i);\
int (*classname_function2)(classname* point);\
int classname_property2;\
int* classname_property1;\
__classname* classname_this;\
void (*delclassname)(classname* point);\
#define CHILDID 102
struct __child
{
int childID;
int(*child_getclassID)();
CLASSNAME();
__child* child_this;
int (*newchild)(__child* child_this);
void (*delchild)(__child* child_this);
};
typedef __child child;
int Child_getclassID()
{
return CHILDID;
}
void Delchild(child* point)
{
(*(point->delclassname))(point->classname_this);
printf("free child is ok");
}
int Newchild(child* point)
{
point->classnameID=CLASSNAMEID;
point->classname_this=(classname*) ( &( point->classnameID ));
if(!INITIAL(point->classname_this)) return 0;
point->delchild=Delchild;
point->childID=102;
point->child_getclassID=Child_getclassID;
return 1;
}
#define CHILD()\
int childID;\
int(*child_getclassID)();\
CLASSNAME();\
__child* child_this;\
int (*newchild)(__child* child_this);\
int (*delchild)(__child* child_this);\


使用C语言实现面向对象的设计 八
void* NEW (int CLASSID)
{
void* tem;
switch(CLASSID)
{
case CLASSNAMEID:
{
tem=malloc(sizeof(classname));
if(!tem) return NULL;
((classname*)tem)->newclassname=Newclassname;
classname* temp=(classname*)tem;
if(!(*(temp->newclassname))((classname*)tem) )
{
free(tem);
return NULL;
}
return tem;
}
case CHILDID:
{
tem=malloc(sizeof(child));
if(!tem) return NULL;
((child*)tem)->newchild=Newchild;
child* temp=(child*)tem;
if(!(*(temp->newchild))((child*)tem) )
{
free(tem);
return NULL;
}
return tem;
}
default:return NULL;
}
}

void DELETE (void* object)
{
if(object == NULL) return ;
switch(*(int*)object)
{
case CLASSNAMEID:
{
Delclassname((classname*)object);
break;
}
case CHILDID:
{
Delchild((child*)object);
break;
}
default:break;
}
free(object);
object=NULL;
}