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;
//成功
}
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.则该子类可以这样实现
＃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);\
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 …..
….
}
}
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…….
………..
}
}
三 ，示例。
下面有一个完整的例子。在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;
}
#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);\
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;
}
int INITIAL(void* object)
{
if(object
== NULL) return 0;
switch(*(int*)object)
{
case
CLASSNAMEID:
{
((classname*)object)->newclassname=Newclassname;
if(!Newclassname((classname*)object))
return 0;
break;
}
case
CHILDID:
{
((child*)object)->newchild=Newchild;
if(!Newchild((child*)object))
return 0;
break;
}
default:return 0;
}
return 1;
}