Javascript多线程引擎(四)

Javascript多线程引擎(四)--之C语言单继承

　　因为使用C语言做为开发语言, 而C语言在类的支持方面几乎为零, 而Javascript语言的Object类型是一个非常明显的类支持对象,所以这里需要提出一个方案对Object类型的继承进行支持.

　　本章节介绍一个简单的基于C语言单继承结构的实现,  实现非常的简单, 但是体现了Java 的OO思想.

　　

 ////Object.h
 #ifndef _Object_
 #define _Object_
 /*******************
 cls:
     类似于Java的接口, 子类想对某个函数进行重载 ,
     则只要在具体同名函数的位置替换掉原先的指针 .
     而子类想访问被覆盖掉的父类同名函数, 则直接访问
     父类的函数指针.
     而私有函数, 则都在.c 文件中
 pb:
     公共数据结构, 数据结构在.h中
     通过指针来访问自己的和父对象的公用数据
     ((struct Pb*)pb[0])->size ; 访问了跟对象的public block的size
 sb:
     私有的数据成员, 数据结构在.c中, 非本对象不可操作
     ((struct Sb*)sb[0])->size
 FLOOR:
     该对象处于继承链的第几个位置, Root 为 0
 注: pb 和 sb的 数据槽 都由new Object的对象来申请空间
 　　初始化的方向为先初始化父类
 　　析构方向为先析构子类
 ********************/
 struct Object;
 //接口操作
 typedef void (*PrintFn)(struct Object* self);
 #define OBJECT_FLOOR 0
 struct Class{
     PrintFn p;
 };
 //公布的操作
 struct Pb{
     int size;
 };
 struct Object{
     struct Class* cls;
     void** pb;
     void** sb;
 };
 void ObjectPrint(struct Object* self);
 //申请基本的空间
 //构建一个基本的空间, floor为子类所在的层, 根为第0层
 struct Object* AllocObject(int floor);
 //初始化对象
 //如果o == NULL, 则Alloc一个空间
 struct Object* CreateObject(struct Object* o);
 #endif

　　通过Cls公布类似java接口操作,  而pb 和 sb 分别为公布数据结构和私有数据结构, 并且私有函数都写在 .c 文件中.

　　

 //Object.c
 #include<stdlib.h>
 #include<stdio.h>
 #include"Object.h"

 struct Sb{
     int num;
 };
 void ObjectPrint(struct Object* self){
     struct Pb* p;
     struct Sb* s;
     p = (struct Pb*)self->pb[OBJECT_FLOOR];
     s = (struct Sb*)self->sb[OBJECT_FLOOR];
     printf("root Object Pb: %d\n root Object Sb: %d\n", p->size,s->num);
 }
 //申请基本的空间
 //构建一个基本的空间, floor为子类所在的层, 根为第0层
 struct Object* AllocObject(int floor){
     if(floor <= ){
         //error
     }
     floor ++;
     struct Object* o;
     o = (struct Object*)malloc(sizeof(struct Object));
     o->cls = (struct Class* )malloc(sizeof(struct Class));
     //数据槽
     o->pb = (void**) malloc(sizeof(void*) * floor );
     o->sb = (void**) malloc(sizeof(void*) * floor );
 }

 //初始化对象
 //如果o == NULL, 则Alloc一个空间
 struct Object* CreateObject(struct Object* o){
     if(o == NULL)
         o = AllocObject(OBJECT_FLOOR);
     //初始化pb数据块
     o->pb[OBJECT_FLOOR] = (struct Pb*)malloc(sizeof(struct Pb));
     //初始化sb数据块
     o->sb[OBJECT_FLOOR] = (struct Sb*)malloc(sizeof(struct Sb));
     o->cls->p = &ObjectPrint;
     ((struct Pb*)o->pb[OBJECT_FLOOR])->size = ;
     ((struct Sb*)o->sb[OBJECT_FLOOR])->num = ;
     return o;
 }

私有数据结构实现在.c 中,  私有函数也实现在.c 中

而下面就是一个简单的Object2.h 对象

 ///Object2.h
 #ifndef _Object2_
 #define _Object2_
 #define OBJECT2_FLOOR 1
 #include"Object.h"
 //新子类的共享数据
 struct Pb2{
     int size;
 };
 void ObjectPrint2(struct Object* self);
 struct Object* CreateObject2(struct Object* o);
 #endif

Object2.h  实现了自己的数据结构 和公布了一个多态函数

 ///Object2.c
 #include"Object.h"
 #include"Object2.h"
 #include<stdio.h>
 #include<stdlib.h>
 void ObjectPrint2(struct Object* self){
     struct Pb2* p = (struct Pb2*)self->pb[];
     printf("Object2 : %d \n",p->size);
     ObjectPrint(self);
 }
 struct Object* CreateObject2(struct Object* o){
     if(o == NULL)
         //处于继承链第一个位置
         o = AllocObject(OBJECT2_FLOOR);
     //初始化父对象
     CreateObject(o);
     //初始化pb数据块
     o->pb[OBJECT2_FLOOR] = malloc(sizeof(struct Pb2));
     //初始化sb数据块
     o->sb[OBJECT2_FLOOR] = NULL;
     //重载
     o->cls->p = &ObjectPrint2;
     ((struct Pb2*)o->pb[OBJECT2_FLOOR])->size =;
     return o;
 }

在第9行 , 调用了父类的该同名函数.

以下是一个基本的测试:

////main.c
#include"Object2.h"
#include<stdlib.h>
int main(){
    struct Object* o = CreateObject2(NULL);
    o->cls->p(o);
}

编译命令:

gcc -c Object.c

gcc -c Object2.c

gcc -c main.c Obejct.o Object2.o

./a.out

测试成功!

　　通过pb 的连续内存块, 在继承结构中, 对象只能看到它自己和父对象的内存结构, 而不能发现该对象的子对象内存结构, 而父对象则照常使用属于他自己的内存空间, 从而实现了信息隐藏.

并且每个对象的访问数据和操作都是统一的（主要是父对象）:

1. 子对象指针和父对象指针都可以通过pb数据块进行操作自己的数据(从共享内存中找到自己的内存地址)

2. 子对象和父对象指针访问API都指向正确的实现(可以访问重载函数)

3. 私有数据都是从sb数据块获取

　　C语言的继承和多态主要的核心是内存结构和CPU访问数据和函数的方式(参考C++对象继承内存模型), 或者采用动态语言的机制进行查询访问.

源代码:

　　http://files.cnblogs.com/tickobject/src.zip

项目代码地址:

github.com/darkgem/js-engine