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語言表驅動的簡單應用

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

其實用C寫面向對象的代碼應該算是一種編程風格，而且真正用起來并不像上面說的那么簡單。

/////

下面列舉一段代碼，用面向對象的方法實現了一個集合【沒有專門的輸出函式，建議調試下】，集合是什么？呃。。。就是一堆不重復數字的組合。

Code
#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)
           &nbsp;break;
    assert(p < heap + MANY);
    * p = MANY;
    return p;
}
void delete (void * _item)
{ 
    int * item = _item;
    if (item)
    {
 &nbsp;      assert(item > heap && item < heap + MANY);
   &nbsp;    * 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)
  &nbsp;     *(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))
 &nbsp;      puts("contains?");
    if (differ(a, add(s, a)))
    ;   &nbsp;puts("differ?");
    if (contains(s, drop(s, a)))
  &nbsp;    &nbsp;puts("drop?");
    delete(drop(s, b));
    delete(drop(s, c));
    return 0;
}

P.S.當然這段代碼不看也罷【不是本文的重點，本文重在介紹并總結使用GObject的面向對象的機制】，放在這里只是為了顯唄顯唄C的面向對象程式的寫法。