#include <stdio.h>
#include <stdlib.h>
#include <unistd.h> //unix标准函数
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h> //文件控制
#include <termios.h> //POSIX中断控制
#include <errno.h>

2、打开串口
fd = open(“/dev/ttyUSB0″, O_RDWR);

3、设置波特率
最基本的串口设置包括波特率、校验位和停止位设置，主要使用termios.h头文件中定义的termios结构，如下：
struct termios
{
tcflag_t c_iflag; //输入模式标志
tcflag_t c_oflag; //输出模式标志
tcflag_t c_cflag; //控制模式标志
tcflag_t c_lflag; //本地模式标志
cc_t c_line;
cc_t c_cc[NCC];
}

4、设置数据位、停止位和校验位
8位数据位、无校验位：
Opt.c_cflag &= ~PARENB;
Opt.c_cflag &= ~CSTOPB;
Opt.c_cflag &= ~CSIZE;
Opt.c_iflag |= CS8
7位数据位、奇校验
Opt.c_cflag |= PARENB;
Opt.c_cflag |= PARODD;
Opt.c_cflag &= ~CSTOPB;
Opt.c_cflag &= ~CSIZE;
Opt.c_cflag |= CS7;
7位数据位、偶校验
Opt.c_cflag |= PARENB;
Opt.c_cflag &= ~PARODD;
Opt.c_cflag &= ~CSTOPB;
Opt.c_cflag &= CSIZE;
Opt.c_cflag |= CS7;
7位数据位、Space校验
Opt.c_cflag &= ~PARENB;
Opt.c_cflag &= ~CSTOPB;
Opt.c_cflag &= ~CSIZE;
Opt.c_cflag |= CS7;

5、读写串口
读使用read函数；写使用write函数。

6、关闭串口
close(fd);

例子：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>     //unix标准函数
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>      //文件控制
#include <termios.h>    //POSIX中断控制
#include <errno.h>

#define TRUE    1
#define FALSE   0
#define SERIAL  "/dev/ttyUSB0"

int speed_arr[] = {B115200, B57600, B38400, B19200, B9600, B4800, B2400, B1200, B600, B300, };
int name_arr[] = {115200, 57600, 38400, 19200, 9600, 4800, 2400, 1200, 600, 300, };

//设置波特率
void SetSpeed(int fd, int speed)
{
    int i;
    struct termios Opt; //定义termios结构

    if (tcgetattr(fd, &Opt) != 0)
    {
        perror("tcgetattr fd");
        return;
    }
    for (i=0; i<sizeof(speed_arr)/sizeof(int); i++)
    {
        if (speed == name_arr[i])
        {
            tcflush(fd, TCIOFLUSH);
            cfsetispeed(&Opt, speed_arr[i]);
            cfsetospeed(&Opt, speed_arr[i]);
            //tcsetattr函数标志：
            //TCSANOW:立即执行而不等待数据发送或者接受完成
            //TCSADRAIN:等待所有数据传递完成后执行
            //TCSAFLUSH:Flush input and output buffers and make the change
            if (tcsetattr(fd, TCSANOW, &Opt) != 0)
            {
                perror("tcsetattr fd");
                return;
            }
            tcflush(fd, TCIOFLUSH);
        }
    }
}

//设置数据位、停止位和校验位
int SetParity(int fd, int databits, int stopbits, int parity)
{
    struct termios Opt;
    if (tcgetattr(fd, &Opt) != 0)
    {
        perror("tcgetattr fd");
        return FALSE;
    }
    Opt.c_cflag |= (CLOCAL | CREAD);    //一般必设置的标志
    switch (databits)                   //设置数据位
    {
        case 7:
        {
            Opt.c_cflag &= ~CSIZE;
            Opt.c_cflag |= CS7;
            break;
        }
        case 8:
        {
            Opt.c_cflag &= ~CSIZE;
            Opt.c_cflag |= CS8;
            break;
        }
        default:
        {
            fprintf(stderr, "Unsupport data size.\n");
            return FALSE;
        }
    }
    switch (parity)                     //设置校验位
    {
        case 'n':
        case 'N':
        {
            Opt.c_cflag &= ~PARENB;     //清除校验位
            Opt.c_iflag &= ~INPCK;      //enable parity checking
            break;
        }
        case 'o':
        case 'O':
        {
            Opt.c_cflag |= PARENB;      //enable parity
            Opt.c_cflag |= PARODD;      //奇校验
            Opt.c_iflag |= INPCK;       //disable parity checking
            break;
        }
        case 'e':
        case 'E':
        {
            Opt.c_cflag |= PARENB;      //enable parity
            Opt.c_cflag &= ~PARODD;     //偶校验
            Opt.c_iflag |= INPCK;       //disable parity checking
            break;
        }
        case 's':
        case 'S':
        {
            Opt.c_cflag &= ~PARENB;     //清除校验位
            Opt.c_cflag &= ~CSTOPB;     //?????
            Opt.c_iflag |= INPCK;       //disable parity checking
            break;
        }
        default:
        {
            fprintf(stderr,"Unsupoort parity.\n");
            return FALSE;
        }
    }
    switch (stopbits)                   //设置停止位
    {
        case 1:
        {
            Opt.c_cflag &= ~CSTOPB;
            break;
        }
        case 2:
        {
            Opt.c_cflag |= CSTOPB;
            break;
        }
        default:
        {
            fprintf(stderr, "Unsupport stopbits.\n");
            return FALSE;
        }
    }

    Opt.c_cflag |= (CLOCAL | CREAD);
    Opt.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);

    Opt.c_oflag &= ~OPOST;
    Opt.c_oflag &= ~(ONLCR | OCRNL);        //添加的

    Opt.c_iflag &= ~(ICRNL | INLCR);
    Opt.c_iflag &= ~(IXON | IXOFF | IXANY); //添加的

    tcflush(fd, TCIFLUSH);
    Opt.c_cc[VTIME] = 0;                    //设置超时为15sec
    Opt.c_cc[VMIN] = 0;                     //Update the Opt and do it now
    if (tcsetattr(fd, TCSANOW, &Opt) != 0)
    {
        perror("tcsetattr fd");
        return FALSE;
    }
    return TRUE;
}

