彩票走势图

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)
            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)
        *(int*)element = set - heap;
    else
 &nbsp;  &nbsp;   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)))
  ;      puts("differ?");
    if (contains(s, drop(s, a)))
     &nbsp;  puts("drop?");
    delete(drop(s, b));
    delete(drop(s, c));
    return 0;
}

P.S.当然这段代码不看也罢【不是本文的重点，本文重在介绍并总结使用GObject的面向对象的机制】，放在这里只是为了显呗显呗C的面向对象程式的写法。