GObject对象系统

前言

大多数现代的计算机语言都带有本身的类型和对象系统，并附带算法结构。正象GLib提供的基本类型和算法结构（如链表、哈希表等）同样，GObject的对象系统提供了一种灵活的、可扩展的、并容易映射（到其它语言）的面向对象的C语言框架。它的实质能够归纳为：

• 一个通用类型系统，用来注册任意的、轻便的、单根继承的、并能推导出任意深度的结构类型的界面，它照顾组合对象的定制、初始化和内存管理，类结构，保持对象的父子关系，处理这些类型的动态实现。也就是说，这些类型的实现是在运行时重置和卸载的；
• 一个基本类型的实现集，如整型，枚举型和结构型等；
• 一个基本对象体系之上的基本对象类型的实现的例子--GObject基本类型；
• 一个信号系统，容许用户很是灵活的自定义虚的或重载对象的方法，而且能充当很是有效力的通知机制；
• 一个可扩展的参数/变量体系，支持全部的能被用做处理对象属性或其它参数化类型的基本的类型。

类型（GType）与对象（GObject）

GLib中最有特点的是它的对象系统--GObject System，它是以Gtype为基础而实现的一套单根继承的C语言的面向对象的框架。

GType 是GLib 运行时类型认证和管理系统。GType API 是GObject的基础系统，因此理解GType是理解GObject的关键。Gtype提供了注册和管理全部基本数据类型、用户定义对象和界面类型的技术实现。（注意：在运用任一GType和GObject函数以前必需运行g_type_init()函数来初始化类型系统。）

为实现类型定制和注册这一目的，全部类型必需是静态的或动态的这两者之一。静态的类型永远不能在运行时加载或卸载，而动态的类型则能够。静态类型由g_type_register_static()建立，经过GTypeInfo结构来取得类型的特殊信息。动态类型则由g_type_register_dynamic()建立，用GTypePlugin结构来取代GTypeInfo，而且还包括g_type_plugin_*()系列API。这些注册函数一般只运行一次，目的是取得它们返回的专有类的类型标识。

还能够用g_type_register_fundamental来注册基础类型，它同时须要GTypeInfo和GTypeFundamentalInfo两个结构，事实上大多数状况下这是没必要要的，由于系统预先定义的基础类型是优于用户自定义的。

（本文重点介绍建立和使用静态的类型。）

对象的定义

在GObject系统中，对象由三个部分组成：

1. 对象的ID标识（惟一，无符号长整型，全部此类对象共同的标识）；
2. 对象的类结构（惟一，结构型，由对象的全部实例共同拥有）；
3. 对象的实例（多个，结构型，对象的具体实现）。

基于GObject的对象究竟是什么样的呢？下面是基于GObject的简单对象 -- Boy的定义代码：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

/* boy.h */ #ifndef __BOY_H__ #define __BOY_H__ #include <glib-object.h> #define BOY_TYPE (boy_get_type()) #define BOY(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),BOY_TYPE,Boy)) typedef struct _Boy Boy; typedef struct _BoyClass BoyClass; struct _Boy { GObject parent; // gint age; gchar *name; void (*cry)(void); }; struct _BoyClass { GObjectClass parent_class; // void (*boy_born)(void); }; GType   boy_get_type(void); Boy*  boy_new(void); int boy_get_age(Boy *boy); void    boy_set_age(Boy *boy, int age); char* boy_get_name(Boy *boy); void    boy_set_name(Boy *boy, char *name); Boy*  boy_new_with_name(gchar *name); Boy*  boy_new_with_age(gint age); Boy*  boy_new_with_name_and_age(gchar *name, gint age); void  boy_info(Boy *boy); #endif /* __BOY_H__*/

这是一段典型的C语言头文件定义，包括编译预处理，宏定义，数据结构定义和函数声明；首先要看的是两个数据结构对象Boy和BoyClass，

结构类型_Boy是Boy对象的实例，就是说咱们每建立一个Boy对象，也就同时建立了一个Boy结构。Boy对象中的parent表示此对象的父类，GObject系统中全部对象的共同的根都是GObject类，因此这是必须的；其它的成员能够是公共的，这里包括表示年龄的age，表示名字的name和表示方法的函数指针cry，外部代码能够操做或引用它们。

结构类型_BoyClass是Boy对象的类结构，它是全部Boy对象实例所共有的。BoyClass中的parent_class是GObjectClass，同GObject是全部对象的共有的根同样，GObejctClass是全部对象的类结构的根。在BoyClass中咱们还定义了一个函数指针boy_born，也就是说这一函数指针也是全部Boy对象实例共有的，全部的Boy实例均可以调用它；一样，若是须要的话，你也能够在类结构中定义其它数据成员。