int main()
{
    int fd;
    int i, len, n=0;
    char read_buf[256];
    char write_buf[256];
    char c;
    struct termios opt;

    fd = open(SERIAL, O_RDWR|O_NOCTTY);
    if (fd == -1)
    {
        perror("open serial\n");
        exit(-1);
    }
    SetSpeed(fd, 115200);
    SetParity(fd, 8, 1, 'n');
    while (1)
    {
        n = 0;
        len = 0;
        memset(read_buf, 0, sizeof(read_buf));
        memset(write_buf, 0, sizeof(write_buf));

        while ((n=read(fd, read_buf, sizeof(read_buf))) > 0)
        {
            read_buf[n] = '\0';
            printf("%s", read_buf);
        }
        scanf("%c", &c);
        write(fd, &c, 1);
        while ((n=read(fd, read_buf, sizeof(read_buf))) > 0)
        {
            read_buf[n] = '\0';
            printf("%s\n", read_buf);
        }
    }
}

例子程序下载：

http://download.csdn.net/detail/wosuopu/4300998

S3C2440有5个16位定时器。定时器0和1共享一个8位预分频器，定时器2、3、4共享另一个8位预分频器。

定时器的时钟源为PCLK，首先经过预分频器降低频率后，进入第二分频。可生成5种不同的分频信号（1/2,1/4,1/8,1/16和TCLK）。

定时器启动后，TCNTn开始减一计数，当TCNTn等于TCMPn时TOUTn反转，TCNTn继续减数。当TCNTn=0时，TOUTn再反转，并触发中断（中断已使能）。若TCON设为自动加载，TCNTn/TCMPn值被重载。

与定时器相关的寄存器：
TCFG0：配置两个8位预分频器［15:8］决定定时器2,3,4的预标定器值，[7:0]决定定时器0,1。
输出频率=PCLK/(prescaler value+1)

TCFG1：设置第二个分频，可设置5种不同分频信号（1/2,1/4,1/8,1/16,TCLK）
定时器工作频率=PCLK/(Prescaler value+1)/(divider value)
divider value=2,4,8,16
Prescaler=0~255

TCON：定时器控制寄存器
TCNTBn：设置一个被装载到递减计数器中的初始值
TCMPBn：设置一个被装载到比较寄存器中用来和递减计数器的值比较的初始值
TCNTOn：通过读取其可以得到TCNTn的值
TCNTB=(PCLK/(Prescaler+1)/divider)*中断间隔

