使用C语言进行面向对象的开发－－GObject入门［1］ [2]

http://www.cnblogs.com/pingf/archive/2009/11/20/1606533.html

C语言是简单的，因为它本身并没有什么特别的内容，标准C并没有提供多少函式（其实一般用不到的提供了很多），也没有提供面向对象的机制，但也正因此使得要用C编写“美丽”的程序变得复杂起来。复杂的原因其实很简单，一切的一切都要我们自己去实现。

最近这段时间集中攻了下GObject，虽然只是会了些皮毛，但还是要寥寥写上几句，省着以后忘记了，又要从头整，毕竟GObject的学习时间令人头痛的事儿。

　　P.S.关于怎么安装GObject以及如何配置使用，本文不多介绍，WIN32下可以安装Glade包，ubuntu下apt－get下就行了。

Part 1.

谁说C不能面向对象，只要你愿意写，所有面向对象的机制都能够实现，好像python之类也是拿C整的吧（呃，多嘴了，涉及到了自己未知的领域。。。。。。orz，八成描述有错误）。

当然就C本身肯定没什么对象可言的，但我们可以用它模拟出对象的机制。

就简单的对象而言，无非是成员和函式的杂糅，另外多了些继承啊，类型转换之类的功能。其实单就成员和函式而言，结构体足矣。例如

struct a

{

int a;

int b;

void (*func)();

}

而如果要模拟继承关系可在子结构中声明一个父结构，就像子类继承了父类一般。

当然像私有公有之类的就有些麻烦了，一般的做法是靠程序员自己的理解来区分。

注意上面的指向函式的指针，可以说C的一部分精华都集中于此，也是因为有了这种机制才使得用C模拟面向对象的机制并不是那么复杂。

另外可以补充看一下我先前的一篇记录

关于C语言表驱动的简单应用

http://www.cnblogs.com/pingf/archive/2009/08/03/1537730.html

其实用C写面向对象的代码应该算是一种编程风格，而且真正用起来并不像上面说的那么简单。

/////

下面列举一段代码，用面向对象的方法实现了一个集合【没有专门的输出函式，建议调试下】，集合是什么？呃。。。就是一堆不重复数字的组合。

#include  < stdio.h >
#include  < assert.h >
#define  MANY 10
static   int  heap [MANY];
void   *   new  ( const   void   *  type, )
{ 
     int   *  p;  /*  & heap[1..]  */
     for  (p  =  heap  +   1 ; p  <  heap  +  MANY;  ++  p)
         if  ( !   *  p)
             break ;
    assert(p  <  heap  +  MANY);
     *  p  =  MANY;
     return  p;
}
void  delete ( void   *  _item)
{ 
     int   *  item  =  _item;
     if  (item)
    {
        assert(item  >  heap  &&  item  <  heap  +  MANY);
         *  item  =   0 ;
    }
}

void   *  add ( void   *  _set,  const   void   *  _element)
{ 
     int   *   set   =  _set;
     const   int   *  element  =  _element;
    assert( set   >  heap  &&   set   <  heap  +  MANY);
    assert( *   set   ==  MANY);
    assert(element  >  heap  &&  element  <  heap  +  MANY);
     if  ( *  element  ==  MANY)
         * ( int * )element  =   set   -  heap;
     else
        assert( *  element  ==   set   -  heap);
     return ( void   * ) element;
}

void   *  find ( const   void   *  _set,  const   void   *  _element)
{
     const   int   *   set   =  _set;
     const   int   *  element  =  _element;
    assert( set   >  heap  &&   set   <  heap  +  MANY);
    assert( *   set   ==  MANY);
    assert(element  >  heap  &&  element  <  heap  +  MANY);
    assert( *  element);
     return   *  element  ==   set   -  heap  ?  ( void   * ) element :  0 ;
}

int  contains ( const   void   *  _set,  const   void   *  _element)
{
     return  find(_set, _element)  !=   0 ;
}

void   *  drop ( void   *  _set,  const   void   *  _element)
{ 
     int   *  element  =  find(_set, _element);
     if  (element)
         *  element  =  MANY;
     return  element;
}

int  differ ( const   void   *  a,  const   void   *  b)
{
     return  a  !=  b;
}

const   void   *  Set;
const   void   *  Object;
int  main ()
{ 
     void   *  s  =   new (Set);
     void   *  a  =  add(s,  new (Object));
     void   *  b  =  add(s,  new (Object));
     void   *  c  =   new (Object);
     if  (contains(s, a)  &&  contains(s, b))
        puts( " ok " );
     if  (contains(s, c))
        puts( " contains? " );
     if  (differ(a, add(s, a)))
        puts( " differ? " );
     if  (contains(s, drop(s, a)))
        puts( " drop? " );
    delete(drop(s, b));
    delete(drop(s, c));
     return   0 ;
}

PART 2.

在正式开始GObject的学习之前，还要简单提一下大名鼎鼎的建立在GObject系统之上的桌面图形库Gtk，先来个最简单的程序看看。

#include <gtk/gtk.h>

int main( int argc, char *argv[])

{

GtkWidget *window;

gtk_init(&argc, &argv);

window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

gtk_widget_show(window);

gtk_main();

return 0;

}

这段代码的作用其实就是显示一个啥都没有的窗口。

有些刚接触gtk的人觉得gtk的函式名总是很长，其实也是有它的原因的，后面再说。

如果我们将上面代码中的Gtk，gtk，GTK去掉，似乎会简明不少。

其实就是 声明window（窗口），new一个window，显示window 三步，当然最后进入一个循环 gtk_main 中。

除了函数名长了些之外，不难发现大小写，下划线的组合还蛮多的，这也是挺麻烦事情。

下面就这些冗长而又麻烦的事情，简单加以说明（就是我个人的理解…….XD），

GTK(不分大小写)其实就是表明了这个函式是gtk库提供的，它表明的是一个域，就像System.out.***之类，前面的一堆写起来也是挺麻烦的一样。

而大小写和下划线的搭配下面举例来说

GtkWindow 用于对象[构件]的声明

GTK_WINDOW 用于对象类型的转换

gtk_window_*** 用于与对象相关的函式的声明

这样的规则不是gtk说了算的，而是GType，GObject决定的，转而言之，一般的基于Glib的库都采用这样的规则，比如进来很流行的2.5D桌面图形库Clutter，里面构件的声明也遵循此规则。

如果想玩下Clutter，但又不懂linux，可以参考下面这篇博文，在win32上搭建Clutter的开发环境。

http://www.cnblogs.com/pingf/archive/2009/10/27/1590419.html

下面简单说下GObject实现的一些面向对象的机制（当然都是模拟的），

类型机制，

继承，

接口，

函式调用（普通，虚，纯虚，当然这需要你自己来理解），

类型转化（静态，动态，基础类型），

类型检测，

属性机制，

信号机制（signal，closure，accumulator…..）

。。。。。。

有很多东西其实平时是用不到滴【其实是目前我还没搞明白】，所以下面的代码集中说明如下一些东西

继承，

接口，

函式调用（普通，虚，纯虚）

函式（普通的，虚的）

信号机制（signal）

类型转化（静态）【动态的简单看了下，有时间的话也会写点……XD】

类型检测

属性机制