其他的函数定义包括三种，一种是取得Boy对象的类型ID的函数boy_get_type，这是必须有的；另外一种是建立Boy对象实例的函数boy_new和boy_new_with_*，这是很是清晰明了的建立对象的方式，固然你也能够用g_object_new函数来建立对象；第三种是设定或取得Boy对象属性成员的值的函数boy_get_*和boy_set_*。正常状况下这三种函数都是一个对象所必需的，另一个函数boy_info用来显示此对象的当前状态。

宏在GObject系统中用得至关普遍，也至关重要，这里咱们定义了两个很是关键的宏，BOY_TYPE宏封装了boy_get_type函数，能够直接取得并替代Boy对象的ID标识；BOY(obj)宏是G_TYPE_CHECK_INSTANCE_CAST宏的再一次封装，目的是将一个Gobject对象强制转换为Boy对象，这在对象的继承中十分关键，也常常用到。

对象的实现

下面的代码实现了上面的Boy对象的定义：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101

/* boy.c */ #include "boy.h" enum { BOY_BORN, LAST_SIGNAL }; static gint boy_signals[LAST_SIGNAL] = { 0 }; static void boy_cry (void); static void boy_born(void); static void boy_init(Boy *boy); static void boy_class_init(BoyClass *boyclass); GType boy_get_type(void) {     static GType boy_type = 0;     if(!boy_type)     {         static const GTypeInfo boy_info = {             sizeof(BoyClass),             NULL,NULL,             (GClassInitFunc)boy_class_init,             NULL,NULL,             sizeof(Boy),             0,             (GInstanceInitFunc)boy_init         };         boy_type = g_type_register_static(G_TYPE_OBJECT,"Boy",&boy_info,0);     }     return boy_type; } static void boy_init(Boy *boy) {     boy->age = 0;     boy->name = "none";     boy->cry = boy_cry; } static void boy_class_init(BoyClass *boyclass) {     boyclass->boy_born = boy_born;     boy_signals[BOY_BORN] = g_signal_new("boy_born",                 BOY_TYPE,                 G_SIGNAL_RUN_FIRST,                 G_STRUCT_OFFSET(BoyClass,boy_born),                 NULL,NULL,                 g_cclosure_marshal_VOID__VOID,                 G_TYPE_NONE, 0, NULL); } Boy *boy_new(void) {     Boy *boy;     boy = g_object_new(BOY_TYPE, NULL);     g_signal_emit(boy,boy_signals[BOY_BORN],0);     return boy; } int boy_get_age(Boy *boy) {     return boy->age; } void boy_set_age(Boy *boy, int age) {     boy->age = age; } char *boy_get_name(Boy *boy) {     return boy->name; } void boy_set_name(Boy *boy, char *name) {     boy->name = name; } Boy*  boy_new_with_name(gchar *name) {     Boy* boy;     boy = boy_new();     boy_set_name(boy, name);     return boy; } Boy*  boy_new_with_age(gint age) {     Boy* boy;     boy = boy_new();     boy_set_age(boy, age);     return boy; } Boy *boy_new_with_name_and_age(gchar *name, gint age) {     Boy *boy;     boy = boy_new();     boy_set_name(boy,name);     boy_set_age(boy,age);     return boy; } static void boy_cry (void) {     g_print("The Boy is crying ......\n"); } static void boy_born(void) {     g_print("Message : A boy was born .\n"); } void  boy_info(Boy *boy) {     g_print("The Boy name is %s\n", boy->name);     g_print("The Boy age is %d\n", boy->age); }

在这段代码中，出现了实现Boy对象的关键函数，这是在Boy对象的定义中未出现的，也是不必出现的。就是两个初始化函数，boy_init和boy_class_init，它们分别用来初始化实例结构和类结构。它们并不被在代码中明显调用，关键是将其用宏转换为地址指针，而后赋值到GTypeInfo结构中，而后由GType系统自行处理，同时将它们定义为静态的也是很是必要的。

GTypeInfo结构中定义了对象的类型信息，包括如下内容：

1. 包括类结构的长度（必需，即咱们定义的BoyClass结构的长度）；
2. 基础初始化函数（base initialization function，可选）；
3. 基础结束化函数（base finalization function，可选）； 

   （以上两个函数能够对对象使用的内存来作分配和释放操做，使用时要用GBaseInitFunc和GBaseFinalizeFunc来转换为指针，本例中均未用到，故设为NULL。）