定时器初始化例子：
TCFG0 = 99; //预分频器0=99
TCFG1 = 0×03; //选择16分频
TCNTB0 = 31250; //0.5秒触发一次中断
TCON |= (1< TCON = 0×09; //自动加载，清“手动更新”，启动定时器0

一个简单的定时器程序下载：http://download.csdn.net/detail/wosuopu/4298320

.include "gpio.inc"
.text
.global _start
_start:
        ldr r0, =GPBCON
        mov r1, #0b01
        str r1, [r0]
        ldr r0, =GPBUP
        mov r1, #0
        str r1, [r0]
        ldr r0, =GPBDAT
        mov r1, #1
next:
        mvn r1, r1
        str r1, [r0]
        bl delay
        b next

delay:
        ldr r4, =100000
delay1: sub r4, r4, #1
        cmp r4, #0
        bgt delay1
        mov pc, lr

main_loop:
        b main_loop

文件名 gpio.inc

.equ GPACON, 0x56000000
.equ GPADAT, 0x56000004

.equ GPBCON, 0x56000010
.equ GPBDAT, 0x56000014
.equ GPBUP,  0x56000018

.equ GPCCON, 0x56000020
.equ GPCDAT, 0x56000024
.equ GPCUP,  0x56000028

.equ GPDCON, 0x56000030
.equ GPDDAT, 0x56000034
.equ GPDUP,  0x56000038

.equ GPECON, 0x56000040
.equ GPEDAT, 0x56000044
.equ GPEUP,  0x56000048

.equ GPFCON, 0x56000050
.equ GPFDAT, 0x56000054
.equ GPFUP,  0x56000058

.equ GPGCON, 0x56000060
.equ GPGDAT, 0x56000064
.equ GPGUP,  0x56000068

.equ GPHCON, 0x56000070
.equ GPHDAT, 0x56000074
.equ GPHUP,  0x56000078

.equ GPJCON, 0x560000d0
.equ GPJDAT, 0x560000d4
.equ GPJUP,  0x560000d8

文件名 Makefile

ARCH = arm-linux-
CC = $(ARCH)gcc
LD = $(ARCH)ld
OBJCOPY = $(ARCH)objcopy

all:beep.S
	$(CC) -g -c -o beep.o beep.S
	$(LD) -Ttext 0x00000000 -g -o beep-elf beep.o
	$(OBJCOPY) -O binary -S beep-elf beep.bin

clean:
	rm -f beep.o beep-elf beep.bin

.text
.global _start
_start:
        ldr r0, =0x56000010 @WATCHDOG
        mov r1, #0
        str r1, [r0]
        ldr sp, =1024*4
        bl main

halt_loop:
        b halt_loop

文件名 gpio.h

#ifndef _GPIO_H
#define _GPIO_H

#define GPACON (*(volatile unsigned int*)0x56000000)
#define GPADAT (*(volatile unsigned int*)0x56000004)

#define GPBCON (*(volatile unsigned int*)0x56000010)
#define GPBDAT (*(volatile unsigned int*)0x56000014)
#define GPBUP  (*(volatile unsigned int*)0x56000018)

#define GPCCON (*(volatile unsigned int*)0x56000020)
#define GPCDAT (*(volatile unsigned int*)0x56000024)
#define GPCUP  (*(volatile unsigned int*)0x56000028)

#define GPDCON (*(volatile unsigned int*)0x56000030)
#define GPDDAT (*(volatile unsigned int*)0x56000034)
#define GPDUP  (*(volatile unsigned int*)0x56000038)

#define GPECON (*(volatile unsigned int*)0x56000040)
#define GPEDAT (*(volatile unsigned int*)0x56000044)
#define GPEUP  (*(volatile unsigned int*)0x56000048)

#define GPFCON (*(volatile unsigned int*)0x56000050)
#define GPFDAT (*(volatile unsigned int*)0x56000054)
#define GPFUP  (*(volatile unsigned int*)0x56000058)

#define GPGCON (*(volatile unsigned int*)0x56000060)
#define GPGDAT (*(volatile unsigned int*)0x56000064)
#define GPGUP  (*(volatile unsigned int*)0x56000068)

#define GPHCON (*(volatile unsigned int*)0x56000070)
#define GPHDAT (*(volatile unsigned int*)0x56000074)
#define GPHUP  (*(volatile unsigned int*)0x56000078)

#define GPJCON (*(volatile unsigned int*)0x560000d0)
#define GPJDAT (*(volatile unsigned int*)0x560000d4)
#define GPJUP  (*(volatile unsigned int*)0x560000d8)

#endif

文件名 key.c

#include "gpio.h"

void delay()
{
    int i;
    for (i=0; i<100000; i++);
}

void main()
{
    GPFCON = 0b0011000000;
    GPFDAT = 0b10111;

    GPBCON = (0b01010101<<10);
    GPBDAT = 0b111100000;
    while(1)
    {
        if((GPFDAT & 0b10) == 0)                   //key1
        {
            GPBDAT = 0b111000000;
        }
        else if((GPFDAT & 0b10000) == 0)        //key2
        {
            GPBDAT = 0b110100000;
        }
        else if((GPFDAT & 0b100) == 0)          //key3
        {
            GPBDAT = 0b101100000;
        }
        else if((GPFDAT & 0b1) == 0)            //key4
        {
            GPBDAT = 0b011100000;
        }
        else continue;
        delay();
        GPBDAT = 0b111100000;
    }
}

文件名 Makefile

ARCH = arm-linux-
CC = $(ARCH)gcc
LD = $(ARCH)ld
OBJDUMP = $(ARCH)objdump
OBJCOPY = $(ARCH)objcopy

all: crt0.S key.c
	$(CC) -nostdlib -g -c -o crt0.o crt0.S
	$(CC) -nostdlib -g -c -o key.o key.c
	$(LD) -Ttext 0x00000000 -g crt0.o key.o -o key-elf
	$(OBJCOPY) -O binary -S key-elf key_c.bin
	$(OBJDUMP) -D -m arm key-elf > key.dis

clean:
	rm -f *.o key-elf key_c.bin key.dis

程序如下：

@  文件名：led_on.s
.equ GPBCON, 0x56000010
.equ GPBDAT, 0x56000014
.equ GPBUP,  0x56000018

.text
.global _start
_start:
    LDR R0,=GPBCON
    MOV R1,#0b010101010000000000    @将GPB5、6、7、8设为输出
    STR R1,[R0]
    LDR R0,=GPBDAT
    MOV R1,#0x00000000
n:  MVN R1,R1
    STR R1,[R0]
    LDR R2,=100000
w:  SUB R2,R2,#1
    CMP R2,#0
    BGT w
    B n

MAIN_LOOP:
    B MAIN_LOOP
.end

Makefile内容如下：

ARCH=arm-linux-
CC=$(ARCH)gcc
LD=$(ARCH)ld
Objcopy=$(ARCH)objcopy

led_on:led_on.s
	$(CC) -g -c -o led_on.o led_on.s
	$(LD) -Ttext 0x00000000 -g led_on.o -o led_on_elf
	$(Objcopy) -O binary -S led_on_elf led_on.bin
clean:
	rm -f led_on.bin
	rm -f led_on.o
	rm -f led_on_elf

创建一个TreeView的步骤：
1、创建一个模式，TreeModel或ListModel；
2、向模式中添加数据；
3、创建视图TreeView，并添加之前创建的模式；
4、创建列TreeViewColumn,并添加视图TreeView中；
5、创建渲染器CellRenderer，并添加到列TreeViewColumn中；
6、设置行选择信号函数和渲染器操作信号函数。

其中GTK提供的渲染器有CellRendererAccel、CellRendererCombo、CellRendererPixbuf、CellRendererProgress、CellRendererSpin、CellRendererSpinner、CellRendererText、CellRendererToggle 8种

这里有个例子介绍了这几种渲染器的用法，可以参考下再举一反三：

https://gist.github.com/2389339

# PIL的Image类型转化为gtk的Image类型
import gtk
import StringIO

f = StringIO.StringIO()
#im为PIL的Image类型
im.save(f, "ppm")
contents = f.getvalue()
f.close()
loader = gtk.gdk.PixbufLoader("pnm")
loader.write(contents, len(contents))
pixbuf = loader.get_pixbuf()
loader.close()
i = gtk.Image()
i.set_from_pixbuf(pixbuf)

#!/usr/bin/env python
#-*- coding:utf-8 -*-
##
# @文件名(file): date.py
# @作者(author): 龙昌锦(LongChangjin)
# @博客(blog): http://www.xefan.com
# @时间(date): 2012-04-13
# 

monthday = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
weekname = ["星期日","星期一","星期二","星期三","星期四","星期五","星期六"]
# 计算某年某月某日是星期几
# 基姆拉尔森计算公式
def week(y, m, d):
    if m == 1 or m == 2:
        m = m + 12
        y = y - 1
    w = ((d + 2 * m + 3 * (m+1) / 5 + y + y/4 - y/100 + y/400) + 1) % 7
    return int(w)

year, month = input("输入日期，如：2012,4:")
if year%4 == 0:
    monthday[1] = 29
w = week(year, month, 1)

print("%d年%d月" % (year, month))
print weekname[0], weekname[1], weekname[2], weekname[3], weekname[4], weekname[5], weekname[6]
i = 0
while i < w:
    print("      "),
    i = i + 1
i = 1
while i <= monthday[month-1]:
    print("%3d   " % i),
    i = i + 1
    w = w + 1
    if w == 7:
        print("")
        w = 0

#运行结果如下：
#[lcj@lcj time]$ python date.py
#输入日期，如：2012,4:2012,2
#2012年2月
#星期日 星期一 星期二 星期三 星期四 星期五 星期六
#                       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
#[lcj@lcj time]$

设置方法：
打开开发板电源后进入u-boot，然后选择“[0] Set the boot parameters”。
再选择“[1] Set NFS boot parameter ”。
然后依次输入PC的IP、开发板的IP、子网掩码、NFS目录。
例子如下：
Enter the PC IP address:(xxx.xxx.xxx.xxx)
10.10.10.2
Enter the SKY2440/TQ2440 IP address:(xxx.xxx.xxx.xxx)
10.10.10.3
Enter the Mask IP address:(xxx.xxx.xxx.xxx)
255.255.255.0
Enter NFS directory:(eg: /opt/EmbedSky/root_nfs)
/opt/EmbedSky/root
bootargs: console=ttySAC0 root=/dev/nfs nfsroot=10.10.10.2:/opt/EmbedSky/root ip=10.10.10.3:10.10.10.2:10.10.10.3:255.255.255.0:SKY2440.embedsky.net:eth0:off

输入好后再选择“[s] Save the parameters to Nand Flash”保存设置即可。

以上是一般情况，下面再说说我的特殊情况。

=====================分割线===============================
我在PC上安装的是ArchLinux，按照以上方法运行时挂载失败，提示Root-NFS: Server returned error -93 while mounting /opt/EmbedSky/root
－93的意思好像是没有这个协议。

于是我又在虚拟机里安装了ubuntu，再尝试以上方法结果却成功了。
最后我查了资料，原因好像是u-boot使用的nfs3，而ArchLinux的官网上说nfs3太老了所以Arch用的是nfs4。因此就出现了这个问题。
解决方法：添加一个”,v3″参数。如：
Enter NFS directory:(eg: /opt/EmbedSky/root_nfs)
/opt/EmbedSky/root,v3
bootargs: console=ttySAC0 root=/dev/nfs nfsroot=10.10.10.2:/opt/EmbedSky/root,v3 ip=10.10.10.3:10.10.10.2:10.10.10.3:255.255.255.0:SKY2440.embedsky.net:eth0:off

git init 初始化
git add <file> 将file添加到跟踪
git commit -m “..” 将修改提交到库，备注为”…”
git commit -a -m “…” 将所有跟踪文件全部提交
git status 查看状态
git rm <file> 移除文件，之后再commit提交
git mv <file1> <file2> 移动文件，之后再commit提交

git log 查看记录
git commit —amend 修改最后一次提交
git remote -v 查看远程仓库，-v显示地址
git remote add <shortname> <url> 添加远程仓库，别名为shortname
git fetch <remote-name> 从远程仓库抓取数据
git push <remote-name> <branch> 从本地branch推送到远程remote

git tag 显示所有标签
git tag -l <reg> 按照reg表达式来搜索标签
git tag -a <name> -m “..” 创建标签
git tag -a <name> <hash> 为某次提交打标签
git push remote —tags 推送本地所有标签

git branch <name> 从当前分支新建一个分支
git checkout <name> 切换到name分支
git checkout -b <name> 新建并切换到name分支
Gti merge <name> 将name分支合并到当前分支
git branch -d <name> 删除name分支
git branch -v 查看各分支最后一次提交

git fetch <remote-name> 从远程分支获取数据
git push <remote> [localbranch]:[remotebranch] 推送本地localbran到远程remotebranch，若localbranch参数为空则删除远程remotebranch分支
git chekcout -b <branch> <remote/branch> 从远程分支分化出一个新本地分支

git stash 暂存不想提交的修改
git stash list 查看暂存列表
git stash apply <stash-name> 应用暂存

git checkout —set-upstream <localbranch> <remote/branch> 本地分支localbranch跟踪远程分支branch
git clone <url> 克隆远程项目

git submodule add <url> <name> 创建子模块，保存到name目录
git submodule init 初始化子模块
git submodule update 从远程下载更新子模块

git archive [--format==tar|zip] [--prefix=<prefix>/] [-o file] <commit> [<path>...] 将commit提交记录中的path目录下的文件以format格式打包导出到file
git revert HEAD^ 撤消前前一次提交
git revert <hash> 撤消指定的版本
git revert —hard <commit> 彻底回退到某个版本

函数： key_t ftok(const char *filename, int proj_id);
通过文件名和项目号获得System V IPC键值（用于创建消息队列、共享内存所用）
proj_id：项目号，不为0即可
返回：成功则返回键值，失败则返回-1

函数： int msgget(key_t key, int msgflg)；
key：键值，当为IPC_PRIVATE时新建一块共享内存；
shmflg：标志。
IPC_CREAT：内存不存在则新建，否则打开；
IPC_EXCL：只有在内存不存在时才创建，否则出错。
返回：成功则返回标识符，出错返回-1

函数： int msgsnd(int msgid, const void *msgp, size_t sz, int flg)；
向消息队列发送消息
msgid：通过msgget获取
msgp：指向消息内容的指针
sz：消息内容的大小
flg：处理方式；如为IPC_NOWAIT时表示空间不足时不会阻塞
返回：成功则返回0，失败返回-1

函数： int msgrcv(int msgid, void *msgp, size_t sz, long type, int flg)；
从消息队列读取消息
msgid：通过msgget获取
msgp：指向消息内容的指针
sz：消息内容的大小
type：指定接收的消息类型；若为0则队列第一条消息将被读取，而不管类型；若大于0则队列中同类型的消息将被读取，如在flg中设了MSG_RXCEPT位将读取指定类型的其他消息；若小于0读取绝对值小于type的消息。
flg：处理方式；
返回：成功返回收到消息长度，错误返回-1

函数： int msgctl(int msgid, int cmd, struct msgid_ds *buf)；
msgid：通过msgget获取
cmd：控制命令，如下：
IPC_STAT：获取消息队列状态
IPC_SET：改变消息队列状态
IPC_RMID：删除消息队列
buf：结构体指针，用于存放消息队列状态
返回：成功返回与cmd相关的正数，错误返回-1

注意：消息队列一旦创建就会一直存在系统中，直到手动删除或者重启系统。可以使用ipcs -q命令来查看系统存在的消息队列。

例子：

/****************************************
 *
 * 使用消息队列进行进程通信——写进程
 * 该进程用于创建信号量
 * 龙昌博客：http://www.xefan.com
 *
 ****************************************/
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>

typedef struct _msg_buf{
    long type;          //消息类型
    char buf[100];      //消息内容
} msg_buf;

int main()
{
    int key, qid;
    msg_buf buf;
    key = ftok("tmp", 10);
    qid = msgget(key, IPC_CREAT);
    printf("key: %d\nqid: %d\n", key, qid);
    buf.type = 10;
    while (1)
    {
        fgets(buf.buf, 100, stdin);
        if (msgsnd(qid, (void *)&buf, 100, 0) < 0)
        {
            perror("msgsnd");
            exit(-1);
        }
    }
    return 0;
}

/****************************************
 *
 * 使用消息队列进行进程通信——读进程
 * 该进程用于创建信号量
 * 龙昌博客：http://www.xefan.com
 *
 ****************************************/
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <stdio.h>

typedef struct _msg_buf{
    long type;          //消息类型
    char buf[100];      //消息内容
} msg_buf;

int main()
{
    int key, qid;
    msg_buf buf;
    key = ftok("tmp", 10);
    qid = msgget(key, IPC_CREAT);
    printf("key: %d\nqid: %d\n", key, qid);
    while (1)
    {
        if (msgrcv(qid, (void *)&buf, 100, 0, 0) < 0)
        {
            perror("msgrcv");
            exit(-1);
        }
        printf("type:%d\nget:%s\n", buf.type, buf.buf);
    }
    return 0;
}

先运行写进程再运行读进程。

函数： key_t ftok(const char *filename, int proj_id);
通过文件名和项目号获得System V IPC键值（用于创建消息队列、共享内存所用）
proj_id：项目号，不为0即可
返回：成功则返回键值，失败则返回-1

函数： int semget(key_t key, int nsems, int msgflg)；
key：键值，当为IPC_PRIVATE时新建。
nsems：信号个数。
msgflg：标志。
IPC_CREAT：不存在则新建，否则打开；
IPC_EXCL：与IPC_CREAT一同使用时，只有在不存在时才创建，否则出错。
返回：成功则返回IPC标识符，出错返回-1

函数： int semop(int semid, struct sembuf *sops, unsigned nsops)；
semid：通过semget获取
sops：指向待操作的信号灯结构体，原型如下：
struct sembuf{
unsigned short sem_num; //信号灯编号，从0开始
short sem_op; //为正数代表释放信号；为负代表获取信号
Short sem_flg; //操作的标识；IPC_NOWAIT：不阻塞；IPC_UNDO：程序结束时释放信号量
}
nsops：要操作的信号量数
返回：成功则返回共享内存起始地址，失败返回-1

函数： void semctl(int semid, int semnum, int cmd, union semun arg)；
semid：通过semget获取
semnum：操作的信号灯编号
cmd：控制命令，如下：
GETPID：获取sempid
GETVAL：获取semval
SETVAL：设置semval
IPC_RMID：删除信号灯
arg：各个量使用与cmd设置有关
返回：成功返回与cmd相关的正数，错误返回-1

注意：信号量一旦创建就会一直存在系统中，直到手动删除或者重启系统。可以使用ipcs -s命令来查看系统存在的信号量。

例子：

/****************************************
 *
 * 使用信号量进行进程通信——进程1
 * 该进程用于创建信号量
 * 龙昌博客：http://www.xefan.com
 *
 ****************************************/
#include <sys/types.h>
//书上说是用sys/ipc.h和sys/sem.h这两个头文件，但是我用了出错，
//而用linux/ipc.h和linux/sem.h却没问题
//#include <sys/ipc.h>
//#include <sys/sem.h>
#include <linux/sem.h>
#include <linux/ipc.h>
#include <errno.h>
#include <math.h>

int main(int argc, char *argv[])
{
    int key, sid, pid;
    union semun val;
    val.val = 1;
    key = ftok("tmp",10);
    if ((sid = semget(key, 1, IPC_CREAT)) < 0)
    {
        perror("semget");
        exit(-1);
    }
    printf("key: %d  sid:%d\n", key, sid);

    if ((semctl(sid, 0, SETVAL, val)) < 0)
    {
        perror("semctl");
        exit(-1);
    }
    if ((semctl(sid, 0, GETVAL, val)) < 0)
    {
        perror("semctl");
        exit(-1);
    }
    printf("sem_val:%d\n", val.val);

    struct sembuf p_op, v_op;
    p_op.sem_num = 0;
    p_op.sem_op = -1;
    //获取信号
    if (semop(sid, &p_op, 1) < 0) //p op
    {
        perror("smeop");
        exit(-1);
    }
    printf("father get the semaphore\n");
    sleep(8);
    printf("father release the senaphore\n");
    v_op.sem_num = 0;
    v_op.sem_op = 1;
    v_op.sem_flg = 0;
    //释放信号
    if (semop(sid, &v_op, 1) < 0) //v op
    {
        perror("semop");
        exit(-1);
    }
    return 0;
}

/****************************************
 *
 * 使用信号量进行进程通信——进程2
 * 该进程用于获取信号量
 * 龙昌博客：http://www.xefan.com
 *
 ****************************************/
#include <sys/types.h>
//书上说是用sys/ipc.h和sys/sem.h这两个头文件，但是我用了出错，
//而用linux/ipc.h和linux/sem.h却没问题
//#include <sys/ipc.h>
//#include <sys/sem.h>
#include <linux/sem.h>
#include <linux/ipc.h>
#include <errno.h>
#include <math.h>

int main(int argc, char *argv[])
{
    int key, sid, pid;
    key = ftok("tmp",10);
    if ((sid = semget(key, 1, IPC_CREAT)) < 0)
    {
        perror("semget");
        exit(-1);
    }
    printf("key: %d  sid:%d\n", key, sid);

    struct sembuf p_op, v_op;
    p_op.sem_num = 0;
    p_op.sem_op = -1;
    //p_op.sem_flg = 0;
    if (semop(sid, &p_op, 1) < 0) //p op
    {
        perror("smeop");
        exit(-1);
    }
    printf("father get the semaphore\n");
    sleep(8);
    printf("father release the senaphore\n");
    v_op.sem_num = 0;
    v_op.sem_op = 1;
    v_op.sem_flg = 0;
    if (semop(sid, &v_op, 1) < 0) //v op
    {
        perror("semop");
        exit(-1);
    }
    return 0;
}

先运行进程1，再运行进程2查看效果

函数：shmget 分配共享内存
函数原型： int shmget(key_t key, size_t size, int shmflg)；
key：键值，当为IPC_PRIVATE时新建一块共享内存；若为0时而shmflg中设了IPC_PRIVATE也将新建。
size：内存大小。
shmflg：标志。
IPC_CREAT：内存不存在则新建，否则打开；
IPC_EXCL：只有在内存不存在时才创建，否则出错。
返回：成功则返回标识符，出错返回-1

函数： void *shmat(int shmid, char *shmaddr, int shmflg)；
shmid：通过shmget获取
shmaddr：映射到进程地址空间的起始地址，设为NULL将自动分配
shmflg：标志；SHM-RDONLY为只读，否则可读可写
返回：成功则返回内存起始地址，失败返回-1

函数： int shmdt(const void *shmaddr)；
使共享内存区脱离映射的进程的地址空间
返回：成功返回0，错误返回-1

函数： void shmctl(int shmid, int cmd, struct shmid_ds *buf)；
shmid：通过shmget获取
cmd：控制命令，如下：
IPC_STAT：获取内存状态
IPC_SET：改变内存状态
IPC_RMID：删除内存
buf：结构体指针，用于存放共享内存状态
返回：成功返回0，错误返回-1

注意：共享内存一旦创建就会一直存在系统中，直到手动删除或者重启系统。
例子：

/**************************************
 *
 * 使用共享内存进行进程通信
 * 龙昌博客：http://www.xefan.com
 *
**************************************/
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/stat.h>
#include <errno.h>
#include <string.h>

int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        printf("Usage:%s str\n", argv[0]);
        exit(1);
    }
    int shmid;
    char *p_addr, *c_addr;
    //创建共享内存
    if ((shmid=shmget(IPC_PRIVATE, 1024, IPC_CREAT)) == -1)
    {
        perror("shmget");
        exit(errno);
    }
    if(fork() > 0)	//父进程向内存写入数据
    {
        //获取内存起始地址
	p_addr = shmat(shmid, 0, 0);
        memset(p_addr, 0, 1024);
	//向内存中写入数据
        strncpy(p_addr, argv[1], 1024);
        shmdt(p_addr);
        sleep(3);
        wait(0);
    }
    else		//子进程从内存中读取数据
    {
        //获取内存起始地址
        c_addr = shmat(shmid, 0, 0);
        sleep(4);
        printf("child get %s\n", c_addr);
        shmdt(c_addr);
    }
    //删除共享内存
    if (shmctl(shmid, IPC_RMID, NULL) < 0)
    {
        perror("shmctl");
        exit(1);
    }
    return 0;
}

