[GLib学习]GObject与GType

*****我本来想学习GLib，因为那是最棒的方法用C来实现OOP。但是开始很困难，对C语言了解的不是很深，所以最近一直在看C语言的基础部分。今天终于对GLib的面向对象是想了解了大概*****

***GLib简介：

GLib是GTK+和GNOME工程的基础底层核心程序库，是一个综合用途的实用的轻量级的C程序库，它提供C语言的常用的数据结构的定义、相关的处理函 数，有趣而实用的宏，可移植的封装和一些运行时机能，如事件循环、线程、动态调用、对象系统等的API。它能够在类UNIX的操作系统平台（如 LINUX， HP-UNIX等），WINDOWS，OS2和BeOS等操作系统台上运行。

GLib需要一个支持线程的操作系统和一个字符集间转换函数iconv的支持，事实上大多现代的操作系统都有以上两项功能。

GLib由基础类型、对核心应用的支持、实用功能、数据类型和对象系统五个部分组成的。

***GObject系统
GLib实现面向对象主要归功于GObject子系统。GObject系统主要依赖于GType系统，它是以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的对象到底是什么样的呢？下面是基于GObject的简单对象 -- Boy的定义代码：

/* boy.h */
#ifndef __BOY_H__
#define __BOY_H__
#include 
#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__*/

结构类型_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用来显示此对象的当前状态。

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

/* 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类型，它也是一个结构型， 定义为：

struct GParameter{
  const gchar* name;
  GValue value;
 };
关于GValue，它是变量类型的统一定义，它是基础的变量容器结构，用于封装变量的值和变量的类型，可以GOBJECT文档的GVALUE部分。

***对象的属性和方法

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

***对象的继承

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

#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类型的对象。

***使用我们定义的对象
#include 
#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）这三个子系统区别对待，编译时要注意加入相应的参数。