4. 类初始化函数（即咱们这里的boy_class_init函数，用GclassInit宏来转换，可选，仅用于类和实例类型）；
5. 类结束函数（可选）；
6. 实例初始化函数（可选，即咱们这里的boy_init函数）；
7. 最后一个成员是GType变量表（可选）。

定义好GTypeInfo结构后就能够用g_type_register_static函数来注册对象的类型了。

g_type_register_static函数用来注册对象的类型，它的第一个参数是表示此对象的父类的对象类型，咱们这里是G_TYPE_OBJECT，这个宏用来表示GObject的父类；第二个参数表示此对象的名称，这里为"Boy"；第三个参数是此对象的GTypeInfo结构型指针，这里赋值为&boyinfo；第四个参数是对象注册成功后返回此对象的整型ID标识。

g_object_new函数，用来建立一个基于G_OBJECT的对象，它能够有多个参数，第一个参数是上面说到的已注册的对象标识ID；第二个参数表示后面参数的数量，若是为0，则没有第三个参数；第三个参数开始类型都是GParameter类型，它也是一个结构型，定义为：

1 2 3 4

struct GParameter{         const gchar* name;         GValue value;     };

关于GValue，它是变量类型的统必定义，它是基础的变量容器结构，用于封装变量的值和变量的类型，能够GOBJECT文档的GVALUE部分。

信号的定义和应用

在GObject系统中，信号是一种定制对象行为的手段，同时也是一种多种用途的通知机制。初学者多是在GTK+中首先接触到信号这一律念的，事实上在普通的字符界面编程中也能够正常应用，这多是不少初学者不曾想到的。

一个对象能够没有信号，也能够有多个信号。当有一或多个信号时，信号的名称定义是必不可少的，此时C语言的枚举类型的功能就凸显出来了，用LAST_SIGNAL来表示最后一个信号（不用实现的信号）是一种很是良好的编程风格。这里为Boy对象定义了一个信号BOY_BORN，在对象建立时发出，表示Boy对象诞生。

同时还须要定义静态的整型指针数组来保存信号的标识，以便于下一步处理信号时使用。

对象的类结构是全部对象的实例所共有的，咱们将信号也定义在对象的类结构中，如此信号一样也是全部对象的实例所共有的，任意一个对象的实例均可以处理信号。所以咱们有必要在在类初始化函数中建立信号（这也多是GObject设计者的初衷）。函数g_signal_new用来建立一个新的信号，它的详细使用方法能够在GObject的API文档中找到。信号建立成功后，返回一个信号的标识ID，如此就能够用发射信号函数g_signal_emit向指定义对象的实例发射信号，从而执行相应的功能。

本例中每建立一个新的Boy对象，就会发射一次BOY_BORN信号，也就会执行一次咱们定义的boy_born函数，也就输出一行"Message : A boy was born ."信息。

对象的属性和方法

对象实例全部的属性和方法通常都定义在对象的实例结构中，属性定义为变量或变量指针，而方法则定义为函数指针，如此，咱们必定要定义函数为static类型，当为函数指针赋值时，才能有效。

对象的继承

如下为继承自Boy对象的Man对象的实现，Man对象在Boy对象的基础上又增长了一个属性job和一个方法bye。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86

#ifndef __MAN_H__ #define __MAN_H__ #include "boy.h" #define MAN_TYPE  (man_get_type()) #define MAN(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),MAN_TYPE,Man)) typedef struct _Man Man; typedef struct _ManClass ManClass; struct _Man {     Boy parent;     char *job;     void (*bye)(void); }; struct _ManClass {     BoyClass parent_class; }; GType man_get_type(void); Man*  man_new(void); gchar* man_get_gob(Man *man); void  man_set_job(Man *man, gchar *job); Man*  man_new_with_name_age_and_job(gchar *name, gint age, gchar *job); void man_info(Man *man); #endif //__MAN_H__ /* man.c */ #include "man.h" static void man_bye(void); static void man_init(Man *man); static void man_class_init(Man *man); GType man_get_type(void) {     static GType man_type = 0;     if(!man_type)     {         static const GTypeInfo man_info = {             sizeof(ManClass),             NULL, NULL,             (GClassInitFunc)man_class_init,             NULL, NULL,             sizeof(Man),             0,             (GInstanceInitFunc)man_init         };         man_type = g_type_register_static(BOY_TYPE, "Man", &man_info, 0);     }     return man_type; } static void man_init(Man *man) {     man->job = "none";     man->bye = man_bye; } static void man_class_init(Man *man) { } Man*  man_new(void) {     Man *man;     man = g_object_new(MAN_TYPE, 0);     return man; } gchar* man_get_gob(Man *man) {     return man->job; } void  man_set_job(Man *man, gchar *job) {     man->job = job; } Man*  man_new_with_name_age_and_job(gchar *name, gint age, gchar *job) {     Man *man;     man = man_new();     boy_set_name(BOY(man), name);     boy_set_age(BOY(man), age);     man_set_job(man, job);     return man; } static void man_bye(void) {     g_print("Goodbye everyone !\n"); } void man_info(Man *man) {     g_print("the man name is %s\n", BOY(man)->name);     g_print("the man age is %d\n", BOY(man)->age);     g_print("the man job is %s\n", man->job); }