函数：pause 让进程暂停直到信号出现
头文件：#include <unistd.h>
函数原型： int pause(void)；
只返回-1

函数： kill 传送信号
头文件：
#include <signal.h>
#include <sys/types.h>
函数原型： int kill(pid_t pid, int sig)；
pid：接收信号的进程号；当pid=0时为相同进程组的所有进程；当pid=-1时为系统内所有进程；当pid>0时为指定进程；当pid<-1时为进程组识别码为pid绝对值的所有进程。
sig：要传送的信号
返回：成功返回0，错误返回-1

例子：

/****************************************
 *
 *设置信号处理
 *等待2秒后向进程本身传送一个SIGALRM信号
 *龙昌博客：http://www.xefan.com
 *
 ****************************************/
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

void func(int sig_no)
{
    if (sig_no == SIGALRM)
    {
        printf("get SIGALRM\n");
    }
}

int main()
{
    printf("%d waiting for signal..\n", getpid());
    alarm(2);
    signal(SIGALRM, func);
    raise(SIGALRM);
    pause();
    return 0;
}

函数：
int mkfifo(const char *filename, mode_t mode);
创建有名管道对应的实名文件，该文件必须事先不存在。
返回0代表创建成功，否则返回-1。
filename：文件路径
mode：文件权限

创建成功之后可以像操作普通文件一样使用read、write进行读写操作。

例子：

/**************************************
 *
 * 使用有名管道进行进程通信——写进程
 * 文件名：fifo_write.c
 * 龙昌博客：http://www.xefan.com
 *
**************************************/

#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <errno.h>

#define FIFO "/tmp/myfifo"

int main(int argc, char *argv[])
{
    int fd;
    char buf[100];
    int num;

    unlink(FIFO);	//先删除文件
    //创建有名管道
    if ( (mkfifo(FIFO, O_CREAT|O_EXCL|O_RDWR) < 0) && (errno != EEXIST))
    {
        perror("mkfifo");
    }

    fd = open(FIFO, O_WRONLY);
    if (fd < 0)
    {
        perror("open");
        exit(1);
    }
    while (1)
    {
        scanf("%s", buf);
        if ((num=write(fd, buf, 100)) < 0)
        {
            if(errno == EAGAIN)
            {
                printf("FIFO has not been read yet.\n");
            }
        }
    }
    close(fd);
    return 0;
}

/**************************************
 *
 * 使用有名管道进行进程通信——读进程
 * 文件名：fifo_read.c
 * 龙昌博客：http://www.xefan.com
 *
**************************************/
#include <sys/stat.h>
#include <sys/types.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>