关键在于定义对象时将父对象实例定义为Boy，父类设定为BoyClass，在注册此对象时将其父对象类型设为BOY_TYPE，在设定对象属性时如用到父对象的属性要强制转换下，如取得对象的name属性，就必须用BOY(obj)->name，由于Man自己没有name属性，而其父对象Boy有，因此用BOY宏将其强制为Boy类型的对象。

测试咱们定义的对象

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

#include <glib.h> #include "boy.h" #include "man.h" int main(int argc, char *argv[]) {     Boy *tom, *peter;     Man *green, *brown;     g_type_init();//注意，初始化类型系统，必需     tom = boy_new_with_name("Tom");     tom->cry();     boy_info(tom);     peter = boy_new_with_name_and_age("Peter", 10);     peter->cry();     boy_info(peter);     green = man_new();     boy_set_name(BOY(green), "Green"); //设定Man对象的name属性用到其父对象Boy的方法     boy_set_age(BOY(green), 28);     man_set_job(green, "Doctor");     green->bye();     man_info(green);     brown = man_new_with_name_age_and_job("Brown", 30, "Teacher");     brown->bye();     man_info(brown); } Makefile文件以下： CC = gcc all:     $(CC) -c boy.c `pkg-config --cflags glib-2.0 gobject-2.0`     $(CC) -c man.c `pkg-config --cflags glib-2.0 gobject-2.0`     $(CC) -c main.c `pkg-config --cflags glib-2.0 gobject-2.0`     $(CC) -o simple boy.o man.o main.o `pkg-config --libs glib-2.0 gobject-2.0` 执行make命令编译，编译结束后，执行./simple运行此测试程序，输出结果以下： Message : A boy was born . The Boy is crying ...... The Boy name is Tom The Boy age is 0 Message : A boy was born . The Boy is crying ...... The Boy name is Peter The Boy age is 10 Goodbye everyone ! the man name is Green the man age is 28 the man job is Doctor Goodbye everyone ! the man name is Brown the man age is 30 the man job is Teacher

Makefile中用到`pkg-config -cflags -libs gobject-2.0`，在GLIB中将线程（gthread），插件（gmoudle）和对象系统（gobject）这三个子系统区别对待，编译时要注意加入相应的参数。

本文只是概要的介绍了如何定义和实现GObject对象，GObject系统中还有不少相关内容，如：枚举和标识类型（Enumeration and flags types）；Gboxed，是Gtype系统中注册一种封装为不透明的C语言结构类型的机制；许多对象用到的参数对象都是C结构类型，使用者没必要了解其结构的内部定义，即不透明，GBoxed便是实现这一功能的机制；标准的参数和变量类型的定义（Standard Parameter and Value Types）等，它们都以C语言来开发，是深刻了解和掌握GObject的关键。

透过以上代码实现，咱们还能够看出，以GLIB为基础的GTK+/GNOME开发环境所具备的独特的编程风格和独到的开发思想。这一点在长期的编程实践中会体验得更深入。

有了GObject系统这一基础，GTK+经过它将X窗口环境中的控件（Widget）巧妙的封装起来，这使开发LINUX平台上的GUI应用程序更方便，更快捷。

以上代码在Redhat 8.0 Linux平台，GLIB2.2.1环境下编译经过。

感谢

本文的写做参考了中国LINUX论坛的网友hoyt的文章，能够在gtkvb.cffd.org.cn找到，在此表示感谢。

相关主题

• 本文的全部代码能够在这里 下载。
• Thomas Hunger写的文章： Gobject tutorial
• 中国 linux 论坛的网友 hoyt 的网页 http://gtkvb.cosoft.org.cn/上的文章
• 与本文相关的另外一篇文章 《浅析GLib》