#define FIFO "/tmp/myfifo"

int main(int argc, char *argv[])
{
    int fd;
    int num;
    char buf[100];

    //打开管道文件
    //fd = open(FIFO, O_RDONLY|O_NONBLOCK);	//非阻塞方式打开
    fd = open(FIFO, O_RDONLY);
    if (fd < 0)
    {
        perror("open");
        exit(1);
    }
    while (1)
    {
        memset(buf, 0, sizeof(buf));
        if ((num=read(fd, buf, 100)) < 0)
        {
            if (errno == EAGAIN)
            {
                printf("no data yet\n");
            }
            sleep(1);
            continue;
        }
        printf("read  %s  from FIFO\n", buf);
        sleep(1);
    }
    return 0;
}

先运行写进程再运行读进程

函数：
int pipe(int fd[2]);
创建无名管道。
fd[2]：管道两个文件描述符，fd[0]代表读端（管道头），fd[1]代表写端（管道尾）。
创建成功返回0，失败返回-1。

创建成功之后可以像操作普通文件一样使用read、write进行读写操作。
例子：

/**********************************
 *
 * 使用无名管道进行进程通信
 * 龙昌博客：http://www.xefan.com
 *
***********************************/
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[])
{
    int pfd[2];
    pid_t pid;
    char buf[100];
    int num;

    memset(buf, 0, sizeof(buf));

    if (pipe(pfd) < 0)  //创建无名管道
    {
        perror("pipe");
        exit(-1);
    }
    //父进程向管道写数据，子进程从管道读数据
    if ((pid=fork()) == 0)
    {
        sleep(1);
        if ((num=read(pfd[0], buf, 100)) > 0)
        {
            printf("%d numbers read, %s\n", num, buf);
        }
    }
    else if (pid > 0)
    {
        if (write(pfd[1], "Hello", 5) < 0)
        {
            perror("write");
        }
        if (write(pfd[1], " Pipe", 5) < 0)
        {
            perror("write");
        }
        waitpid(pid, NULL, 0);
    }
    close(pfd[0]);
    close(pfd[1]);
    return 0;
}

函数：
pid_t fork();
创建一个子进程，在子进程中返回0，在父进程中返回子进程ID，出错则返回-1。
pid_t vfor();
创建一个子进程，与fork()相似；区别如下：
fork()子进程拷贝父进程数据段、堆栈段，vfork()则是共享；
fork()父子进程执行顺序不确定，vfork()是先执行完子进程再执行父进程。

pid_t getpid();
返回当前进程ID
pid_t getppid();
返回父进程ID

进程等待
头文件：
#include <sys/wait.h>

函数：
pid_t wait(int *status);
等子进程结束之后才运行。
status：接收子进程返回状态

pid_t waitpid(pid_t pid, int *status, int options);
与waitpid()相似。
pid：指定的进程号，当pid=-1时等待任何子进程，相当于wait()；
status：用于接收进程返回状态；
option：为WNOHANG时若无任何已结束的子进程则马上返回，不予以等待；为WUNTRACES时若子进程暂停则马上返回，不予以理会结束状态。

例子：

//使用vfor函数创建子进程
//龙昌博客：http://www.xefan.com
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <math.h>

int main(void)
{
	pid_t child;
        int i = 0;

	/* 创建子进程 */
	if((child=vfork())==-1)
	{
		printf("Fork Error : %s\n", strerror(errno));
		exit(1);
	}
	else
	{
		if(child > 0)
		{
                        i++;
			printf("I am the father: %d ;i=%d\n", getpid(), i);
			exit(0);
		}
		else
		{
                        i++;
			printf("I am the child:%d ;i=%d\n",getpid(), i);
                        sleep(1);
			exit(0);
		}
	}
}

然后依次解压MinGW-gcc440_1.zip、安装qt-win-opensource-4.7.4-mingw.exe。记得要将gcc的目录和qt的目录添加到环境变量中。

然后打开DOS窗口并切换到Qt的目录（比如我的是D:\Qt\4.7.4），再设置两个变量
set QTDIR=D:\Qt\4.7.4
set QMAKESPEC=win32-g++

再编辑D:\Qt\4.7.4\mkspecs\win32-g++\qmake.conf文件（最好先备份），改两处：
QMAKE_LFLAGS = -enable-stdcall-fixup -Wl,-enable-auto-import -Wl,-enable-runtime-pseudo-reloc
修改为
QMAKE_LFLAGS = -static -enable-stdcall-fixup -Wl,-enable-auto-import -Wl,-enable-runtime-pseudo-reloc
再将
QMAKE_LFLAGS_DLL = -shared
修改为
QMAKE_LFLAGS_DLL = -static

再执行命令：
configure -platform win32-g++ -release -opensource -static -fast -qt-sql-sqlite -plugin-sql-sqlite -qt-zlib -qt-gif -qt-libpng -qt-libmng -qt-libtiff -qt-libjpeg -no-webkit -nomake examples -nomake docs -nomake demos

如果有提问是否遵守LGPL协议，选y。配置完成后，最后两句是这样的：
Qt is now configured for building. Just run mingw32-make.
To reconfigure, run mingw32-make confclean and configure.

cd src
mingw32-make -i -k

注意：我们只在在Qt子目录src里运行make。不要在整个qt库的大目录下运行make。只在src目录make，这样只编译核心的Qt库和一些插件，节省时间，而且有核心Qt库就够用了。
如果在D:\Qt\4.7.4\ 整个大目录下运行make，那么make还会去重新编译生成tools目录下的代码，重新做工具程序，像assistant.exe、designer.exe、linguist.exe、qmlviewer.exe等等（生成后全在bin目录）。这些工具使用静态库生成后巨大无比。这些工具程序不管是静态链接还是动态链接生成的，对我们编程压根没影响，都一样用。

好了，接下来就是漫长的等待。2个多小时左右就应该可以编译完成了。
此时再用Qt编译生成的可执行文件不用再信赖Qt的动态库了,但是文件比较大随便一个都是10M以上，而且如果使用的是从qt官网下载的MinGW-gcc编译生成的可执行文件还是会信赖mingwm10.dll动态库。这个只需换一个版本的编译器即可，我用的是这个： http://115.com/file/dn3fkn1g

如果嫌这个过程太麻烦可以直接下载我编译好的静态库来使用：
Qt4.7.4_Win32静态库.part1.rar： http://115.com/file/dn3zwayy
Qt4.7.4_Win32静态库.part2.rar： http://115.com/file/dn3zwa9g
这个是完整版的，解压下来有2G多。如果觉得太大了可以下载精简版：
Qt4.7.4_Win32静态库精简版.rar： http://115.com/file/bhy7bat6
精简版只保留了编译时需要的库文件和qmake等必要的工具，解压下来有500M左右。
注意：只有解压到D盘根目录下才能使用
编译器用的是mingw-7.2.exe： http://115.com/file/dn3fkn1g

先说一下在Windows下编译的方法。

解压文件，然后进入解压后的bin目录执行命令：
pkg-config.exe –libs –cflags “gtk+-2.0″
如果出现以下错误
Package gtk+-2.0 was not found in the pkg-config search path.
Perhaps you should add the directory containing `gtk+-2.0.pc’
to the PKG_CONFIG_PATH environment variable
No package ‘gtk+-2.0′ found
则先执行命令：set PKG_CONFIG_PATH=你的解压路径\lib\pkgconfig 设置PKG_CONFIG_PATH环境变量

我得到的结果是：
-mms-bitfields -IE:/Dev-Cpp/gtk+-2.0/include/gtk-2.0 -IE:/Dev-Cpp/gtk+-2.0/lib/gtk-2.0/include -IE:/Dev-Cpp/gtk+-2.0/include/atk-1.0 -IE:/Dev-Cpp/gtk+-2.0/include/cairo -IE:/Dev-Cpp/gtk+-2.0/include/gdk-pixbuf-2.0 -IE:/Dev-Cpp/gtk+-2.0/include/pango-1.0 -IE:/Dev-Cpp/gtk+-2.0/include/glib-2.0 -IE:/Dev-Cpp/gtk+-2.0/lib/glib-2.0/include -IE:/Dev-Cpp/gtk+-2.0/include/pixman-1 -IE:/Dev-Cpp/gtk+-2.0/include -IE:/Dev-Cpp/gtk+-2.0/include/freetype2 -I/gtk-dev/include/libpng14 -LE:/Dev-Cpp/gtk+-2.0/lib -L/gtk-dev/lib -lgtk-win32-2.0 -lgdk-win32-2.0 -limm32 -lshell32 -luuid -latk-1.0 -lpangocairo-1.0 -lgio-2.0 -lshlwapi -ldnsapi -lgdk_pixbuf-2.0 -ltiff -ljpeg -ljasper -lpangoft2-1.0 -lpangowin32-1.0 -lusp10 -lfontconfig -lexpat -lpango-1.0 -lcairo -lpixman-1 -lfreetype -lmsimg32 -lgdi32 -lpng -lz -lm -lgobject-2.0 -lgmodule-2.0 -lgthread-2.0 -lglib-2.0 -lintl -liconv -lws2_32 -lole32

记得保存这个结果，作为编译时的参数在后面要用到。
然后编译一个程序试试，将以下代码保存为test.c文件。

#include <gtk/gtk.h>
int main(int argc,char *argv[]){
    GtkWidget *window, *label;
    gtk_init(&argc,&argv);
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(window),"Hellow World");
    g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
    label = gtk_label_new("龙昌博客:http://www.xefan.com");
    gtk_container_add (GTK_CONTAINER (window), label);
    gtk_widget_show_all(window);
    gtk_main();
    return 0;
}

执行命令进行编译：
gcc -o test.exe test.c -mms-bitfields -IE:/Dev-Cpp/gtk+-2.0/include/gtk-2.0 -IE:/Dev-Cpp/gtk+-2.0/lib/gtk-2.0/include -IE:/Dev-Cpp/gtk+-2.0/include/atk-1.0 -IE:/Dev-Cpp/gtk+-2.0/include/cairo -IE:/Dev-Cpp/gtk+-2.0/include/gdk-pixbuf-2.0 -IE:/Dev-Cpp/gtk+-2.0/include/pango-1.0 -IE:/Dev-Cpp/gtk+-2.0/include/glib-2.0 -IE:/Dev-Cpp/gtk+-2.0/lib/glib-2.0/include -IE:/Dev-Cpp/gtk+-2.0/include/pixman-1 -IE:/Dev-Cpp/gtk+-2.0/include -IE:/Dev-Cpp/gtk+-2.0/include/freetype2 -I/gtk-dev/include/libpng14 -LE:/Dev-Cpp/gtk+-2.0/lib -L/gtk-dev/lib -lgtk-win32-2.0 -lgdk-win32-2.0 -limm32 -lshell32 -luuid -latk-1.0 -lpangocairo-1.0 -lgio-2.0 -lshlwapi -ldnsapi -lgdk_pixbuf-2.0 -ltiff -ljpeg -ljasper -lpangoft2-1.0 -lpangowin32-1.0 -lusp10 -lfontconfig -lexpat -lpango-1.0 -lcairo -lpixman-1 -lfreetype -lmsimg32 -lgdi32 -lpng -lz -lm -lgobject-2.0 -lgmodule-2.0 -lgthread-2.0 -lglib-2.0 -lintl -liconv -lws2_32 -lole32
如果不出错的话则生成一个test.exe的可执行文件。
如果没有gcc的话，可以下载安装一个MinGW程序，我之前用MinGW的gcc 4.4.0版本来编译结果出错了，然后换了个4.6版本的才能顺利编译，下载地址：http://nuwen.net/mingw.html

然后再介绍下在Linux下交叉编译的方法。

前一篇文章介绍了在Linux下交叉编译Windows程序的方法。现在只需把上面的参数的路径改下即可。
我的Windows的E盘在Linux下挂载到/mnt/Win_E ，再用上面的程序测试，执行命令：
i486-mingw32-gcc -o test.exe test.c -mms-bitfields -I/mnt/Win_E/Dev-Cpp/gtk+-2.0/include/gtk-2.0 -I/mnt/Win_E/Dev-Cpp/gtk+-2.0/lib/gtk-2.0/include -I/mnt/Win_E/Dev-Cpp/gtk+-2.0/include/atk-1.0 -I/mnt/Win_E/Dev-Cpp/gtk+-2.0/include/cairo -I/mnt/Win_E/Dev-Cpp/gtk+-2.0/include/gdk-pixbuf-2.0 -I/mnt/Win_E/Dev-Cpp/gtk+-2.0/include/pango-1.0 -I/mnt/Win_E/Dev-Cpp/gtk+-2.0/include/glib-2.0 -I/mnt/Win_E/Dev-Cpp/gtk+-2.0/lib/glib-2.0/include -I/mnt/Win_E/Dev-Cpp/gtk+-2.0/include/pixman-1 -I/mnt/Win_E/Dev-Cpp/gtk+-2.0/include -I/mnt/Win_E/Dev-Cpp/gtk+-2.0/include/freetype2 -I/gtk-dev/include/libpng14  -L/mnt/Win_E/Dev-Cpp/gtk+-2.0/lib -L/gtk-dev/lib -lgtk-win32-2.0 -lgdk-win32-2.0 -limm32 -lshell32 -luuid -latk-1.0 -lpangocairo-1.0 -lgio-2.0 -lshlwapi -ldnsapi -lgdk_pixbuf-2.0 -ltiff -ljpeg -ljasper -lpangoft2-1.0 -lpangowin32-1.0 -lusp10 -lfontconfig -lexpat -lpango-1.0 -lcairo -lpixman-1 -lfreetype -lmsimg32 -lgdi32 -lpng -lz -lm -lgobject-2.0 -lgmodule-2.0 -lgthread-2.0 -lglib-2.0 -lintl -liconv -lws2_32 -lole32
然后生成 test.exe文件，可以用wine来测试下是否可用。

这个生成的文件好像有点大了，随便一个都是25M以上。使用命令：
i486-mingw32-strip hellow.exe
一下子可以减到7M左右。