Linux系统下VI命令快捷键集合

　　光标控制命令

　　命令 光标移动

　　h或^h 向左移一个字符

　　j或^j或^n 向下移一行

　　k或^p 向上移一行

　　l或空格 向右移一个字符

　　G 移到文件的最后一行

　　nG 移到文件的第n行

　　w 移到下一个字的开头

　　W 移到下一个字的开头，忽略标点符号

　　b 移到前一个字的开头

　　B 移到前一个字的开头，忽略标点符号

　　L 移到屏幕的最后一行

　　M 移到屏幕的中间一行

　　H 移到屏幕的第一行

　　e 移到下一个字的结尾

　　E 移到下一个字的结尾，忽略标点符号

　　( 移到句子的开头

　　) 移到句子的结尾

　　{ 移到段落的开头

　　} 移到下一个段落的开头

　　0或| 移到当前行的第一列

　　n| 移到当前行的第n列

　　^ 移到当前行的第一个非空字符

　　$ 移到当前行的最后一个字符

　　+或return 移到下一行的第一个字符

　　- 移到前一行的第一个非空字符

　　在vi中添加文本

　　命令 插入动作

　　a 在光标后插入文本

　　A 在当前行插入文本

　　i 在光标前插入文本

　　I 在当前行前插入文本

　　o 在当前行的下边插入新行

　　O 在当前行的上边插入新行

　　:r file 读入文件file内容，并插在当前行后

　　:nr file 读入文件file内容，并插在第n行后

　　escape 回到命令模式

　　^v char 插入时忽略char的指定意义，这是为了插入特殊字符

　　在vi中删除文本

　　命令 删除操作

　　x 删除光标处的字符，可以在x前加上需要删除的字符数目

　　nx 从当前光标处往后删除n个字符

　　X 删除光标前的字符，可以在X前加上需要删除的字符数目

　　nX 从当前光标处往前删除n个字符

　　dw 删至下一个字的开头

　　ndw 从当前光标处往后删除n个字

　　dG 删除行，直到文件结束

　　dd 删除整行

　　ndd 从当前行开始往后删除

　　db 删除光标前面的字

　　ndb 从当前行开始往前删除n字

　　:n,md 从第m行开始往前删除n行

　　d或d$ 从光标处删除到行尾

　　dcursor_command 删除至光标命令处，如dG将从当产胆行删除至文件的末尾

　　^h或backspace 插入时，删除前面的字符

　　^w 插入时，删除前面的字

修改vi文本

　　每个命令前面的数字表示该命令重复的次数

　　命令 替换操作

　　rchar 用char替换当前字符

　　R text escape 用text替换当前字符直到换下Esc键

　　stext escape 用text代替当前字符

　　S或cctext escape 用text代替整行

　　cwtext escape 将当前字改为text

　　Ctext escape 将当前行余下的改为text

　　cG escape 修改至文件的末尾

　　ccursor_cmd text escape 从当前位置处到光标命令位置处都改为text

　　在vi中查找与替换

　　命令 查找与替换操作

　　/text 在文件中向前查找text

　　?text 在文件中向后查找text

　　n 在同一方向重复查找

　　N 在相反方向重复查找

　　ftext 在当前行向前查找text

　　Ftext 在当前行向后查找text

　　ttext 在当前行向前查找text，并将光标定位在text的第一个字符

　　Ttext 在当前行向后查找text，并将光标定位在text的第一个字符

　　:set ic 查找时忽略大小写

　　:set noic 查找时对大小写敏感

　　:s/oldtext/newtext 用newtext替换oldtext

　　:m,ns/oldtext/newtext 在m行通过n，用newtext替换oldtext

　　& 重复最后的:s命令

　　:g/text1/s/text2/text3 查找包含text1的行，用text3替换text2

　　:g/text/command 在所有包含text的行运行command所表示的命令

　　:v/text/command 在所有不包含text的行运行command所表示的命令

　　在vi中复制文本

　　命令 复制操作

　　yy 将当前行的内容放入临时缓冲区

　　nyy 将n行的内容放入临时缓冲区

　　p 将临时缓冲区中的文本放入光标后

　　P 将临时缓冲区中的文本放入光标前

　　"(a-z)nyy 复制n行放入名字为圆括号内的可命名缓冲区，省略n表示当前行

　　"(a-z)ndd 删除n行放入名字为圆括号内的可命名缓冲区，省略n表示当前行

　　"(a-z)p 将名字为圆括号的可命名缓冲区的内容放入当前行后

　　"(a-z)P 将名字为圆括号的可命名缓冲区的内容放入当前行前

　　在vi中撤消与重复

　　命令 撤消操作

　　u 撤消最后一次修改

　　U 撤消当前行的所有修改

　　. 重复最后一次修改

　　, 以相反的方向重复前面的f、F、t或T查找命令

　　; 重复前面的f、F、t或T查找命令

　　"np 取回最后第n次的删除(缓冲区中存有一定次数的删除内容，一般为9)

　　n 重复前面的/或?查找命令

　　N 以相反方向重复前面的/或?命令

　　保存文本和退出vi

　　命令 保存和/或退出操作

　　:w 保存文件但不退出vi

　　:w file 将修改保存在file中但不退出vi

　　:wq或ZZ或:x 保存文件并退出vi

　　:q! 不保存文件，退出vi

　　:e! 放弃所有修改，从上次保存文件开始再编辑
vi中的选项

　　选项 作用

　　:set all 打印所有选项

　　:set nooption 关闭option选项

　　:set nu 每行前打印行号

　　:set showmode 显示是输入模式还是替换模式

　　:set noic 查找时忽略大小写

　　:set list 显示制表符(^I)和行尾符号

　　:set ts=8 为文本输入设置tab stops

　　:set window=n 设置文本窗口显示n行

　　vi的状态

　　选项 作用

　　:.= 打印当前行的行号

　　:= 打印文件中的行数

　　^g 显示文件名、当前的行号、文件的总行数和文件位置的百分比

　　:l 使用字母"l"来显示许多的特殊字符，如制表符和换行符

　　在文本中定位段落和放置标记

　　选项 作用

　　{ 在第一列插入{来定义一个段落

　　[[ 回到段落的开头处

　　]] 向前移到下一个段落的开头处

　　m(a-z) 用一个字母来标记当前位置，如用mz表示标记z

　　'(a-z) 将光标移动到指定的标记，如用'z表示移动到z

　　在vi中连接行

　　选项 作用

　　J 将下一行连接到当前行的末尾

　　nJ 连接后面n行

　　光标放置与屏幕调整

　　选项 作用

　　H 将光标移动到屏幕的顶行

　　nH 将光标移动到屏幕顶行下的第n行

　　M 将光标移动到屏幕的中间

　　L 将光标移动到屏幕的底行

　　nL 将光标移动到屏幕底行上的第n行

　　^e(ctrl+e) 将屏幕上滚一行

　　^y 将屏幕下滚一行

　　^u 将屏幕上滚半页

　　^d 将屏幕下滚半页

　　^b 将屏幕上滚一页

　　^f 将屏幕下滚一页

　　^l 重绘屏幕

　　z-return 将当前行置为屏幕的顶行

　　nz-return 将当前行下的第n行置为屏幕的顶行

　　z. 将当前行置为屏幕的中央

　　nz. 将当前行上的第n行置为屏幕的中央

　　z- 将当前行置为屏幕的底行

　　nz- 将当前行上的第n行置为屏幕的底行

　　vi中的shell转义命令

　　选项 作用

　　:!command 执行shell的command命令，如:!ls

　　:!! 执行前一个shell命令

　　:r!command 读取command命令的输入并插入，如:r!ls会先执行ls，然后读入内容

　　:w!command 将当前已编辑文件作为command命令的标准输入并执行command命令，如:w!grep all

　　:cd directory 将当前工作目录更改为directory所表示的目录

　　:sh 将启动一个子shell，使用^d(ctrl+d)返回vi

　　:so file 在shell程序file中读入和执行命令

　　vi中的宏与缩写

　　(避免使用控制键和符号，不要使用字符K、V、g、q、v、*、=和功能键)

　　选项 作用

　　:map key command_seq 定义一个键来运行command_seq，如:map e ea，无论什么时候都可以e移到一个字的末尾来追加文本

　　:map 在状态行显示所有已定义的宏

　　:umap key 删除该键的宏

　　:ab string1 string2 定义一个缩写，使得当插入string1时，用string2替换string1。当要插入文本时，键入string1然后按Esc键，系统就插入了 string2

　　:ab 显示所有缩写

　　:una string 取消string的缩写

在vi中缩进文本

　　选项 作用

　　^i(ctrl+i)或tab 插入文本时，插入移动的宽度，移动宽度是事先定义好的

　　:set ai 打开自动缩进

　　:set sw=n 将移动宽度设置为n个字符

　　n<< 使n行都向左移动一个宽度

　　n>> 使n行都向右移动一个宽度，例如3>>就将接下来的三行每行都向右移动一个移动宽度

　　1.编辑模式: 插入/替换 （按INSERT键切换）

　　2.[ESC] 指令模式

　　3.输入模式 将在指令模式下输入 a

　　新增（a,A）

　　a:从光标所在位置后面开始新增资料，光标后的资料随新增资料向后移动。

　　A:从光标所在列最后面的地方开始新增资料。

　　插入（i,I）

　　i:从光标所在位置前面开始插入资料，光标后的资料随新增资料向后移动。

　　I:从光标所在列的第一个非空白字元前面开始插入资料。

　　开始（o,O）

　　o:在光标所在列下新增一列并进入输入模式。

　　O:在光标所在列上方新增一列并进入输入模式。

　　4.存盘/退出

　　[ESC] :wq //存盘退出

　　:w! //存盘继续

　　:q //退出 （源文件未被编辑过可用）

　　:q! //强制退出

　　5.删除与改修

　　[ESC] x //删除光标所在字符

　　dd //删除光标所在列。

　　r //修改光标所在字元，r后接着要修正的字符。

　　R //进入取替换状态。

　　s //删除光标所在字元，并进入输入模式。

　　S //删除光标所在的列，并进入输入模式。

　　6.恢复

　　[ESC] u //可以恢复被删除的文字。

　　U //可以恢复光标所在列的所有改变。

C语言，结构体(struct) 用法

结构(struct)
结构是由基本数据类型构成的、并用一个标识符来命名的各种变量的组合。
结构中可以使用不同的数据类型。

1. 结构说明和结构变量定义
在Turbo C中, 结构也是一种数据类型, 可以使用结构变量, 因此, 象其它

类型的变量一样, 在使用结构变量时要先对其定义。
定义结构变量的一般格式为:
struct 结构名
{
类型 变量名;
类型 变量名;
...
} 结构变量;

结构名是结构的标识符不是变量名。
类型为第二节中所讲述的五种数据类型(整型、浮点型、字符型、指针型和

无值型)。
构成结构的每一个类型变量称为结构成员, 它象数组的元素一样, 但数组中

元素是以下标来访问的, 而结构是按变量名字来访问成员的。
下面举一个例子来说明怎样定义结构变量。
struct string
{
char name[8];
int age;
char sex[2];
char depart[20];
float wage1, wage2, wage3, wage4, wage5;
} person;
这个例子定义了一个结构名为string的结构变量person, 如果省略变量名person, 则变成对结构的说明。用已说明的结构名也可定义结构变量。
这样定义时上例变成:

struct string

{

char name[8];

int age;

char sex[2];

char depart[20];

float wage1, wage2, wage3, wage4, wage5;

};

struct string person;

如果需要定义多个具有相同形式的结构变量时用这种方法比较方便, 它先作

结构说明, 再用结构名来定义变量。

例如:

struct string Tianyr, Liuqi, ...;

如果省略结构名, 则称之为无名结构, 这种情况常常出现在函数内部, 用这

种结构时前面的例子变成:

struct

{

char name[8];

int age;

char sex[2];

char depart[20];

float wage1, wage2, wage3, wage4, wage5;

} Tianyr, Liuqi;

2. 结构变量的使用

结构是一个新的数据类型, 因此结构变量也可以象其它类型的变量一样赋值、

运算, 不同的是结构变量以成员作为基本变量。

结构成员的表示方式为:

结构变量.成员名

如果将"结构变量.成员名"看成一个整体, 则这个整体的数据类型与结构中

该成员的数据类型相同, 这样就可象前面所讲的变量那样使用。

下面这个例子定义了一个结构变量, 其中每个成员都从键盘接收数据, 然后

对结构中的浮点数求和, 并显示运算结果, 同时将数据以文本方式存入一个名为

wage.dat的磁盘文件中。请注意这个例子中不同结构成员的访问。

例3:

＃i nclude

main()

{

struct{ /*定义一个结构变量*/

char name[8];

int age;

char sex[2];

char depart[20];

float wage1, wage2, wage3, wage4,

wage5;

}a;

FILE *fp;

float wage;

char c=’Y’;

fp=fopen("wage.dat", "w");

/*创建一个文件只写*/

while(c==’Y’||c==’y’)

/*判断是否继续循环*/

{

printf("\nName:");

scanf("%s", a.name); /*输入姓名*/

printf("Age:");

scanf("%d", &a.wage); /*输入年龄*/

printf("Sex:");

scanf("%d", a.sex);

printf("Dept:");

scanf("%s", a.depart);

printf("Wage1:");

scanf("%f", &a.wage1); /*输入工资*/

printf("Wage2:");

scanf("%f", &a.wage2);

printf("Wage3:");

scanf("%f", &a.wage3);

printf("Wage4:");

scanf("%f", &a.wage4);

printf("Wage5:");

scanf("%f", &a.wage5);



wage=a.wage1+a.wage2+a.wage3+a.wage4+a.wage5;

printf("The sum of wage is

%6.2f\n", wage);/*显示结果*/

fprintf(fp,

"%10s%4d%4s%30s%10.2f\n", /*结果写入文件*/

a.name, a.age, a.sex,

a.depart, wage);

while(1)

{

printf("Continue?");

c=getche();



if(c==’Y’||c==’y’||c==’N’||c==’n’)

break;

}

}

fclose(fp);

}

3. 结构数组和结构指针

结构是一种新的数据类型, 同样可以有结构数组和结构指针。

一、结构数组

结构数组就是具有相同结构类型的变量集合。假如要定义一个班级40个同学

的姓名、性别、年龄和住址, 可以定义成一个结构数组。如下所示:

struct{

char name[8];

char sex[2];

int age;

char addr[40];

}student[40];

也可定义为:

struct string{

char name[8];

char sex[2];

int age;

char addr[40];

};

struct string student[40];

需要指出的是结构数组成员的访问是以数组元素为结构变量的, 其形式为:

结构数组元素.成员名

例如:

student[0].name

student[30].age

实际上结构数组相当于一个二维构造, 第一维是结构数组元素, 每个元素是

一个结构变量, 第二维是结构成员。

注意:

结构数组的成员也可以是数组变量。

例如:

struct a

{

int m[3][5];

float f;

char s[20];

}y[4];

为了访问结构a中结构变量y[2]的这个变量, 可写成

y[2].m[1][4]

二、结构指针

结构指针是指向结构的指针。它由一个加在结构变量名前的"*" 操作符来定

义, 例如用前面已说明的结构定义一个结构指针如下:

struct string{

char name[8];

char sex[2];

int age;

char addr[40];

}*student;

也可省略结构指针名只作结构说明, 然后再用下面的语句定义结构指针。

struct string *student;

使用结构指针对结构成员的访问, 与结构变量对结构成员的访问在表达方式

上有所不同。结构指针对结构成员的访问表示为:

结构指针名->结构成员

其中"->"是两个符号"-"和">"的组合, 好象一个箭头指向结构成员。例如要

给上面定义的结构中name和age赋值, 可以用下面语句:

strcpy(student->name, "Lu G.C");

student->age=18;

实际上, student->name就是(*student).name的缩写形式。

需要指出的是结构指针是指向结构的一个指针, 即结构中第一个成员的首地

址, 因此在使用之前应该对结构指针初始化, 即分配整个结构长度的字节空间,

这可用下面函数完成, 仍以上例来说明如下:

student=(struct string*)malloc(size of

(struct string));

size of (struct string)自动求取string结构的字节长度,

malloc() 函数

定义了一个大小为结构长度的内存区域, 然后将其诈地址作为结构指针返回。

注意:

1. 结构作为一种数据类型, 因此定义的结构变量或结构指针变量同样有局

部变量和全程变量, 视定义的位置而定。

2. 结构变量名不是指向该结构的地址, 这与数组名的含义不同, 因此若需

要求结构中第一个成员的首地址应该是&[结构变量名]。

4. 结构的复杂形式

一、嵌套结构

嵌套结构是指在一个结构成员中可以包括其它一个结构, Turbo C 允许这种

嵌套。

例如: 下面是一个有嵌套的结构

struct string{

char name[8];

int age;

struct addr address;

} student;

其中: addr为另一个结构的结构名, 必须要先进行, 说明, 即

struct addr{

char city[20];

unsigned lon zipcode;

char tel[14];

}

如果要给student结构中成员address结构中的zipcode赋值, 则可写成:

student.address.zipcode=200001;

每个结构成员名从最外层直到最内层逐个被列出, 即嵌套式结构成员的表达

方式是:

结构变量名.嵌套结构变量名.结构成员名

其中: 嵌套结构可以有很多, 结构成员名为最内层结构中不是结构的成员名。



二、位结构

位结构是一种特殊的结构, 在需按位访问一个字节或字的多个位时, 位结构

比按位运算符更加方便。

位结构定义的一般形式为:

struct位结构名{

数据类型 变量名: 整型常数;

数据类型 变量名: 整型常数;

} 位结构变量;

其中: 数据类型必须是int(unsigned或signed)。 整型常数必须是非负的整

数, 范围是0~15, 表示二进制位的个数, 即表示有多少位。

变量名是选择项, 可以不命名, 这样规定是为了排列需要。

例如: 下面定义了一个位结构。

struct{

unsigned incon: 8;

/*incon占用低字节的0~7共8位*/

unsigned txcolor:

4;/*txcolor占用高字节的0~3位共4位*/

unsigned bgcolor:

3;/*bgcolor占用高字节的4~6位共3位*/

unsigned blink: 1; /*blink占用高字节的第7位*/

}ch;

位结构成员的访问与结构成员的访问相同。

例如: 访问上例位结构中的bgcolor成员可写成:

ch.bgcolor



注意:

1. 位结构中的成员可以定义为unsigned, 也可定义为signed, 但当成员长

度为1时, 会被认为是unsigned类型。因为单个位不可能具有符号。

2. 位结构中的成员不能使用数组和指针, 但位结构变量可以是数组和指针,

如果是指针, 其成员访问方式同结构指针。

3. 位结构总长度(位数), 是各个位成员定义的位数之和, 可以超过两个字

节。

4. 位结构成员可以与其它结构成员一起使用。

例如:

struct info{

char name[8];

int age;

struct addr address;

float pay;

unsigned state: 1;

unsigned pay: 1;

}workers;’

上例的结构定义了关于一个工从的信息。其中有两个位结构成员, 每个位结

构成员只有一位, 因此只占一个字节但保存了两个信息, 该字节中第一位表示工

人的状态, 第二位表示工资是否已发放。由此可见使用位结构可以节省存贮空间。

Linux下的串口通信学习笔记

一、什么是串口通信
串口通信是指计算机主机与外设之间以及主机系统与主机系统之间数据的串行传送。使用串口通信时，发送和接收到的每一个字符实际上都是一次一位的传送的，每一位为1或者为0。

二、串口通信的分类
串口通信可以分为同步通信和异步通信两类。同步通信是按照软件识别同步字符来实现数据的发送和接收，异步通信是一种利用字符的再同步技术的通信方式。
2.1同步通信
同步通信是一种连续串行传送数据的通信方式，一次通信只传送一帧信息。这里的信息帧与异步通信中的字符帧不同，通常含有若干个数据字符。如图：

单同步字符帧结构
+-----+------+-------+------+-----+--------+-------+-------+
|同步|数据 |数据 |数据 | ... |数据 |CRC1|CRC2|
|字符|字符1|字符2|字符3| |字符N| | |
+-----+------+-------+------+-----+--------+-------+-------+

双同步字符帧结构
+-----+--------+------+-------+---+-------+-------+--------+
|同步 |同步 |数据 |数据 | ... |数据 |CRC1|CRC2|
|字符1|字符2|字符1|字符2| |字符N| | |
+-----+--------+------+-------+---+-------+-------+--------+
它们均由同步字符、数据字符和校验字符（CRC）组成。其中同步字符位于帧开头，用于确认数据字符的开始。数据字符在同步字符之后，个数没有限制，由所需传输的数据块长度来决定；校验字符有1到2个，用于接收端对接收到的字符序列进行正确性的校验。
同步通信的缺点是要求发送时钟和接收时钟保持严格的同步。
2.2异步通信
异步通信中，数据通常以字符或者字节为单位组成字符帧传送。字符帧由发送端逐帧发送，通过传输线被接收设备逐帧接收。发送端和接收端可以由各自的时钟来控制数据的发送和接收，这两个时钟源彼此独立，互不同步。
接收端检测到传输线上发送过来的低电平逻辑"0"（即字符帧起始位）时，确定发送端已开始发送数据，每当接收端收到字符帧中的停止位时，就知道一帧字符已经发送完毕。
在异步通行中有两个比较重要的指标：字符帧格式和波特率。
(1)字符帧，由起始位、数据位、奇偶校验位和停止位组成。如图：

无空闲位字符帧
+--+---+---+---+---+--+--+--+--+--+--+--+---+---+---+--+--+
|D7|0/1| 1 | 0 |D0|D1|D2|D3|D4|D5|D6|D7|0/1| 1 | 0 |D0|D1|
+--+---+---+---+--+--+--+--+--+--+--+--+---+---+---+--+--+
奇偶 停 起 奇偶 停 起
校验 止 始 校验 止 始
位 位 位 位

有空闲位字符帧
+---+---+--+--+--+--+--+--+--+--+---+---+---+---+---+---+--+
| 1 | 0 |D0|D1|D2|D3|D4|D5|D6|D7|0/1| 1 | 1 | 1 | 1 | 0 |D0|
+---+---+--+--+--+--+--+--+--+--+---+---+---+---+---+---+--+
空 起 奇偶 停 空 闲 位 起
闲 始 校验 止 始
位 位 位 位

1.起始位：位于字符帧开头，占1位，始终为逻辑0电平，用于向接收设备表示发送端开始发送一帧信息。
2.数据位：紧跟在起始位之后，可以设置为5位、6位、7位、8位，低位在前高位在后。
3.奇偶校验位：位于数据位之后，仅占一位，用于表示串行通信中采用奇校验还是偶校验。

(2)波特率，波特率是每秒钟传送二进制数码的位数，单位是b/s。
异步通信的优点是不需要传送同步脉冲，字符帧长度也不受到限制。缺点是字符帧中因为包含了起始位和停止位，因此降低了有效数据的传输速率。

三、什么是RS-232
RS-232-C 接口（又称 EIA RS-232-C）它是在 1970 年由美国电子工业协会（EIA）联合贝尔系统、调制解调器厂家及计算机终端生产厂家共同制定的用于串行通讯的标准。它的全名是"数据终端设备（DTE）和数据通讯设备（DCE）之间串行二进制数据交换接口技术标准"该标准规定采用一个 25 个脚的 DB25 连接器，对连接器的每个引脚的信号内容加以规定，还对各种信号的电平加以规定。传输距离在码元畸变小于 4% 的情况下，传输电缆长度应为 50 英尺。

四、计算机串口引脚说明
引出号 说明
1 接地
2 TXD输出
3 RXD输入
4 RTS请求发送
5 CTS请求接收
6 DSR数据序列就绪
7 GND逻辑地
8 DCD数据负载检测
9 保留
10 保留
11 未定义
12 后备DCD
13 后备CTS
14 后备TXD
15 传输时钟
16 后备RXD
17 接收时钟
18 未定义
19 后备RTS
20 DTR数据终端就绪
21 信号质量检测
22 闹钟检测
23 数据速率选择
24 传输时钟
25 未定义

五、全双工与半双工
1.全双工，表示机器可以同时发送数据也可以接收数据，有两个独立的数据通道（一个用于发送，一个用于接收）
2.半双工，表示机器不能在发送数据的同时也接收数据。

六、流量控制
1.使用软件方法
使用特殊的字符来标记数据流的开始和结束，比如XON,DC1,八进制021来标志开始，用X0FF,DC3,八进制023来标志结束。
2.使用硬件方法
使用RS232的CTS和RTS信号来代替特殊字符控制。当接收方准备接收更多数据时，设置CTS为0,反之设置成1。对应的发送端准备发送数据时，设置 RTS为0。

七、串口的访问
串口设备在LINUX下与所有设备一样都是通过设备文件来进行访问。
7.1打开串口
LINUX系统下串口设备是通过open函数来打开的，不过需要注意的是，一般用户是没有权限访问设备文件的，需要将打开的串口设备的访问权限设置成一般用户可以访问的权限。
open函数
头文件
#include
#include
#include
函数原型
int open(const char *pathname, int oflag, .../*, mode_t mode*/);
参数
const char *pathname - 要打开文件的文件名称，例如/dev/ttyS0
int oflag - 文件打开方式，可用标志如下：
O_RDONLY 以只读方式打开文件
O_WRONLY 以只写方式打开文件
O_RDWR 以读写方式打开文件
O_APPEND 写入数据时添加到文件末尾
O_CREATE 如果文件不存在则产生该文件，使用该标志需要设置访问权限位mode_t
O_EXCL 指定该标志，并且指定了O_CREATE标志，如果打开的文件存在则会产生一个错误
O_TRUNC 如果文件存在并且成功以写或者只写方式打开，则清除文件所有内容，使得文件长度变为0
O_NOCTTY 如果打开的是一个终端设备，这个程序不会成为对应这个端口的控制终端，如果没有该标志，任何一个输入，例如键盘中止信号等，都将影响进程。
O_NONBLOCK 该标志与早期使用的O_NDELAY标志作用差不多。程序不关心DCD信号线的状态，如果指定该标志，进程将一直在休眠状态，直到DCD信号线为0。
O_SYNC 对I/O进行写等待
返回值
成功返回文件描述符，如果失败返回-1

例如：以可读写方式打开/dev/ttyS0设备
int fd; /* 文件描述符 */
fd = open("/dev/ttyS0", O_RDWR | 0_NOCTTY | O_NONBLOCK);

7.2关闭串口
Linux系统下通过close函数来关闭串口设备
close函数
头文件
#include
函数原型
int close(int filedes);
参数
int filedes - 文件描述符
返回值
成功返回0，否则返回-1

例如：关闭打开的串口设备fd
int ret; /* 返回标志，用于判断是否正常关闭设备 */
ret = close(fd);

7.3写串口
写串口是通过write函数来完成的
write函数
头文件
#include
函数原型
ssize_t write(int filedes, const void *buff, size_t nbytes);
参数
int filedes - 文件描述符
const void *buff - 存储写入数据的数据缓冲区
size_t nbytes - 写入数据字节数
返回值
ssize_t - 返回写入数据的字节数,该值通常等于nbytes，如果写入失败返回-1

例如：向终端设备发送初始化命令
int n = 0; /* 写入字节数 */
n = write(fd, "ATZ\r", 4);
if(n == -1)
{
fprintf(stderr, "Wirte ATZ command error.\n");
}

7.4读串口
读串口是通过read函数来完成的
read函数
头文件
#include
函数原型
ssize_t read(int filedes, void *buff, size_t nbytes);
参数
int filedes - 文件描述符
void *buff - 存储读取数据的数据缓冲区
size_t nbytes - 需要读取的字节数
返回值
ssize_t - 成功读取返回读取的字节数，否则返回-1

注意，在对串口进行读取操作的时候，如果是使用的RAW模式，每个read系统调用将返回当前串行输入缓冲区中存在的字节数。如果没有数据，将会一致阻塞到有字符达到或者间隔时钟到期，或者发生错误。如果想使read函数在没有数据的时候立即返回则可以使用fcntl函数来设置文件访问属性。例如：
fcntl(fd, F_SETFL, FNDELAY);
这样设置后，当没有可读取的数据时，read函数立即返回0。
通过fcntl(fd, F_SETFL, 0)可以设置回一般状态。

例如：从终端读取5个字节的应答数据
int nRead; /* 从终端读取的字节数 */
char buffer[256]; /* 接收缓冲区 */
nRead = read(fd, buffer, 5);
if(nRead == -1)
{
fprintf(stderr, "Read answer message error.\n");
}

八、终端配置
8.1 POSIX终端接口
大多数系统都支持POSIX终端接口，POSIX终端通过一个termios结构来进行控制，该结构定义在termios.h文件中。
termios结构
struct termios
{
tcflag_t c_iflag; /* 输入选项标志 */
tcflag_t c_oflag; /* 输出选项标志 */
tcflag_t c_cflag; /* 控制选项标志 */
tcflag_t c_lflag; /* 本地选项标志 */
cc_t c_cc[NCCS]; /* 控制特性 */
};

c_iflag成员
Flag Description
IGNBRK 忽略输入中的BREAK状态
BRKINT 如果设置了IGNBRK，将忽略BREAK。如果没有设置，但是设置了BRKINT，那么BREAK将使得输入和输出队列被刷新，如果终端是一个前台进程组的控制终端，这个进程组中所有进程将收到SIGINT信号。如果既未设置IGNBRK也未设置BRKINT，BREAK将视为NUL同义字符，除非设置了PARMRK，这种情况下被视为序列\377\0\0
IGNPAR 忽略桢错误和奇偶校验错误
PARMRK 如果没有设置IGNPAR，在有奇偶校验错误或者桢错误的字符前插入\377\0。如果既没有设置IGNPAR也没有设置PARMRK，将所有奇偶校验错误或者桢错误的字符视为\0。
INPCK 启用输入奇偶校验检测。
ISTRIP 去掉第八位。
INLCR 将输入的NL翻译为CR。
IGNCR 忽略输入中的回车。
ICRNL 将输入中的回车翻译为新行字符（除非设置了IGNCR）。
IUCLC （不属于POSIX）将输入中的大写字母映射为小写字母。
IXON 启用输出的XON/XOFF流控制
IXANY （不属于POSIX。1；XSI）允许任何字符来重新开始输出。
IXOFF 启用输入的XON/XOFF流控制
IMAXBEL （不属于POSIX）当输入队列满时响铃。LINUX没有实现该位，总是将其视为已设置。

c_oflag成员
Flag Description
OPOST 启用具体实现自行定义的输出。
OLCUC （不属于POSIX）将输出中的小写字母映射为大写字母。
ONLCR （XSI）将输出中的新行符映射为回车-换行
OCRNL 将输出中的回车映射为新行符。
ONOCR 不在第0列输出回车。
ONLRET 不输出回车。
OFILL 发送填充字符作为延时。
OFDEL （不属于POSIX）填充字符是ASCII DEL（0177）。如果不设置填充字符则是ASCII NUL。
NLDLY 新行延时掩码。取值为NL0和NL1。
CRDLY 回车延时掩码。取值为CR0,CR1,CR2或CR3。
TABDLY 水平跳格延时掩码。取值为TAB0,TAB1,TAB2,TAB3（或XTABS）。取值为TAB3,即XTABS，将扩展跳格为空格（每个跳格符填充8 个空格）。
BSDLY 回车延时掩码。取值为BS0或BS1.（从来没有被实现）
VTDLY 竖直跳格掩码。取值为VT0或VT1。
FFDLY 进表延时掩码。取值为FF0或者FF1。

c_cflag成员
Flag Description
CBAUD （不属于POSIX）波特率掩码（4+1位）。
CBAUDEX （不属于POSIX）扩展的波特率掩码（1位），包含在CBAUD中。
CSIZE 字符长度掩码。取值为CS5,CS6,CS7或CS8。
CSTOPB 设置两个停止位。
CREAD 打开接受者。
PARENB 允许输出产生奇偶信息以及输入的奇偶校验。
PARODD 输入和输出是奇校验
HUPCL 在最后一个进程关闭设备后，降低MODEM控制线（挂断）。
CLOCAL 忽略MODEM控制线。
LOBLK （不属于POSIX）从非当前SHELL层阻塞输出（用于sh1）。
CIBAUD （不属于POSIX）输入速度的掩码。CIBAUD各位的值与CBAUD各位相同，左移了IBSHIFT位。
CRTSCTS （不属于POSIX）启用RTS/CTS（硬件）控制流。

c_lflag成员
Flag Description
ISIG 当接收到字符INTR，QUIT，SUSP或DSUSP时，产生相应的信号。
XCASE （不属于POSIX；LINUX下不支持）如果同时设置了ICANON，终端只有大写。输入被转换为小写，除了以\前缀的字符。输出时，大写字符被前缀 \，小写字符被转换成大写。
ECHO 回显输入字符。
ECHOE 如果同时设置了ICANON，字符ERASE擦除前一个输入字符，WERASE擦除前一个词。
ECHOK 如果同时设置了ICANON，字符KILL删除当前行。
ECHONL 如果同时设置了ICANON，回显字符NL，即使没有设置ECHO。
ECHOCTL （不属于POSIX）如果同时设置了ECHO，除了TAB，NL，START和STOP之外的ASCII控制信号被回显为^x，这里X是比控制信号大 0x40的ASCII码。例如字符0x08(BS)被回显为^H。
ECHOPRT （不属于POSIX）如果同时设置了ICANON和IECHO，字符在删除的同时被打印。
ECHOKE （不属于POSIX）如果同时设置了ICANON，回显KILL时将删除一行中的每个字符，如同指定了ECHOE和ECHORPT一样。
DEFECHO （不属于POSIX）只在一个进程读的时候回显。
FLUSHO （不属于POSIX；LINUX不支持）输出被刷新。这个标志可以通过键入字符DISCARD来打开和关闭。
NOFLSH 禁止产生SIGINT，SIGQUIT和SIGSUSP信号时刷新输入和输出队列。
TOSTOP 向试图写控制终端的后台进程组发送SIGTTOU信号。
PENDIN （不属于POSIX；LINUX不支持）在读入一个字符时，输入队列中的所有字符被重新输出。（bash用他来处理typeahead）。
IEXTEN 启用实现自定义的输入处理。这个标志必须与ICANON同时使用，才能解释特殊字符EOL2,LNEXT，REPRINT和WERASE，IUCLC标志才有效。

c_cc数组成员
Flag Description
VINTR （003,ETX，Ctrl-C,or also 0177, DEL, rubout）中断字符。发送SIGINT信号。当设置ISIG时可被识别，不再作为输入传递。
VQUIT （034,FS，Ctrl-\）退出字符。发出SIGQUIT信号。当设置ISIG时可被识别，不再作为输入传递。
VERASE (0177, DEL, rubout, or 010, BS, Ctrl-H, or also #) 删除字符。删除上一个还没有删掉的字符，但不删除上一个 EOF 或行首。当设置 ICANON 时可被识别，不再作为输入传递。
VKILL (025, NAK, Ctrl-U, or Ctrl-X, or also @) 终止字符。删除自上一个 EOF 或行首以来的输入。当设置 ICANON 时可被识别，不再作为输入传递。
VEOF (004, EOT, Ctrl-D) 文件尾字符。更精确地说，这个字符使得 tty 缓冲中的内容被送到等待输入的用户程序中，而不必等到 EOL。如果它是一行的第一个字符，那么用户程序的 read() 将返回 0，指示读到了 EOF。当设置 ICANON 时可被识别，不再作为输入传递。
VMIN 非 canonical 模式读的最小字符数。 VEOL (0, NUL) 附加的行尾字符。当设置 ICANON 时可被识别。 VTIME 非 canonical 模式读时的延时，以十分之一秒为单位。 VEOL2 (not in POSIX; 0, NUL) 另一个行尾字符。当设置 ICANON 时可被识别。
VEOL (0, NUL) 附加的行尾字符。当设置 ICANON 时可被识别。
VTIME 非 canonical 模式读时的延时，以十分之一秒为单位。
VEOL2 (not in POSIX; 0, NUL) 另一个行尾字符。当设置 ICANON 时可被识别。
VSWTCH (not in POSIX; not supported under Linux; 0, NUL) 开关字符。(只为 shl 所用。)
VSTART (021, DC1, Ctrl-Q) 开始字符。重新开始被 Stop 字符中止的输出。当设置 IXON 时可被识别，不再作为输入传递。
VSTOP (023, DC3, Ctrl-S) 停止字符。停止输出，直到键入 Start 字符。当设置 IXON 时可被识别，不再作为输入传递。
VSUSP (032, SUB, Ctrl-Z) 挂起字符。发送 SIGTSTP 信号。当设置 ISIG 时可被识别，不再作为输入传递。
VDSUSP (not in POSIX; not supported under Linux; 031, EM, Ctrl-Y) 延时挂起信号。当用户程序读到这个字符时，发送 SIGTSTP 信号。当设置 IEXTEN 和 ISIG，并且系统支持作业管理时可被识别，不再作为输入传递。
VLNEXT (not in POSIX; 026, SYN, Ctrl-V) 字面上的下一个。引用下一个输入字符，取消它的任何特殊含义。当设置 IEXTEN 时可被识别，不再作为输入传递。
VWERASE (not in POSIX; 027, ETB, Ctrl-W) 删除词。当设置 ICANON 和 IEXTEN 时可被识别，不再作为输入传递。
VREPRINT (not in POSIX; 022, DC2, Ctrl-R) 重新输出未读的字符。当设置 ICANON 和 IEXTEN 时可被识别，不再作为输入传递。
VDISCARD (not in POSIX; not supported under Linux; 017, SI, Ctrl-O) 开关：开始/结束丢弃未完成的输出。当设置 IEXTEN 时可被识别，不再作为输入传递。
VSTATUS (not in POSIX; not supported under Linux; status request: 024, DC4, Ctrl-T).

8.2设置波特率
对于波特率的设置通常使用cfsetospeed和cfsetispeed函数来完成。获取波特率信息是通过cfgetispeed和 cfgetospeed函数来完成的。
cfsetospeed函数
头文件:
#include
函数原型:
int cfsetospeed(struct termios *termptr, speed_t speed);
参数：
struct termios *termptr - 指向termios结构的指针
speed_t speed - 需要设置的输出波特率
返回值：
如果成功返回0,否则返回-1

cfsetispeed函数
头文件：
#include
函数原型:
int cfsetispeed(struct termios *termptr, speed_t speed);
参数:
struct termios *termptr - 指向termios结构的指针
speed_t speed - 需要设置的输入波特率
返回值：
如果成功返回0,否则返回-1

cfgetospeed函数
头文件：
#include
函数原型：
speed_t cfgetospeed(const struct termios *termptr);
参数:
const struct termios - 指向termios结构的指针
返回值：
返回输出波特率

cfgetispeed函数
头文件：
#include
函数原型:
speed_t cfgetispeed(const struct termios *termptr);
参数:
const struct termios *termptr - 指向termios结构的指针
返回值：
返回输入波特率

波特率常量：
CBAUD 掩码
B0 0波特
B50 50波特
B75 75波特
B110 100波特
B134 134波特
B150 150波特
B200 200波特
B300 300波特
B600 600波特
B1200 1200波特
B1800 1800波特
B2400 2400波特
B9600 9600波特
B19200 19200波特
B38400 38400波特
B57600 57600波特
B115200 115200波特

8.3设置字符大小
设置字符的大小通过设置c_cflag标志位来实现的。
例如：
option.c_cflag &= ~CSIZE;
option.c_cflag |= CS7;

8.4设置奇偶校验
对于奇偶校验是需要手工设置的，常用的设置方式如下：
No parity (8N1):
options.c_cflag &= ~PARENB
options.c_cflag &= ~CSTOPB
options.c_cflag &= ~CSIZE;
options.c_cflag |= CS8;

Even parity (7E1):
options.c_cflag |= PARENB
options.c_cflag &= ~PARODD
options.c_cflag &= ~CSTOPB
options.c_cflag &= ~CSIZE;
options.c_cflag |= CS7;

Odd parity (7O1):
options.c_cflag |= PARENB
options.c_cflag |= PARODD
options.c_cflag &= ~CSTOPB
options.c_cflag &= ~CSIZE;
options.c_cflag |= CS7;

Space parity is setup the same as no parity (7S1):
options.c_cflag &= ~PARENB
options.c_cflag &= ~CSTOPB
options.c_cflag &= ~CSIZE;
options.c_cflag |= CS8;

8.5获取和设置终端属性
设置和获取终端控制属性是通过tcgetattr和tcsetattr两个函数来完成的
tcgetattr函数
头文件:
#include
函数原型:
int tcgetattr(int filedes, struct termios *termptr);
参数：
int filedes - 文件描述符
struct termiso *termptr - 指向termios结构的指针，
返回值:
如果成功返回0,否则返回-1

tcsetattr函数
头文件:
#include
函数原型：
int tcsetattr(int filedes, int opt, const struct termios *termptr);
参数：
int filedes - 文件描述符
int opt - 选项值，可以为下面三个值之一
TCSANOW - 不等数据传输完毕就改变属性
TCSADRAIN - 等待所有数据传输结束才改变属性
TCSAFLUSH - 清空输入输出缓冲区并且是设置属性
const struct termios *termptr - 指向termios结构的指针，
返回值：
成功返回0,否则返回-1

九、常用设置
9.1设置规范模式
规范模式是面向行的输入方式，输入字符被放入用于和用户交互可以编辑的缓冲区内，直接到读入回车或者换行符号时才结束。
可以通过如下方式来设置
option.c_lflag |= (ICANON | ECHO | ECHOE);

9.2设置原始输入模式
原始输入模式是没有处理过的，当接收数据时，输入的字符在它们被接收后立即被传送，使用原始输入模式时候，一般可以选择取消 ICANON，ECHO，ECHOE和ISIG选项。
例如：
option.c_lflag &= ~(ICANON | ECHO | ECHOE);

9.3设置输入奇偶选项
当激活c_cflag中的奇偶校验后，应该激活输入的奇偶校验。与之相关的标志有INPCK，IGNPAR，PARMRK和ISTRIP。一般是通过选择 INPCK和ISTRIP激活检验和移除奇偶位。
例如：
option.c_iflag |= (INPCK | ISTRIP);

9.4设置软件控制流
软件控制流通过IXON，IXOFF和IXANY标志来设置
例如：
option.c_iflag |=(IXON | IXOFF | IXANY);

9.5选择预处理输出
通过OPOST标志来设置预处理的输出
例如：
option.c_oflag |= OPOST;

9.6选择原始数据输出
原始数据的输出通过设置c_oflag的OPOST标志
例如:
option.c_oflag &= ~OPOST;

9.7设置软件流控制字符
软件流控制字符是通过c_cc数组中的VSTART和VSTOP来设置的，一般来说，它们应该被设置城DC1（021八进制）和DC3（023八进制），分别表示ASCII码的XON和XOFF字符。

9.8设置读超时
c_cc数组中的VMIN指定了最少读取的字符数，如果设置为0,那么VTIME就指定了读取每个字符的等待时间。VTIME是以1/10秒为单位指定接收字符的超时时间的，如果VTIME设置为0,而端口没有用open或者fcntl设置为NONBLOCK，那么read操作将会阻塞不确定的时间。

十、参考资料
1.《Serial Programming Guide for POSIX Operating Systems》5th Edition Michael R.Sweet
2.《Linux 下串口编程入门》左锦
3.《Advanced Programming in the UNIX Environment》 W.Richard Stevens
4.《Linux Serial Programming HOWTO》
5.《Unix Systems Programming》Kay A.Robbins & Steven Robbins
6.《Linux Programming by Example》Arnold Robbins
7.《Linux Programmer's Manual》

嵌入式系统开发学习如何起步、如何深入

很多新手学习嵌入式系统，不清楚那么多方向舵知识和参考书，该从哪里开始学习。入手了，却又在该先学习什么后学习什么上失去方向。这里有你想要的答案，帮你指点迷经。

这是我在ITjob培训网上找到的课程大纲，觉得作为嵌入式系统开发的学习步骤，按部就班地去施行和学习，到不失为一种好的学习方法：）

就算是作为参考也是有很好的价值的！

随着现代社会信息化进程的加快，嵌入式系统被广泛的地应用于军事、家用、工业、商业、办公、医疗等社会各个方面，表现出很强的投资价值。从国际范围来看，作为数字化电子信息产品核心的嵌入式系统目前其硬件和软件开发工具市场已经突破2000亿美元，嵌入式系统带来的全球工业年产值更是达到了一万亿美元，随着全球经济的持续增长以及信息化的加速发展，嵌入式系统市场必将进一步增长。

本课程是为了适应目前发展迅速的嵌入式Linux需求而设计，课程目标是让学员达到适应嵌入式应用软件开发、嵌入式系统开发或嵌入式驱动开发的基本素质。课程循序渐进的带领您嵌入式开发的世界，采用了目前应用最广泛的软硬件开发平台（Linux和Arm），可以保证您尽量贴近目前企业需求。

学习步骤如下：

1、Linux 基础

安装Linux操作系统

Linux文件系统

Linux常用命令

Linux启动过程详解

熟悉Linux服务能够独立安装Linux操作系统

能够熟练使用Linux系统的基本命令

认识Linux系统的常用服务安装Linux操作系统

Linux基本命令实践

设置Linux环境变量

定制Linux的服务 Shell 编程基础使用vi编辑文件

使用Emacs编辑文件

使用其他编辑器

2、Shell 编程基础

Shell简介

认识后台程序

Bash编程熟悉Linux系统下的编辑环境

熟悉Linux下的各种Shell

熟练进行shell编程熟悉vi基本操作

熟悉Emacs的基本操作

比较不同shell的区别

编写一个测试服务器是否连通的shell脚本程序

编写一个查看进程是否存在的shell脚本程序

编写一个带有循环语句的shell脚本程序

3、Linux 下的 C 编程基础

linux C语言环境概述

Gcc使用方法

Gdb调试技术

Autoconf

Automake

Makefile

代码优化 熟悉Linux系统下的开发环境

熟悉Gcc编译器

熟悉Makefile规则编写Hello,World程序

使用 make命令编译程序

编写带有一个循环的程序

调试一个有问题的程序

4、嵌入式系统开发基础

嵌入式系统概述

交叉编译

配置TFTP服务

配置NFS服务

下载Bootloader和内核

嵌入式Linux应用软件开发流程

熟悉嵌入式系统概念以及开发流程

建立嵌入式系统开发环境制作cross_gcc工具链

编译并下载U-boot

编译并下载Linux内核

编译并下载Linux应用程序

嵌入式系统移植

Linux内核代码

平台相关代码分析

ARM平台介绍

平台移植的关键技术

移植Linux内核到 ARM平台 了解移植的概念

能够移植Linux内核移植Linux2.6内核到 ARM9开发板

5、嵌入式 Linux 下串口通信

串行I/O的基本概念

嵌入式Linux应用软件开发流程

Linux系统的文件和设备

与文件相关的系统调用

配置超级终端和MiniCOM 能够熟悉进行串口通信

熟悉文件I/O 编写串口通信程序

编写多串口通信程序

6、嵌入式系统中多进程程序设计

Linux系统进程概述

嵌入式系统的进程特点

进程操作

守护进程

相关的系统调用了解Linux系统中进程的概念

能够编写多进程程序编写多进程程序

编写一个守护进程程序

sleep系统调用任务管理、同步与通信 Linux任务概述

任务调度

管道

信号

共享内存

任务管理 API 了解Linux系统任务管理机制

熟悉进程间通信的几种方式

熟悉嵌入式Linux中的任务间同步与通信

编写一个简单的管道程序实现文件传输

编写一个使用共享内存的程序

7、嵌入式系统中多线程程序设计

线程的基础知识

多线程编程方法

线程应用中的同步问题了解线程的概念

能够编写简单的多线程程序编写一个多线程程序

8、嵌入式 Linux 网络编程

网络基础知识

嵌入式Linux中TCP/IP网络结构

socket 编程

常用 API函数

分析Ping命令的实现

基本UDP套接口编程

许可证管理

PPP协议

GPRS 了解嵌入式Linux网络体系结构

能够进行嵌入式Linux环境下的socket 编程

熟悉UDP协议、PPP协议

熟悉GPRS 使用socket 编写代理服务器

使用socket 编写路由器

编写许可证服务器

指出TCP和UDP的优缺点

编写一个web服务器

编写一个运行在 ARM平台的网络播放器

9、GUI 程序开发

GUI基础

嵌入式系统GUI类型

编译QT

进行QT开发熟悉嵌入式系统常用的GUI

能够进行QT编程使用QT编写“Hello，World”程序

调试一个加入信号/槽的实例

通过重载QWidget 类方法处理事件

10、Linux 字符设备驱动程序

设备驱动程序基础知识

Linux系统的模块

字符设备驱动分析

fs_operation结构

加载驱动程序了解设备驱动程序的概念

了解Linux字符设备驱动程序结构

能够编写字符设备驱动程序编写Skull驱动

编写键盘驱动

编写I/O驱动

分析一个看门狗驱动程序

对比Linux2.6内核与2.4内核中字符设备驱动的不同

Linux 块设备驱动程序块设备驱动程序工作原理

典型的块设备驱动程序分析

块设备的读写请求队列了解Linux块设备驱动程序结构

能够编写简单的块设备驱动程序比较字符设备与块设备的异同

编写MMC卡驱动程序

分析一个文件系统

对比Linux2.6内核与2.4内核中块设备驱动的不同

11、文件系统

虚拟文件系统

文件系统的建立

ramfs内存文件系统

proc文件系统

devfs 文件系统

MTD技术简介

MTD块设备初始化

MTD块设备的读写操作了解Linux系统的文件系统

了解嵌入式Linux的文件系统

了解MTD技术

能够编写简单的文件系统为 ARM9开发板添加 MTD支持

移植JFFS2文件系统

通过proc文件系统修改操作系统参数

分析romfs 文件系统源代码

创建一个cramfs 文件系统

新手学堂 嵌入式开发都需要学习什么

这是一个初学者常问的问题,也是初学者问嵌入式该如何入门的根源。我感觉有两个方面,偏硬和偏软.我不认为嵌入式开发软件占绝对比重,相反,软硬件都懂,才是嵌入式高手所应该追求的
　
这是一个初学者常问的问题,也是初学者问嵌入式该如何入门的根源。我感觉有两个方面,偏硬和偏软.我不认为嵌入式开发软件占绝对比重,相反,软硬件都懂,才是嵌入式高手所应该追求的,也是高手的必由之路。

硬件道路:

第一步: pcb设计,一般为开发板的电路裁减和扩充,由开发板原理图为基础,画出PCB和封装库,设计自己的电路。

第二步: SOPC技术,一般为FPGA,CPLD开发,利用VHDL等硬件描述语言做专用芯片开发,写出自己的逻辑电路,基于ALTER或XILINUX的 FPGA做开发。

第三步: SOC设计,分前端,后端实现,这是硬件设计的核心技术:芯片设计.能做到这步,已经不属于平凡的技术人员。

软件道路:

第一步:bootloader的编写，修改, 通过这步熟悉ARM硬件结构,学习ARM汇编语言,阅读ARM的芯片手册,感觉就是像操作51单片机一样操作ARM芯片.这一步最好的两个参考资料就是: 芯片手册和bootloader源代码。

第二步:系统移植, 驱动开发, 我只做过linux方向,所以也推荐学习嵌入式linux系统,作为标准体系,他开源而且可以获得大量学习资料.操作系统是整个计算机科学的核心,熟悉 kernel实属不易,kernel, 驱动开发的学习,没有什么捷径,只有多读代码,多写代码,熟悉系统API.. understanding linux kernel , linux device driver 都是不可多得的好书，值得一看。

第三步:应用程序的编写,各种GUI的移植,qt , minigui都被大量采用,两种思想都类似,熟悉一种就可以。

软件道路中,驱动,系统应该是最深入的部分,不是短时间可以掌握的,需要有勇气和耐心。嵌入式开发,软硬结合,因为硬件条件比PC差很多,所以肯定会遇见不少问题,因此实践的勇气更加重要.有问题就解决问题，无数次的实验, 也许是解决问题的必由之路。

浅谈＃ifdef在软件开发中的妙用

　　笔者从事UNIX环境下某应用软件的开发与维护工作，用户分布于全国各地，各用户需要的基本功能都是一样的，但在某些功能上要随着需求变化，不断加以升级，要想实现全国各地用户的升级工作是很困难的，而我们则只是利用E-mail发送补丁程序给用户，这些补丁程序都是在一套软件的基础上不断地修改与扩充而编写的，并由不同的标志文件转入到不同的模块，虽然程序体积在不断扩大，但丝毫不影响老用户的功能，这主要是得益于C程序的＃ifdef/＃else/＃endif的作用。

　　我们主要使用以下几种方法,假设我们已在程序首部定义＃ifdef DEBUG与＃ifdef TEST：

　　1.利用＃ifdef/＃endif将某程序功能模块包括进去，以向某用户提供该功能。

　　在程序首部定义＃ifdef HNLD：

　　＃ifdef HNLD

　　＃include"n166_hn.c"

　　＃endif

　　如果不许向别的用户提供该功能，则在编译之前将首部的HNLD加一下划线即可。

　　2.在每一个子程序前加上标记，以便追踪程序的运行。

　　＃ifdef DEBUG

　　printf(" Now is in hunan !");

　　＃endif

　　3.避开硬件的限制。有时一些具体应用环境的硬件不一样，但限于条件，本地缺乏这种设备，于是绕过硬件，直接写出预期结果。具体做法是:

　　＃ifndef TEST

　　i=dial();

　　//程序调试运行时绕过此语句

　　＃else

　　i=0;

　　＃endif

　　调试通过后，再屏蔽TEST的定义并重新编译，即可发给用户使用了。

C/C++语法知识：typedef struct 用法详解

第一篇：typedef struct与struct的区别

1. 基本解释

typedef为C语言的关键字，作用是为一种数据类型定义一个新名字。这里的数据类型包括内部数据类型（int,char等）和自定义的数据类型（struct等）。

在编程中使用typedef目的一般有两个，一个是给变量一个易记且意义明确的新名字，另一个是简化一些比较复杂的类型声明。

至于typedef有什么微妙之处，请你接着看下面对几个问题的具体阐述。

2. typedef & 结构的问题

当用下面的代码定义一个结构时，编译器报了一个错误，为什么呢？莫非C语言不允许在结构中包含指向它自己的指针吗？请你先猜想一下，然后看下文说明：

typedef struct tagNode
{
　char *pItem;
　pNode pNext;
} *pNode;

答案与分析：

1、typedef的最简单使用

typedef long byte_4;

给已知数据类型long起个新名字，叫byte_4。

2、 typedef与结构结合使用

typedef struct tagMyStruct
{
　int iNum;
　long lLength;
} MyStruct;

这语句实际上完成两个操作：

1) 定义一个新的结构类型

struct tagMyStruct
{
　int iNum;
　long lLength;
};

分析：tagMyStruct称为“tag”，即“标签”，实际上是一个临时名字，struct 关键字和tagMyStruct一起，构成了这个结构类型，不论是否有typedef，这个结构都存在。

我们可以用struct tagMyStruct varName来定义变量，但要注意，使用tagMyStruct varName来定义变量是不对的，因为struct 和tagMyStruct合在一起才能表示一个结构类型。

2) typedef为这个新的结构起了一个名字，叫MyStruct。

typedef struct tagMyStruct MyStruct;

因此，MyStruct实际上相当于struct tagMyStruct，我们可以使用MyStruct varName来定义变量。

答案与分析

C语言当然允许在结构中包含指向它自己的指针，我们可以在建立链表等数据结构的实现上看到无数这样的例子，上述代码的根本问题在于typedef的应用。

根据我们上面的阐述可以知道：新结构建立的过程中遇到了pNext域的声明，类型是pNode，要知道pNode表示的是类型的新名字，那么在类型本身还没有建立完成的时候，这个类型的新名字也还不存在，也就是说这个时候编译器根本不认识pNode。

解决这个问题的方法有多种：

1)、

typedef struct tagNode
{
　char *pItem;
　struct tagNode *pNext;
} *pNode;

2)、

typedef struct tagNode *pNode;
struct tagNode
{
　char *pItem;
　pNode pNext;
};

注意：在这个例子中，你用typedef给一个还未完全声明的类型起新名字。C语言编译器支持这种做法。

3)、规范做法：

typedef uint32 (* ADM_READDATA_PFUNC)( uint16*, uint32 );

这个以前没有看到过,个人认为是宇定义一个uint32的指针函数,uint16*, uint32 为函数里的两个参数; 应该相当于#define uint32 (* ADM_READDATA_PFUNC)( uint16*, uint32 );

struct在代码中常见两种形式：
struct A
{
//...
};

struct
{
//...
} A;
这其实是两个完全不同的用法：
前者叫做“结构体类型定义”，意思是：定义{}中的结构为一个名称是“A”的结构体。
这种用法在typedef中一般是：
typedef struct tagA //故意给一个不同的名字，作为结构体的实名
{
//...
} A; //结构体的别名。

后者是结构体变量定义，意思是：以{}中的结构，定义一个名称为"A"的变量。这里的结构体称为匿名结构体，是无法被直接引用的。
也可以通过typedef为匿名结构体创建一个别名，从而使得它可以被引用：
typedef struct
{
//...
} A; //定义匿名结构体的别名为A

第二篇：在C和C++中struct和typedef struct的区别

在C和C++有三种定义结构的方法。

typedef struct {

int data;

int text;

} S1;

//这种方法可以在c或者c++中定义一个S1结构

struct S2 {

int data;

int text;

};

// 这种定义方式只能在C++中使用，而如果用在C中，那么编译器会报错

struct {

int data;

int text;

} S3;

这种方法并没有定义一个结构，而是定义了一个s3的结构变量，编译器会为s3内存。

void main()

{

S1 mine1;// OK ,S1 是一个类型

S2 mine2;// OK,S2 是一个类型

S3 mine3;// OK,S3 不是一个类型

S1.data = 5;// ERRORS1 是一个类型

S2.data = 5;// ERRORS2 是一个类型

S3.data = 5;// OKS3是一个变量

}

另外，对与在结构中定义结构本身的变量也有几种写法

struct S6 {

S6* ptr;

};

// 这种写法只能在C++中使用

typedef struct {

S7* ptr;

} S7;

// 这是一种在C和C++中都是错误的定义

如果在C中，我们可以使用这样一个“曲线救国的方法“

typedef struct tagS8{

tagS8 * ptr;

} S8;

第三篇：struct和typedef struct

分三块来讲述：
1 首先：
在C中定义一个结构体类型要用typedef:
typedef struct Student
{
int a;
}Stu;
于是在声明变量的时候就可：Stu stu1;
如果没有typedef就必须用struct Student stu1;来声明
这里的 Stu实际上就是struct Student的别名。
另外这里也可以不写Student（于是也不能struct Student stu1;了）
typedef struct
{
int a;
}Stu;
但在c++里很简单，直接
struct Student
{
int a;
};
于是就定义了结构体类型Student，声明变量时直接Student stu2；
===========================================
2其次：
在c++中如果用typedef的话，又会造成区别：
struct Student
{
int a;
}stu1;//stu1是一个变量
typedef struct Student2
{
int a;
}stu2;//stu2是一个结构体类型
使用时可以直接访问stu1.a
但是stu2则必须先 stu2 s2;
然后 s2.a=10;
===========================================
3 掌握上面两条就可以了，不过最后我们探讨个没多大关系的问题
如果在c程序中我们写：
typedef struct
{
int num;
int age;
}aaa,bbb,ccc;
这算什么呢？
我个人观察编译器（VC6）的理解，这相当于
typedef struct
{
int num;
int age;
}aaa；
typedef aaa bbb;
typedef aaa ccc;
也就是说 aaa,bbb,ccc三者都是结构体类型。声明变量时用任何一个都可以,在c++中也是如此。但是你要注意的是这个在c++中如果写掉了typedef 关键字，那么aaa，bbb，ccc将是截然不同的三个对象。

第四篇：C/C++中typedef struct和struct的用法

struct _x1 { ...}x1; 和 typedef struct _x2{ ...} x2; 有什么不同？

其实, 前者是定义了类_x1和_x1的对象实例x1, 后者是定义了类_x2和_x2的类别名x2 ,

所以它们在使用过程中是有取别的.请看实例1.

[知识点]

结构也是一种数据类型, 可以使用结构变量, 因此, 象其它 类型的变量一样, 在使用结构变量时要先对其定义。

定义结构变量的一般格式为:

struct 结构名

{

类型 变量名;

类型 变量名;

...

} 结构变量;

结构名是结构的标识符不是变量名。

另一种常用格式为:

typedef struct 结构名

{

类型 变量名;

类型 变量名;

...

} 结构别名;

另外注意: 在C中，struct不能包含函数。在C++中，对struct进行了扩展，可以包含函数。

======================================================================

实例1: struct.cpp

#include

using namespace std;

typedef struct _point{

int x;

int y;

}point; //定义类，给类一个别名

struct _hello{

int x,y;

} hello; //同时定义类和对象

int main()

{

point pt1;

pt1.x = 2;

pt1.y = 5;

cout<< "ptpt1.x=" << pt1.x << "pt.y=" <
//hello pt2;

//pt2.x = 8;

//pt2.y =10;

//cout<<"pt2pt2.x="<< pt2.x <<"pt2.y="<
//上面的hello pt2;这一行编译将不能通过. 为什么?

//因为hello是被定义了的对象实例了.

//正确做法如下: 用hello.x和hello.y

hello.x = 8;

hello.y = 10;

cout<< "hellohello.x=" << hello.x << "hello.y=" <
return 0;

}

第五篇：问答

Q：用struct和typedef struct 定义一个结构体有什么区别？为什么会有两种方式呢？

struct Student
{
int a;
} stu;
typedef struct Student2
{
int a;
}stu2;

A：

事实上，这个东西是从C语言中遗留过来的，typedef可以定义新的复合类型或给现有类型起一个别名，在C语言中，如果你使用
struct xxx
{
}; 的方法，使用时就必须用 struct xxx var 来声明变量，而使用
typedef struct
{
}的方法 就可以写为 xxx var;
不过在C++中已经没有这回事了，无论你用哪一种写法都可以使用第二种方式声明变量，这个应该算是C语言的糟粕。

plc是什么意思？

PLC的定义有许多种。国际电工委员会（IEC）对PLC的定义是：可编程控制器是一种数字运算操作的电子系统，专为在工业环境下应用而设计。它采用可编程序的存贮器，用来在其内部存贮执行逻辑运算、顺序控制、定时、计数和算术运算等操作的指令，并通过数字的、模拟的输入和输出，控制各种类型的机械或生产过程。可编程序控制器及其有关设备，都应按易于与工业控制系统形成一个整体，易于扩充其功能的原则设计。
PLC的构成
　　从结构上分，PLC分为固定式和组合式（模块式）两种。固定式PLC包括CPU板、I/O板、显示面板、内存块、电源等，这些元素组合成一个不可拆卸的整体。模块式PLC包括CPU模块、I/O模块、内存、电源模块、底板或机架，这些模块可以按照一定规则组合配置。
CPU的构成
　　CPU是PLC的核心，起神经中枢的作用，每套PLC至少有一个CPU，它按PLC的系统程序赋予的功能接收并存贮用户程序和数据，用扫描的方式采集由现场输入装置送来的状态或数据，并存入规定的寄存器中，同时，诊断电源和PLC内部电路的工作状态和编程过程中的语法错误等。进入运行后，从用户程序存贮器中逐条读取指令，经分析后再按指令规定的任务产生相应的控制信号，去指挥有关的控制电路。
　　CPU主要由运算器、控制器、寄存器及实现它们之间联系的数据、控制及状态总线构成，CPU单元还包括外围芯片、总线接口及有关电路。内存主要用于存储程序及数据，是 PLC不可缺少的组成单元。
　　在使用者看来，不必要详细分析CPU的内部电路，但对各部分的工作机制还是应有足够的理解。CPU的控制器控制 CPU工作，由它读取指令、解释指令及执行指令。但工作节奏由震荡信号控制。运算器用于进行数字或逻辑运算，在控制器指挥下工作。寄存器参与运算，并存储运算的中间结果，它也是在控制器指挥下工作。
CPU速度和内存容量是PLC的重要参数，它们决定着PLC的工作速度，IO数量及软件容量等，因此限制着控制规模。
更多的PLC信息请查看 http://www.iacmall.com/

利用sed 命令去掉windows下回车符及空白符

windows下的回车符为 \r\n 而unix下的回车符是 \n

1.去掉所有行的空格
sed -i 's/ //g' df.txt

2.去掉所有行的空格
sed -e 's/ //g' df.txt >cwm.txt

3.将每一行拖尾的“空白字符”（空格，制表符）删除
sed 's/ *$//' df.txt >cwm.txt

4.将每一行中的前导和拖尾的空白字符删除
sed 's/^ *//;s/ *$//' df.txt >cwm.txt

5.去掉空行
sed '/^$/d' df.txt >cwm.txt
sed -e '/^$/d' df.txt >cwm.txt
sed -i '/^$/d' df.txt
这三个是等价的 但第三个会改变原文件

6.去掉windows下的回车符 （注意^M 在linux 下写法 按^M 是回车换行符,输入方法是按住CTRL+v,松开v,按m)
sed -i 's/^M//g' df.txt

7.去掉windows下的回车符 （注意^M 在linux 下写法 按^M 是回车换行符,输入方法是按住CTRL+v,松开v,按m)
sed -e 's/^M//g' df.txt >cwm.txt
8.sed 用正则表达式 8个字符一组换行

echo "aaaaaaaabbbbbbbbccccccccdddddddd"|sed 's/.\{8\}/&\n/g'

aaaaaaaa
bbbbbbbb
cccccccc
dddddddd


也等价于
dos2unix df.txt >cwm.txt


----------------------------------------------------------------------------------------------

******如何去掉文件中行尾的回车符号^M******
sed 's/^M//g w newfilename' oldfilename
其中：
s 表示Searchg 表示搜索全文,缺省是搜索第一个^M 是回车换行符,输入方法是按住CTRL+v,松开v,按m
w 表示写到新文件中.


例子1
86103113234778,
86103145878770,
86103116778768,
86103111879708, sed 's/^86//;s/,$//' user.txt #去掉开头的86 及尾部的,号

例子2
103113234778
103145878770
103116778768
103111879708
sed -e 's/^/86/' user.txt #每行行首加上86
86103113234778
86103145878770
86103116778768
86103111879708
------------------------------------------------------------------
我有一个文件：
aaa，
bbb，

ccc，
ddd，

eee，
fff，


想删除第3，6，9。。。的空行并且合并12，45，78。。。行，
结果如下：
aaa,bbb,
ccc,ddd,
eee,fff,
.......

解法
sed -e '/^$/d' -e 'N;s/\n//g'
或
sed 'N;N;s/\n//g' （行数必须是3的倍数，不然最后一行不对）

对于替换单引号外层应加双引号

sed "s/^/'/;s/$/'/" 营帐GPRS用户.txt
===========================================================================


用sed 模式空间把时间格式加个空格
[oracle@TestAs4 filter]$ more nd_td.txt
13211124412,2008-08-2613:24:07,2008-08-2615:28:39
13144035749,2008-08-2613:24:06,2008-08-2615:30:39
13144023993,2008-08-2613:19:11,2008-08-2615:37:34
13006601565,2008-08-2612:04:15,2008-08-2615:40:34
13178665198,2008-08-2613:17:49,2008-08-2615:42:35
13058107546,2008-08-2613:08:41,2008-08-2615:49:35
13246005230,2008-08-2613:27:20,2008-08-2615:54:36

[oracle@TestAs4 filter]$ sed 's/\(2008-[0-9][0-9]-[0-9][0-9]\)/& /g' nd_td.txt |more
13211124412,2008-08-26 13:24:07,2008-08-26 15:28:39
13144035749,2008-08-26 13:24:06,2008-08-26 15:30:39
13144023993,2008-08-26 13:19:11,2008-08-26 15:37:34
13006601565,2008-08-26 12:04:15,2008-08-26 15:40:34
13178665198,2008-08-26 13:17:49,2008-08-26 15:42:35
13058107546,2008-08-26 13:08:41,2008-08-26 15:49:35
13246005230,2008-08-26 13:27:20,2008-08-26 15:54:36
13169867085,2008-08-26 13:18:14,2008-08-26 15:58:34
13043484284,2008-08-26 12:04:07,2008-08-26 16:03:35

以下两个都是利用模式空间替换实现的
sed 's/\(2008-[0-9][0-9]-[0-9][0-9]\)/\1 /g' nd_td.txt |more
sed 's/\(2008-[0-9][0-9]-[0-9][0-9]\)\([0-9][0-9]:[0-9][0-9]:[0-9][0-9]\)/\1 \2/g' nd_td.txt |more


#echo ${orjtext0.txt//[!a-z]||[!0-9]} >orjtext1.txt
#sed -e 's/^M//g' orjtext01.txt >orjtext0.txt
#cat orjtext0.txt|sed s/\n\r/\n/ >orjtext01.txt
#doc2unix orjtext0.txt orjtext01.txt
col -b < orjtext0.txt > orjtext01.txt

cat orjtext01.txt|grep -v '^#'|sed '/^$/d' >>orjtext02.txt #把#号注释掉的和空行去掉
#sed -e 's/^#//' orjtext01.txt >orjtext02.txt #把#号注释掉的行去掉
#sed -i '/^[ \t]*\/\#d' orjtext01.txt

有时当进行某些配置文件的查看时，分去除注释（如："#"），但之后还会发现中间也许会有好多空行，所以，现小结一下去除空行的方法。
1）用tr命令
# grep -v "#" /etc/snmp/snmpd.conf |tr -s '\n'
2）用sed命令
# grep -v "#" /etc/snmp/snmpd.conf |sed '/^$/d'
3）用awk命令
# grep -v "#" /etc/snmp/snmpd.conf |awk '{if($0!="")print}'
4）用grep命令
# grep -v "#" /etc/snmp/snmpd.conf |grep -v "^$"

/dev/console,/dev/tty和/dev/null含义

UNIX和Linux中比较重要的三个设备文件是：/dev/console，/dev/tty和/dev/null。

/dev/console
这个设备代表的是系统控制台，错误信息和诊断信息通常会被发送到这个设备。
每个UNIX系统都会有一个指定的终端或显示屏用来接收控制台信息。

/dev/tty
如果一个进程有控制终端的话，那么 /dev/tty就是这个控制终端的别名。
像cron这样的进程是没有控制终端的，因此它也就无法打开/dev/tty。
tty 这个词源于Teletypes，最早是源于电传打印机。
如果你登录了一个shell，那么/dev/tty就是你当前使用的终端。你也可以用tty命令查看/dev/tty设备实际链接到的设备是哪个。
/dev/tty其实就是类似于“符号链接”一样的东西。像我的 tty输出就是:
[root@wupengchong dev]# tty
/dev/pts/0

/dev/null
这是个空设备，也称为“位桶bit bucket”。所有写向这个设备的输出都将被丢弃，而如果你读/dev/null，则会立即得到一个文件尾标志而返回。
在cp命令里，可以用/dev/null来作为拷贝空文件的源文件。
在shell中，通常将不需要的东西重定向到/dev/null中。
这里要提一下/dev/zero，它和null是有区别的。通俗的讲，/dev/null是一个饭桶，你可以无穷无尽的往里塞垃圾，它不会埋怨。而/dev /zero是一个输入设备，它给你无穷无尽的提供0（就是null），它可以用于向文件或设备写入无穷无尽的0.
/dev/zero和 /dev/null的用法比较：
$dd if=/dev/zero of=mydoc.txt bs=1k count=1
$find . -name “*.c” 2>/dev/null

Linux下的多线程编程

1 引言
　　线程（thread）技术早在60年代就被提出，但真正应用多线程到操作系统中去，是在80年代中期，solaris是这方面的佼佼者。传统的Unix也支持线程的概念，但是在一个进程（process）中只允许有一个线程，这样多线程就意味着多进程。现在，多线程技术已经被许多操作系统所支持，包括Windows/NT，当然，也包括Linux。
　　为什么有了进程的概念后，还要再引入线程呢？使用多线程到底有哪些好处？什么的系统应该选用多线程？我们首先必须回答这些问题。
　　使用多线程的理由之一是和进程相比，它是一种非常"节俭"的多任务操作方式。我们知道，在Linux系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种"昂贵"的多任务工作方式。而运行于一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间，而且，线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。据统计，总的说来桓鼋痰目笤际且桓鱿叱炭?0倍左右，当然，在具体的系统上，这个数据可能会有较大的区别。
　　使用多线程的理由之二是线程间方便的通信机制。对不同进程来说，它们具有独立的数据空间，要进行数据的传递只能通过通信的方式进行，这种方式不仅费时，而且很不方便。线程则不然，由于同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便。当然，数据的共享也带来其他一些问题，有的变量不能同时被两个线程所修改，有的子程序中声明为static的数据更有可能给多线程程序带来灾难性的打击，这些正是编写多线程程序时最需要注意的地方。
　　除了以上所说的优点外，不和进程比较，多线程程序作为一种多任务、并发的工作方式，当然有以下的优点：
　　1) 提高应用程序响应。这对图形界面的程序尤其有意义，当一个操作耗时很长时，整个系统都会等待这个操作，此时程序不会响应键盘、鼠标、菜单的操作，而使用多线程技术，将耗时长的操作（time consuming）置于一个新的线程，可以避免这种尴尬的情况。
　　2) 使多CPU系统更加有效。操作系统会保证当线程数不大于CPU数目时，不同的线程运行于不同的CPU上。
　　3) 改善程序结构。一个既长又复杂的进程可以考虑分为多个线程，成为几个独立或半独立的运行部分，这样的程序会利于理解和修改。
　　下面我们先来尝试编写一个简单的多线程程序。

2 简单的多线程编程
　　Linux系统下的多线程遵循POSIX线程接口，称为pthread。编写Linux下的多线程程序，需要使用头文件pthread.h，连接时需要使用库libpthread.a。顺便说一下，Linux下pthread的实现是通过系统调用clone（）来实现的。clone（）是Linux所特有的系统调用，它的使用方式类似fork，关于clone（）的详细情况，有兴趣的读者可以去查看有关文档说明。下面我们展示一个最简单的多线程程序 example1.c。

/* example.c*/
#include
#include
void thread(void)
{
int i;
for(i=0;i<3;i++)
printf("This is a pthread.\n");
}

int main(void)
{
pthread_t id;
int i,ret;
ret=pthread_create(&id,NULL,(void *) thread,NULL);
if(ret!=0){
printf ("Create pthread error!\n");
exit (1);
}
for(i=0;i<3;i++)
printf("This is the main process.\n");
pthread_join(id,NULL);
return (0);
}

我们编译此程序：
gcc example1.c -lpthread -o example1
运行example1，我们得到如下结果：
This is the main process.
This is a pthread.
This is the main process.
This is the main process.
This is a pthread.
This is a pthread.
再次运行，我们可能得到如下结果：
This is a pthread.
This is the main process.
This is a pthread.
This is the main process.
This is a pthread.
This is the main process.

　　前后两次结果不一样，这是两个线程争夺CPU资源的结果。上面的示例中，我们使用到了两个函数，　　pthread_create和pthread_join，并声明了一个pthread_t型的变量。
　　pthread_t在头文件 /usr/include/bits/pthreadtypes.h中定义：
　　typedef unsigned long int pthread_t;
　　它是一个线程的标识符。函数pthread_create用来创建一个线程，它的原型为：
　　extern int pthread_create __P ((pthread_t *__thread, __const pthread_attr_t *__attr,
　　void *(*__start_routine) (void *), void *__arg));
　　第一个参数为指向线程标识符的指针，第二个参数用来设置线程属性，第三个参数是线程运行函数的起始地址，最后一个参数是运行函数的参数。这里，我们的函数 thread不需要参数，所以最后一个参数设为空指针。第二个参数我们也设为空指针，这样将生成默认属性的线程。对线程属性的设定和修改我们将在下一节阐述。当创建线程成功时，函数返回0，若不为0则说明创建线程失败，常见的错误返回代码为EAGAIN和EINVAL。前者表示系统限制创建新的线程，例如线程数目过多了；后者表示第二个参数代表的线程属性值非法。创建线程成功后，新创建的线程则运行参数三和参数四确定的函数，原来的线程则继续运行下一行代码。
　　函数pthread_join用来等待一个线程的结束。函数原型为：
　　extern int pthread_join __P ((pthread_t __th, void **__thread_return));
　　第一个参数为被等待的线程标识符，第二个参数为一个用户定义的指针，它可以用来存储被等待线程的返回值。这个函数是一个线程阻塞的函数，调用它的函数将一直等待到被等待的线程结束为止，当函数返回时，被等待线程的资源被收回。一个线程的结束有两种途径，一种是象我们上面的例子一样，函数结束了，调用它的线程也就结束了；另一种方式是通过函数 pthread_exit来实现。它的函数原型为：
　　extern void pthread_exit __P ((void *__retval)) __attribute__ ((__noreturn__));
　　唯一的参数是函数的返回代码，只要 pthread_join中的第二个参数thread_return不是NULL，这个值将被传递给thread_return。最后要说明的是，一个线程不能被多个线程等待，否则第一个接收到信号的线程成功返回，其余调用pthread_join的线程则返回错误代码ESRCH。
　　在这一节里，我们编写了一个最简单的线程，并掌握了最常用的三个函数pthread_create，pthread_join和pthread_exit。下面，我们来了解线程的一些常用属性以及如何设置这些属性。

3 修改线程的属性
　　在上一节的例子里，我们用pthread_create函数创建了一个线程，在这个线程中，我们使用了默认参数，即将该函数的第二个参数设为NULL。的确，对大多数程序来说，使用默认属性就够了，但我们还是有必要来了解一下线程的有关属性。
　　属性结构为pthread_attr_t，它同样在头文件/usr/include/pthread.h中定义，喜欢追根问底的人可以自己去查看。属性值不能直接设置，须使用相关函数进行操作，初始化的函数为pthread_attr_init，这个函数必须在pthread_create函数之前调用。属性对象主要包括是否绑定、是否分离、堆栈地址、堆栈大小、优先级。默认的属性为非绑定、非分离、缺省1M的堆栈、与父进程同样级别的优先级。
　　关于线程的绑定，牵涉到另外一个概念：轻进程（LWP：Light Weight Process）。轻进程可以理解为内核线程，它位于用户层和系统层之间。系统对线程资源的分配、对线程的控制是通过轻进程来实现的，一个轻进程可以控制一个或多个线程。默认状况下，启动多少轻进程、哪些轻进程来控制哪些线程是由系统来控制的，这种状况即称为非绑定的。绑定状况下，则顾名思义，即某个线程固定的"绑"在一个轻进程之上。被绑定的线程具有较高的响应速度，这是因为CPU时间片的调度是面向轻进程的，绑定的线程可以保证在需要的时候它总有一个轻进程可用。通过设置被绑定的轻进程的优先级和调度级可以使得绑定的线程满足诸如实时反应之类的要求。
　　设置线程绑定状态的函数为 pthread_attr_setscope，它有两个参数，第一个是指向属性结构的指针，第二个是绑定类型，它有两个取值：PTHREAD_SCOPE_SYSTEM（绑定的）和PTHREAD_SCOPE_PROCESS（非绑定的）。下面的代码即创建了一个绑定的线程。
#include
pthread_attr_t attr;
pthread_t tid;

/*初始化属性值，均设为默认值*/
pthread_attr_init(&attr);
pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);

pthread_create(&tid, &attr, (void *) my_function, NULL);

　　线程的分离状态决定一个线程以什么样的方式来终止自己。在上面的例子中，我们采用了线程的默认属性，即为非分离状态，这种情况下，原有的线程等待创建的线程结束。只有当pthread_join（）函数返回时，创建的线程才算终止，才能释放自己占用的系统资源。而分离线程不是这样子的，它没有被其他的线程所等待，自己运行结束了，线程也就终止了，马上释放系统资源。程序员应该根据自己的需要，选择适当的分离状态。设置线程分离状态的函数为 pthread_attr_setdetachstate（pthread_attr_t *attr, int detachstate）。第二个参数可选为PTHREAD_CREATE_DETACHED（分离线程）和 PTHREAD _CREATE_JOINABLE（非分离线程）。这里要注意的一点是，如果设置一个线程为分离线程，而这个线程运行又非常快，它很可能在 pthread_create函数返回之前就终止了，它终止以后就可能将线程号和系统资源移交给其他的线程使用，这样调用pthread_create的线程就得到了错误的线程号。要避免这种情况可以采取一定的同步措施，最简单的方法之一是可以在被创建的线程里调用 pthread_cond_timewait函数，让这个线程等待一会儿，留出足够的时间让函数pthread_create返回。设置一段等待时间，是在多线程编程里常用的方法。但是注意不要使用诸如wait（）之类的函数，它们是使整个进程睡眠，并不能解决线程同步的问题。
　　另外一个可能常用的属性是线程的优先级，它存放在结构sched_param中。用函数pthread_attr_getschedparam和函数 pthread_attr_setschedparam进行存放，一般说来，我们总是先取优先级，对取得的值修改后再存放回去。下面即是一段简单的例子。
#include
#include
pthread_attr_t attr;
pthread_t tid;
sched_param param;
int newprio=20;

pthread_attr_init(&attr);
pthread_attr_getschedparam(&attr, ¶m);
param.sched_priority=newprio;
pthread_attr_setschedparam(&attr, ¶m);
pthread_create(&tid, &attr, (void *)myfunction, myarg);
　　
4 线程的数据处理
　　和进程相比，线程的最大优点之一是数据的共享性，各个进程共享父进程处沿袭的数据段，可以方便的获得、修改数据。但这也给多线程编程带来了许多问题。我们必须当心有多个不同的进程访问相同的变量。许多函数是不可重入的，即同时不能运行一个函数的多个拷贝（除非使用不同的数据段）。在函数中声明的静态变量常常带来问题，函数的返回值也会有问题。因为如果返回的是函数内部静态声明的空间的地址，则在一个线程调用该函数得到地址后使用该地址指向的数据时，别的线程可能调用此函数并修改了这一段数据。在进程中共享的变量必须用关键字volatile来定义，这是为了防止编译器在优化时（如gcc中使用-OX参数）改变它们的使用方式。为了保护变量，我们必须使用信号量、互斥等方法来保证我们对变量的正确使用。下面，我们就逐步介绍处理线程数据时的有关知识。

4.1 线程数据
　　在单线程的程序里，有两种基本的数据：全局变量和局部变量。但在多线程程序里，还有第三种数据类型：线程数据（TSD: Thread-Specific Data）。它和全局变量很象，在线程内部，各个函数可以象使用全局变量一样调用它，但它对线程外部的其它线程是不可见的。这种数据的必要性是显而易见的。例如我们常见的变量errno，它返回标准的出错信息。它显然不能是一个局部变量，几乎每个函数都应该可以调用它；但它又不能是一个全局变量，否则在 A线程里输出的很可能是B线程的出错信息。要实现诸如此类的变量，我们就必须使用线程数据。我们为每个线程数据创建一个键，它和这个键相关联，在各个线程里，都使用这个键来指代线程数据，但在不同的线程里，这个键代表的数据是不同的，在同一个线程里，它代表同样的数据内容。
　　和线程数据相关的函数主要有4个：创建一个键；为一个键指定线程数据；从一个键读取线程数据；删除键。
　　创建键的函数原型为：
　　extern int pthread_key_create __P ((pthread_key_t *__key,
　　void (*__destr_function) (void *)));
　　第一个参数为指向一个键值的指针，第二个参数指明了一个 destructor函数，如果这个参数不为空，那么当每个线程结束时，系统将调用这个函数来释放绑定在这个键上的内存块。这个函数常和函数 pthread_once ((pthread_once_t*once_control, void (*initroutine) (void)))一起使用，为了让这个键只被创建一次。函数pthread_once声明一个初始化函数，第一次调用pthread_once时它执行这个函数，以后的调用将被它忽略。

　　在下面的例子中，我们创建一个键，并将它和某个数据相关联。我们要定义一个函数 createWindow，这个函数定义一个图形窗口（数据类型为Fl_Window *，这是图形界面开发工具FLTK中的数据类型）。由于各个线程都会调用这个函数，所以我们使用线程数据。
/* 声明一个键*/
pthread_key_t myWinKey;
/* 函数 createWindow */
void createWindow ( void ) {
Fl_Window * win;
static pthread_once_t once= PTHREAD_ONCE_INIT;
/* 调用函数createMyKey，创建键*/
pthread_once ( & once, createMyKey) ;
/*win 指向一个新建立的窗口*/
win=new Fl_Window( 0, 0, 100, 100, "MyWindow");
/* 对此窗口作一些可能的设置工作，如大小、位置、名称等*/
setWindow(win);
/* 将窗口指针值绑定在键myWinKey上*/
pthread_setpecific ( myWinKey, win);
}

/* 函数 createMyKey，创建一个键，并指定了destructor */
void createMyKey ( void ) {
pthread_keycreate(&myWinKey, freeWinKey);
}

/* 函数 freeWinKey，释放空间*/
void freeWinKey ( Fl_Window * win){
delete win;
}

　　这样，在不同的线程中调用函数createMyWin，都可以得到在线程内部均可见的窗口变量，这个变量通过函数pthread_getspecific得到。在上面的例子中，我们已经使用了函数 pthread_setspecific来将线程数据和一个键绑定在一起。这两个函数的原型如下：
　　extern int pthread_setspecific __P ((pthread_key_t __key,__const void *__pointer));
　　extern void *pthread_getspecific __P ((pthread_key_t __key));
　　这两个函数的参数意义和使用方法是显而易见的。要注意的是，用pthread_setspecific为一个键指定新的线程数据时，必须自己释放原有的线程数据以回收空间。这个过程函数pthread_key_delete用来删除一个键，这个键占用的内存将被释放，但同样要注意的是，它只释放键占用的内存，并不释放该键关联的线程数据所占用的内存资源，而且它也不会触发函数pthread_key_create中定义的destructor函数。线程数据的释放必须在释放键之前完成。

4.2 互斥锁
　　互斥锁用来保证一段时间内只有一个线程在执行一段代码。必要性显而易见：假设各个线程向同一个文件顺序写入数据，最后得到的结果一定是灾难性的。
　　我们先看下面一段代码。这是一个读/写程序，它们公用一个缓冲区，并且我们假定一个缓冲区只能保存一条信息。即缓冲区只有两个状态：有信息或没有信息。

void reader_function ( void );
void writer_function ( void );

char buffer;
int buffer_has_item=0;
pthread_mutex_t mutex;
struct timespec delay;
void main ( void ){
pthread_t reader;
/* 定义延迟时间*/
delay.tv_sec = 2;
delay.tv_nec = 0;
/* 用默认属性初始化一个互斥锁对象*/
pthread_mutex_init (&mutex,NULL);
pthread_create(&reader, pthread_attr_default, (void *)&reader_function), NULL);
writer_function( );
}

void writer_function (void){
while(1){
/* 锁定互斥锁*/
pthread_mutex_lock (&mutex);
if (buffer_has_item==0){
buffer=make_new_item( );
buffer_has_item=1;
}
/* 打开互斥锁*/
pthread_mutex_unlock(&mutex);
pthread_delay_np(&delay);
}
}

void reader_function(void){
while(1){
pthread_mutex_lock(&mutex);
if(buffer_has_item==1){
consume_item(buffer);
buffer_has_item=0;
}
pthread_mutex_unlock(&mutex);
pthread_delay_np(&delay);
}
}
　　这里声明了互斥锁变量mutex，结构pthread_mutex_t为不公开的数据类型，其中包含一个系统分配的属性对象。函数 pthread_mutex_init用来生成一个互斥锁。NULL参数表明使用默认属性。如果需要声明特定属性的互斥锁，须调用函数 pthread_mutexattr_init。函数pthread_mutexattr_setpshared和函数 pthread_mutexattr_settype用来设置互斥锁属性。前一个函数设置属性pshared，它有两个取值，PTHREAD_PROCESS_PRIVATE和PTHREAD_PROCESS_SHARED。前者用来不同进程中的线程同步，后者用于同步本进程的不同线程。在上面的例子中，我们使用的是默认属性PTHREAD_PROCESS_ PRIVATE。后者用来设置互斥锁类型，可选的类型有PTHREAD_MUTEX_NORMAL、PTHREAD_MUTEX_ERRORCHECK、 PTHREAD_MUTEX_RECURSIVE和PTHREAD _MUTEX_DEFAULT。它们分别定义了不同的上所、解锁机制，一般情况下，选用最后一个默认属性。
　　 pthread_mutex_lock声明开始用互斥锁上锁，此后的代码直至调用pthread_mutex_unlock为止，均被上锁，即同一时间只能被一个线程调用执行。当一个线程执行到pthread_mutex_lock处时，如果该锁此时被另一个线程使用，那此线程被阻塞，即程序将等待到另一个线程释放此互斥锁。在上面的例子中，我们使用了pthread_delay_np函数，让线程睡眠一段时间，就是为了防止一个线程始终占据此函数。
　　上面的例子非常简单，就不再介绍了，需要提出的是在使用互斥锁的过程中很有可能会出现死锁：两个线程试图同时占用两个资源，并按不同的次序锁定相应的互斥锁，例如两个线程都需要锁定互斥锁1和互斥锁2，a线程先锁定互斥锁1，b线程先锁定互斥锁2，这时就出现了死锁。此时我们可以使用函数 pthread_mutex_trylock，它是函数pthread_mutex_lock的非阻塞版本，当它发现死锁不可避免时，它会返回相应的信息，程序员可以针对死锁做出相应的处理。另外不同的互斥锁类型对死锁的处理不一样，但最主要的还是要程序员自己在程序设计注意这一点。

4.3 条件变量
　　前一节中我们讲述了如何使用互斥锁来实现线程间数据的共享和通信，互斥锁一个明显的缺点是它只有两种状态：锁定和非锁定。而条件变量通过允许线程阻塞和等待另一个线程发送信号的方法弥补了互斥锁的不足，它常和互斥锁一起使用。使用时，条件变量被用来阻塞一个线程，当条件不满足时，线程往往解开相应的互斥锁并等待条件发生变化。一旦其它的某个线程改变了条件变量，它将通知相应的条件变量唤醒一个或多个正被此条件变量阻塞的线程。这些线程将重新锁定互斥锁并重新测试条件是否满足。一般说来，条件变量被用来进行线承间的同步。
　　条件变量的结构为pthread_cond_t，函数pthread_cond_init（）被用来初始化一个条件变量。它的原型为：
　　extern int pthread_cond_init __P ((pthread_cond_t *__cond,__const pthread_condattr_t *__cond_attr));
　　其中cond是一个指向结构pthread_cond_t的指针，cond_attr是一个指向结构pthread_condattr_t的指针。结构 pthread_condattr_t是条件变量的属性结构，和互斥锁一样我们可以用它来设置条件变量是进程内可用还是进程间可用，默认值是 PTHREAD_ PROCESS_PRIVATE，即此条件变量被同一进程内的各个线程使用。注意初始化条件变量只有未被使用时才能重新初始化或被释放。释放一个条件变量的函数为pthread_cond_ destroy（pthread_cond_t cond）。　
　　函数 pthread_cond_wait（）使线程阻塞在一个条件变量上。它的函数原型为：
　　extern int pthread_cond_wait __P ((pthread_cond_t *__cond,
　　pthread_mutex_t *__mutex));
　　线程解开mutex指向的锁并被条件变量cond阻塞。线程可以被函数pthread_cond_signal和函数 pthread_cond_broadcast唤醒，但是要注意的是，条件变量只是起阻塞和唤醒线程的作用，具体的判断条件还需用户给出，例如一个变量是否为0等等，这一点我们从后面的例子中可以看到。线程被唤醒后，它将重新检查判断条件是否满足，如果还不满足，一般说来线程应该仍阻塞在这里，被等待被下一次唤醒。这个过程一般用while语句实现。
　　另一个用来阻塞线程的函数是pthread_cond_timedwait（），它的原型为：
　　extern int pthread_cond_timedwait __P ((pthread_cond_t *__cond,
　　 pthread_mutex_t *__mutex, __const struct timespec *__abstime));
　　它比函数pthread_cond_wait（）多了一个时间参数，经历abstime段时间后，即使条件变量不满足，阻塞也被解除。
　　函数 pthread_cond_signal（）的原型为：
　　extern int pthread_cond_signal __P ((pthread_cond_t *__cond));
　　它用来释放被阻塞在条件变量cond上的一个线程。多个线程阻塞在此条件变量上时，哪一个线程被唤醒是由线程的调度策略所决定的。要注意的是，必须用保护条件变量的互斥锁来保护这个函数，否则条件满足信号又可能在测试条件和调用 pthread_cond_wait函数之间被发出，从而造成无限制的等待。下面是使用函数pthread_cond_wait（）和函数 pthread_cond_signal（）的一个简单的例子。

pthread_mutex_t count_lock;
pthread_cond_t count_nonzero;
unsigned count;
decrement_count　() {
pthread_mutex_lock (&count_lock);
while(count==0)
pthread_cond_wait( &count_nonzero, &count_lock);
count=count -1;
pthread_mutex_unlock (&count_lock);
}

increment_count(){
pthread_mutex_lock(&count_lock);
if(count==0)
pthread_cond_signal(&count_nonzero);
count=count+1;
pthread_mutex_unlock(&count_lock);
}
　　count值为0时，decrement函数在pthread_cond_wait处被阻塞，并打开互斥锁count_lock。此时，当调用到函数increment_count时，pthread_cond_signal（）函数改变条件变量，告知decrement_count（）停止阻塞。读者可以试着让两个线程分别运行这两个函数，看看会出现什么样的结果。
　　函数 pthread_cond_broadcast（pthread_cond_t *cond）用来唤醒所有被阻塞在条件变量cond上的线程。这些线程被唤醒后将再次竞争相应的互斥锁，所以必须小心使用这个函数。

4.4 信号量
　　信号量本质上是一个非负的整数计数器，它被用来控制对公共资源的访问。当公共资源增加时，调用函数sem_post（）增加信号量。只有当信号量值大于０时，才能使用公共资源，使用后，函数sem_wait（）减少信号量。函数sem_trywait（）和函数pthread_ mutex_trylock（）起同样的作用，它是函数sem_wait（）的非阻塞版本。下面我们逐个介绍和信号量有关的一些函数，它们都在头文件 /usr/include/semaphore.h中定义。
　　信号量的数据类型为结构sem_t，它本质上是一个长整型的数。函数 sem_init（）用来初始化一个信号量。它的原型为：
　　extern int sem_init __P ((sem_t *__sem, int __pshared, unsigned int __value));
　　sem为指向信号量结构的一个指针；pshared不为０时此信号量在进程间共享，否则只能为当前进程的所有线程共享；value给出了信号量的初始值。
　　函数sem_post( sem_t *sem )用来增加信号量的值。当有线程阻塞在这个信号量上时，调用这个函数会使其中的一个线程不在阻塞，选择机制同样是由线程的调度策略决定的。
　　函数sem_wait( sem_t *sem )被用来阻塞当前线程直到信号量sem的值大于0，解除阻塞后将sem的值减一，表明公共资源经使用后减少。函数sem_trywait ( sem_t *sem )是函数sem_wait（）的非阻塞版本，它直接将信号量sem的值减一。
　　函数sem_destroy(sem_t *sem)用来释放信号量sem。
　　下面我们来看一个使用信号量的例子。在这个例子中，一共有4个线程，其中两个线程负责从文件读取数据到公共的缓冲区，另两个线程从缓冲区读取数据作不同的处理（加和乘运算）。
/* File sem.c */
#include
#include
#include
#define MAXSTACK 100
int stack[MAXSTACK][2];
int size=0;
sem_t sem;
/* 从文件1.dat读取数据，每读一次，信号量加一*/
void ReadData1(void){
FILE *fp=fopen("1.dat","r");
while(!feof(fp)){
fscanf(fp,"%d %d",&stack[size][0],&stack[size][1]);
sem_post(&sem);
++size;
}
fclose(fp);
}
/* 从文件2.dat读取数据*/
void ReadData2(void){
FILE *fp=fopen("2.dat","r");
while(!feof(fp)){
fscanf(fp,"%d %d",&stack[size][0],&stack[size][1]);
sem_post(&sem);
++size;
}
fclose(fp);
}
/* 阻塞等待缓冲区有数据，读取数据后，释放空间，继续等待*/
void HandleData1(void){
while(1){
sem_wait(&sem);
printf("Plus:%d+%d=%d\n",stack[size][0],stack[size][1],
stack[size][0]+stack[size][1]);
--size;
}
}

void HandleData2(void){
while(1){
sem_wait(&sem);
printf("Multiply:%d*%d=%d\n",stack[size][0],stack[size][1],
stack[size][0]*stack[size][1]);
--size;
}
}
int main(void){
pthread_t t1,t2,t3,t4;
sem_init(&sem,0,0);
pthread_create(&t1,NULL,(void *)HandleData1,NULL);
pthread_create(&t2,NULL,(void *)HandleData2,NULL);
pthread_create(&t3,NULL,(void *)ReadData1,NULL);
pthread_create(&t4,NULL,(void *)ReadData2,NULL);
/* 防止程序过早退出，让它在此无限期等待*/
pthread_join(t1,NULL);
}

　　在Linux下，我们用命令gcc -lpthread sem.c -o sem生成可执行文件sem。 我们事先编辑好数据文件1.dat和2.dat，假设它们的内容分别为1 2 3 4 5 6 7 8 9 10和 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 ，我们运行sem，得到如下的结果：
Multiply:-1*-2=2
Plus:-1+-2=-3
Multiply:9*10=90
Plus:-9+-10=-19
Multiply:-7*-8=56
Plus:-5+-6=-11
Multiply:-3*-4=12
Plus:9+10=19
Plus:7+8=15
Plus:5+6=11

　　从中我们可以看出各个线程间的竞争关系。而数值并未按我们原先的顺序显示出来这是由于size这个数值被各个线程任意修改的缘故。这也往往是多线程编程要注意的问题。

5 小结
　　多线程编程是一个很有意思也很有用的技术，使用多线程技术的网络蚂蚁是目前最常用的下载工具之一，使用多线程技术的grep比单线程的grep要快上几倍，类似的例子还有很多。希望大家能用多线程技术写出高效实用的好程序来。

七款嵌入式Linux操作系统简介

除了智能数字终端领域以外，Linux在移动计算平台、智能工业控制、金融业终端系统，甚至军事领域都有着广泛的应用前景。这些Linux被统称为“嵌入式Linux”。下面就来看看都有哪些嵌入式Linux在以上领域纵横驰骋吧！

RT-Linux

这是由美国墨西哥理工学院开发的嵌入式Linux操作系统。到目前为止，RT- Linux已经成功地应用于航天飞机的空间数据采集、科学仪器测控和电影特技图像处理等广泛领域。RT-Linux开发者并没有针对实时操作系统的特性而重写Linux的内核，因为这样做的工作量非常大，而且要保证兼容性也非常困难。为此，RT-Linux提出了精巧的内核，并把标准的Linux核心作为实时核心的一个进程，同用户的实时进程一起调度。这样对Linux内核的改动非常小，并且充分利用了Linux下现有的丰富的软件资源。

uClinux

uCLinux是Lineo公司的主打产品，同时也是开放源码的嵌入式Linux的典范之作。uCLinux主要是针对目标处理器没有存储管理单元MMU （Memory Management Unit）的嵌入式系统而设计的。它已经被成功地移植到了很多平台上。由于没有MMU，其多任务的实现需要一定技巧。uCLinux是一种优秀的嵌入式 Linux版本，是micro-Conrol-Linux的缩写。它秉承了标准Linux的优良特性，经过各方面的小型化改造，形成了一个高度优化的、代码紧凑的嵌入式Linux。虽然它的体积很小，却仍然保留了Linux的大多数的优点：稳定、良好的移植性、优秀的网络功能、对各种文件系统完备的支持和标准丰富的API。它专为嵌入式系统做了许多小型化的工作，目前已支持多款CPU。其编译后目标文件可控制在几百KB数量级，并已经被成功地移植到很多平台上。

Embedix

Embedix是由嵌入式Linux行业主要厂商之一Luneo推出的，是根据嵌入式应用系统的特点重新设计的Linux发行版本。Embedix提供了超过25种的Linux系统服务，包括Web服务器等。系统需要最小8MB内存，3MB ROM或快速闪存。Embedix基于Linux 2.2内核，并已经成功地移植到了Intel x86和PowerPC处理器系列上。像其它的Linux版本一样，Embedix可以免费获得。Luneo还发布了另一个重要的软件产品，它可以让在 Windows CE上运行的程序能够在Embedix上运行。Luneo还将计划推出Embedix的开发调试工具包、基于图形界面的浏览器等。可以说，Embedix 是一种完整的嵌入式Linux解决方案。

XLinux

XLinux是由美国网虎公司推出，主要开发者是陈盈豪。他在加盟网虎几个月后便开发出了基于XLinux的、号称是世界上最小的嵌入式Linux系统，内核只有143KB，而且还在不断减小。XLinux核心采用了“超字元集”专利技术，让Linux核心不仅可能与标准字符集相容，还含盖了12个国家和地区的字符集。因此，XLinux在推广Linux的国际应用方面有独特的优势。

PoketLinux

PoketLinux由Agenda公司采用、作为其新产品“VR3 PDA”的嵌入式Linux操作系统。它可以提供跨操作系统构造统一的、标准化的和开放的信息通信基础结构，在此结构上实现端到端方案的完整平台。 PoketLinux资源框架开放，使普通的软件结构可以为所有用户提供一致的服务。PoketLinux平台使用户的视线从设备、平台和网络上移开，由此引发了信息技术新时代的产生。在PoketLinux中，称之为用户化信息交换（CIE），也就是提供和访问为每个用户需求而定制的“主题”信息的能力，而不管正在使用的设备是什么。

MidoriLinux

由Transmeta公司推出的MidoriLinux操作系统代码开放，在GUN普通公共许可（GPL）下发布，可以在http://midori.transmeta.com上立即获得。该公司有个名为“MidoriLinux计划”。“MidoriLinux”这个名字来源于日本的“绿色”——Midori，用来反映其 Linux操作系统的环保外观。

红旗嵌入式Linux

由北京中科院红旗软件公司推出的嵌入式Linux是国内做得较好的一款嵌入式操作系统。目前，中科院计算所自行开发的开放源码的嵌入式操作系统—— Easy Embedded OS(EEOS)也已经开始进入实用阶段了。该款嵌入式操作系统重点支持p-Java。系统目标一方面是小型化，另一方面能重用Linux的驱动和其它模块。由于有中科院计算所的强大科研力量做后盾，EEOS有望发展成为功能完善、稳定、可靠的国产嵌入式操作系统平台。

思考与展望

以上列举的众多嵌入式Linux操作系统中，国内对于uClinux和RT-Linux 研究的较多，很多基于它们的产品已经面世，比如华恒公司已经把uClinux成功移植，并投放到市场。

正是由于Linux开放源代码的特点，所以全世界的开发厂商都站在同一个起跑线上。国内的研究机构和企业也正在积极投入人力、物力，力争在嵌入式操作系统上有所为。但应该清醒认识到，绝大多数的嵌入式系统的硬件平台还掌握在外国公司的手中。国产的嵌入式操作系统在技术含量、兼容性、市场运作模式等方面还有很多工作要做。国家对嵌入式领域的发展也极为重视。信息产业部《2003年度电子发展基金项目指南》在软件类重点产品项目中，第五小类就是关于嵌入式软件与系统开发的，并提出要重点进行如下重点项目的研制与开发：嵌入式实时操作系统、嵌入式软件集成开发平台和嵌入式数据库管理软件。由于嵌入式系统研发在国内起步比较晚，我国目前还基本处于实验室阶段。但是嵌入式操作系统的巨大的商业价值和 Linux的开放性，为民族软件产业的发展提供了难得的机会。在跟踪国外嵌入式操作系统最新技术的同时，国内厂商要坚持自主产权，力争找到自己的突破点，探索出一条适合中国国情的嵌入式操作系统的发展道路。

glib库,Linux平台下最常用的C语言函数

推荐glib库是Linux平台下最常用的C语言函数库，它具有很好的可移植性和实用性。
glib是Gtk +库和Gnome的基础。glib可以在多个平台下使用，比如Linux、Unix、Windows等。glib为许多标准的、常用的C语言结构提供了相应的替代物。

使用glib库的程序都应该包含glib的头文件glib.h。

########################### glib基本类型定义： ##############################

整数类型：
gint8、guint8、gint16、guint16、gint32、guint32、gint64、guint64。
不是所有的平台都提供64位整型，如果一个平台有这些， glib会定义G_HAVE_GINT64。
类型gshort、glong、gint和short、long、int完全等价。
布尔类型：
gboolean：它可使代码更易读，因为普通C没有布尔类型。
Gboolean可以取两个值：TRUE和FALSE。实际上FALSE定义为0，而TRUE定义为非零值。
字符型：
gchar和char完全一样，只是为了保持一致的命名。
浮点类型：
gfloat、gdouble和float、double完全等价。
指针类型：
gpointer对应于标准C的void *，但是比void *更方便。
指针gconstpointer对应于标准C的const void *（注意，将const void *定义为const gpointer是行不通的

########################### glib的宏 ##############################

一些常用的宏列表
＃i nclude
TRUE
FALSE
NULL
MAX(a, b)
MIN(a, b)
ABS ( x )
CLAMP(x, low, high)

TRUE / FALSE / NULL就是1 / 0 / ( ( v o i d * ) 0 )。
MIN ( ) / MAX ( )返回更小或更大的参数。
ABS ( )返回绝对值。
CLAMP(x,low,high )若X在[low,high]范围内，则等于X；如果X小于low，则返回low；如果X大于high，则返
回high。

有些宏只有g l i b拥有，例如在后面要介绍的gpointer-to-gint和gpointer-to-guint。
大多数glib的数据结构都设计成存储一个gpointer。如果想存储指针来动态分配对象，可以这样做。
在某些情况下，需要使用中间类型转换。
//////////////////////////////////////////////////////////////
gint my_int;
gpointer my_pointer;
my_int = 5;
my_pointer = GINT_TO_POINTER(my_int);
printf("We are storing %d\n", GPOINTER_TO_INT(my_pointer));
//////////////////////////////////////////////////////////////

这些宏允许在一个指针中存储一个整数，但在一个整数中存储一个指针是不行的。
如果要实现的话，必须在一个长整型中存储指针。
宏列表：
在指针中存储整数的宏
＃i nclude
GINT_TO_POINTER ( p )
GPOINTER_TO_INT ( p )
GUINT_TO_POINTER ( p )
GPOINTER_TO_UINT ( p )

调试宏:
定义了G_DISABLE_CHECKS或G_DISABLE_ASSERT之后，编译时它们就会消失.
宏列表：
前提条件检查
＃i nclude
g_return_if_fail ( condition )
g_return_val_if_fail(condition, retval)

///////////////////////////////////////////////////////////////////////////////////
使用这些函数很简单，下面的例子是g l i b中哈希表的实现：
void g_hash_table_foreach (GHashTable *hash_table,GHFunc func,gpointer user_data)
{
GHashNode *node;
gint i;
g_return_if_fail (hash_table != NULL);
g_return_if_fail (func != NULL);
for (i = 0; i < hash_table->size; i++)
for (node = hash_table->nodes[i]; node; node = node->next)
(* func) (node->key, node->value, user_data);
}
///////////////////////////////////////////////////////////////////////////////////

宏列表：
断言
＃i nclude
g_assert( condition )
g_assert_not_reached ( )
如果执行到这个语句，它会调用abort()退出程序并且(如果环境支持)转储一个可用于调试的core文件。

断言与前提条件检查的区别:
应该断言用来检查函数或库内部的一致性。
g_return_if_fail()确保传递到程序模块的公用接口的值是合法的。
如果断言失败，将返回一条信息，通常应该在包含断言的模块中查找错误；
如果g_return_if_fail()检查失败，通常要在调用这个模块的代码中查找错误。
//////////////////////////////////////////////////////////////////////
下面glib日历计算模块的代码说明了这种差别：
GDate * g_date_new_dmy (GDateDay day, GDateMonth m, GDateYear y)
{
GDate *d;
g_return_val_if_fail (g_date_valid_dmy (day, m, y), NULL);
d = g_new (GDate, 1);
d->julian = FALSE;
d->dmy = TRUE;
d->month = m;
d->day = day;
d->year = y;
g_assert (g_date_valid (d));
return d;
}
//////////////////////////////////////////////////////////////////////
开始的预条件检查确保用户传递合理的年月日值；
结尾的断言确保glib构造一个健全的对象，输出健全的值。

断言函数g_assert_not_reached() 用来标识“不可能”的情况，通常用来检测不能处理的
所有可能枚举值的switch语句：
switch (val)
{
case FOO_ONE:
break ;
case FOO_TWO:
break ;
default:
/* 无效枚举值* /
g_assert_not_reached ( ) ;
break ;
}

所有调试宏使用glib的g_log()输出警告信息，g_log()的警告信息包含发生错误的应用程序或库函数名字，并且还可以

使用一个替代的警告打印例程.

########################### 内存管理 ##############################

glib用自己的g_变体包装了标准的malloc()和free()，即g_malloc()和g_free()。
它们有以下几个小优点：
* g_malloc()总是返回gpointer，而不是char *，所以不必转换返回值。
* 如果低层的malloc()失败，g_malloc()将退出程序，所以不必检查返回值是否是NULL。
* g_malloc() 对于分配0字节返回NULL。
* g_free()忽略任何传递给它的NULL指针。

函数列表： glib内存分配
＃i nclude
gpointer g_malloc(gulong size)
void g_free(gpointer mem)
gpointer g_realloc(gpointer mem,gulong size)
gpointer g_memdup(gconstpointer mem,guint bytesize)

g_realloc()和realloc()是等价的。
g_malloc0()，它将分配的内存每一位都设置为0；
g_memdup()返回一个从mem开始的字节数为bytesize的拷贝。
为了与g_malloc()一致，g_realloc()和g_malloc0()都可以分配0字节内存。
g_memdup()在分配的原始内存中填充未设置的位，而不是设置为数值0。

宏列表：内存分配宏
＃i nclude
g_new(type, count)
g_new0(type, count)
g_renew(type, mem, count)

########################### 字符串处理 ##############################

如果需要比gchar *更好的字符串，glib提供了一个GString类型。
函数列表： 字符串操作
＃i nclude
gint g_snprintf(gchar* buf,gulong n,const gchar* format,. . . )
gint g_strcasecmp(const gchar* s1,const gchar* s2)
gint g_strncasecmp(const gchar* s1,const gchar* s2,guint n)

在含有snprintf()的平台上，g_snprintf()封装了一个本地的snprintf()，并且比原有实现更稳定、安全。
以往的snprintf()不保证它所填充的缓冲是以NULL结束的，但g_snprintf()保证了这一点。
g_snprintf函数在buf参数中生成一个最大长度为n的字符串。其中format是格式字符串,“...”是要插入的参数。

函数列表： 修改字符串
＃i nclude
void g_strdown(gchar* string)
void g_strup(gchar* string)
void g_strreverse(gchar* string)
gchar* g_strchug(gchar* string)
gchar* g_strchomp(gchar* string)
宏g_strstrip()结合以上两个函数，删除字符串前后的空格。

函数列表： 字符串转换
＃i nclude
gdouble g_strtod(const gchar* nptr,gchar** endptr)
gchar* g_strerror(gint errnum)
gchar* g_strsignal(gint signum)

函数列表： 分配字符串
＃i nclude
gchar * g_strdup(const gchar* str)
gchar* g_strndup(const gchar* format,guint n)
gchar* g_strdup_printf(const gchar* format,. . . )
gchar* g_strdup_vprintf(const gchar* format,va_list args)
gchar* g_strescape(gchar* string)
gchar* g_strnfill(guint length,gchar fill_char)
/////////////////////////////////////////////////////////////////////////
gchar* str = g_malloc(256);
g_snprintf(str, 256, "%d printf-style %s", 1, "format");
用下面的代码，不需计算缓冲区的大小：
gchar* str = g_strdup_printf("%d printf-style %", 1, "format") ;
/////////////////////////////////////////////////////////////////////////

函数列表：连接字符串的函数
＃i nclude
gchar* g_strconcat(const gchar* string1,. . . )
gchar* g_strjoin(const gchar* separator,. . . )

函数列表： 处理以NULL结尾的字符串向量
＃i nclude
gchar** g_strsplit(const gchar* string,const gchar* delimiter,gint max_tokens)
gchar* g_strjoinv(const gchar* separator,gchar** str_array)
void g_strfreev(gchar** str_array)

########################### 数据结构 ##############################

链表~~~~~~~~~~

glib提供了普通的单向链表和双向链表，分别是GSList 和GList。

创建链表、添加一个元素的代码：
GSList* list = NULL;
gchar* element = g_strdup("a string");
list = g_slist_append(list, element);
删除上面添加的元素并清空链表：
list = g_slist_remove(list, element);
为了清除整个链表，可使用g_slist_free()，它会快速删除所有的链接；
g_slist_free()只释放链表的单元，它并不知道怎样操作链表内容。

访问链表的元素，可以直接访问GSList结构：
gchar* my_data = list->data;
为了遍历整个链表，可以如下操作：
GSList* tmp = list;
while (tmp != NULL)
{
printf("List data: %p\n", tmp->data);
tmp = g_slist_next(tmp);
}

/////////////////////////////////////////////////////////////////////////////
下面的代码可以用来有效地向链表中添加数据：
void efficient_append(GSList** list, GSList** list_end, gpointer data)
{
g_return_if_fail(list != NULL);
g_return_if_fail(list_end != NULL);
if (*list == NULL)
{
g_assert(*list_end == NULL);
*list = g_slist_append(*list, data);
*list_end = *list;
}
else
{
*list_end = g_slist_append(*list_end, data)->next;
}
}

要使用这个函数，应该在其他地方存储指向链表和链表尾的指针，并将地址传递给efficient_append ()：
GSList* list = NULL;
GSList* list_end = NULL;
efficient_append(&list, &list_end, g_strdup("Foo"));
efficient_append(&list, &list_end, g_strdup("Bar"));
efficient_append(&list, &list_end, g_strdup("Baz"));
//////////////////////////////////////////////////////////////////////////////

函数列表：改变链表内容
＃i nclude
/* 向链表最后追加数据，应将修改过的链表赋给链表指针* /
GSList* g_slist_append(GSList* list,gpointer data)
/* 向链表最前面添加数据，应将修改过的链表赋给链表指针* /
GSList* g_slist_prepend(GSList* list,gpointer data)
/* 在链表的position位置向链表插入数据，应将修改过的链表赋给链表指针* /
GSList* g_slist_insert(GSList* list,gpointer data,gint position)
/ *删除链表中的data元素，应将修改过的链表赋给链表指针* /
GSList* g_slist_remove(GSList* list,gpointer data)

访问链表元素可以使用下面的函数列表中的函数。
这些函数都不改变链表的结构。
g_slist_foreach()对链表的每一项调用Gfunc函数。
Gfunc函数是像下面这样定义的：
typedef void (*GFunc)(gpointer data, gpointer user_data);
在g_slist_foreach()中，Gfunc函数会对链表的每个list->data调用一次，将user_data传递到g_slist_foreach()函

数中。

////////////////////////////////////////////////////////////////////////////////
例如, 有一个字符串链表，并且想创建一个类似的链表，让每个字符串做一些变换。
下面是相应的代码，使用了前面例子中的efficient_append()函数。
typedef struct _AppendContext AppendContext;
struct _AppendContext {
GSList* list;
GSList* list_end;
const gchar* append;
} ;
static void append_foreach(gpointer data, gpointer user_data)
{
AppendContext* ac = (AppendContext*) user_data;
gchar* oldstring = (gchar*) data;
efficient_append(&ac->list, &ac->list_end, g_strconcat(oldstring, ac->append, NULL));
}
GSList * copy_with_append(GSList* list_of_strings, const gchar* append)
{
AppendContext ac;
ac.list = NULL;
ac.list_end = NULL;
ac.append = append;
g_slist_foreach(list_of_strings, append_foreach, &ac);
return ac.list;
}

函数列表：访问链表中的数据
＃i nclude
GSList* g_slist_find(GSList* list,gpointer data)
GSList* g_slist_nth(GSList* list,guint n)
gpointer g_slist_nth_data(GSList* list,guint n)
GSList* g_slist_last(GSList* list)
gint g_slist_index(GSList* list,gpointer data)
void g_slist_foreach(GSList* list,GFunc func,gpointer user_data)

函数列表： 操纵链表
＃i nclude
/* 返回链表的长度* /
guint g_slist_length(GSList* list)
/* 将list1和list2两个链表连接成一个新链表* /
GSList* g_slist_concat(GSList* list1,GSList* list2)
/ *将链表的元素颠倒次序* /
GSList* g_slist_reverse(GSList* list)
/ *返回链表list的一个拷贝* /
GSList* g_slist_copy(GSList* list)

还有一些用于对链表排序的函数，见下面的函数列表。要使用这些函数，必须写一个比较函数GcompareFunc，就像标准

C里面的qsort()函数一样。
在glib里面，比较函数是这个样子：
typedef gint (*GCompareFunc) (gconstpointer a, gconstpointer b);
如果a < b，函数应该返回一个负值；如果a > b，返回一个正值；如果a = b，返回0。

函数列表： 对链表排序
＃i nclude
GSList* g_slist_insert_sorted(GSList* list,gpointer data,GCompareFunc func)
GSList* g_slist_sort(GSList* list,GCompareFunc func)
GSList* g_slist_find_custom(GSList* list,gpointer data,GCompareFunc func)

树~~~~~~~~~~~~~~

在glib中有两种不同的树：GTree是基本的平衡二叉树，它将存储按键值排序成对键值； GNode存储任意的树结构数据

，比如分析树或分类树。

函数列表：创建和销毁平衡二叉树
＃i nclude
GTree* g_tree_new(GCompareFunc key_compare_func)
void g_tree_destroy(GTree* tree)

函数列表： 操纵G t r e e数据
＃i nclude
void g_tree_insert(GTree* tree,gpointer key,gpointer value)
void g_tree_remove(GTree* tree,gpointer key)
gpointer g_tree_lookup(GTree* tree,gpointer key)

函数列表： 获得G Tr e e的大小
＃i nclude
/ *获得树的节点数* /
gint g_tree_nnodes(GTree* tree)
/ *获得树的高度* /
gint g_tree_height(GTree* tree)

使用g_tree_traverse()函数可以遍历整棵树。
要使用它，需要一个GtraverseFunc遍历函数，它用来给g_tree_trave rse()函数传递每一对键值对和数据参数。
只要GTraverseFunc返回FALSE，遍历继续；返回TRUE时，遍历停止。
可以用GTraverseFunc函数按值搜索整棵树。
以下是GTraverseFunc的定义：
typedef gint (*GTraverseFunc)(gpointer key, gpointer value, gpointer data);
G Tr a v e r s e Ty p e是枚举型，它有四种可能的值。下面是它们在G t r e e中各自的意思：
* G_IN_ORDER (中序遍历)首先递归左子树节点(通过GCompareFunc比较后,较小的键)，然后对当前节点的键值对调用

遍历函数，最后递归右子树。这种遍历方法是根据使用GCompareFunc函数从最小到最大遍历。
* G_PRE_ORDER (先序遍历)对当前节点的键值对调用遍历函数，然后递归左子树，最后递归右子树。
* G_POST_ORDER (后序遍历)先递归左子树，然后递归右子树，最后对当前节点的键值对调用遍历函数。
* G_LEVEL_ORDER (水平遍历)在GTree中不允许使用，只能用在Gnode中。

函数列表： 遍历GTree
＃i nclude
void g_tree_traverse( GTree* tree,
GTraverseFunc traverse_func,
GTraverseType traverse_type,
gpointer data )

一个GNode是一棵N维的树，由双链表(父和子链表)实现。
这样，大多数链表操作函数在Gnode API中都有对等的函数。可以用多种方式遍历。

以下是一个GNode的声明：
typedef struct _GNode GNode;
struct _GNode
{
gpointer data;
GNode *next;
GNode *prev;
GNode *parent;
GNode *children;
} ;

宏列表：访问GNode成员
＃i nclude
/ *返回GNode的前一个节点* /
g_node_prev_sibling ( node )
/ *返回GNode的下一个节点* /
g_node_next_sibling ( node )
/ *返回GNode的第一个子节点* /
g_node_first_child( node )

用g_node_new ()函数创建一个新节点。
g_node_new ()创建一个包含数据，并且无子节点、无父节点的Gnode节点。
通常仅用g_node_new ()创建根节点，还有一些宏可以根据需要自动创建新节点。
函数列表: 创建一个GNode
＃i nclude
GNode* g_node_new(gpointer data)

函数列表： 创建一棵GNode树
＃i nclude
/ *在父节点p a r e n t的p o s i t i o n处插入节点n o d e * /
GNode* g_node_insert(GNode* parent,gint position,GNode* node)
/ *在父节点p a r e n t中的s i b l i n g节点之前插入节点n o d e * /
GNode* g_node_insert_before(GNode* parent,GNode* sibling,GNode* node)
/ *在父节点p a r e n t最前面插入节点n o d e * /
GNode* g_node_prepend(GNode* parent,GNode* node)

宏列表：向Gnode添加、插入数据
＃i nclude
g_node_append(parent, node)
g_node_insert_data(parent, position, data)
g_node_insert_data_before(parent, sibling, data)
g_node_prepend_data(parent, data)
g_node_append_data(parent, data)

函数列表： 销毁GNode
＃i nclude
void g_node_destroy(GNode* root)
void g_node_unlink(GNode* node)

宏列表：判断G n o d e的类型
＃i nclude
G_NODE_IS_ROOT ( node )
G_NODE_IS_LEAF ( node )

下面函数列表中的函数返回Gnode的一些有用信息，包括它的节点数、根节点、深度以及含有特定数据指针的节点。
其中的遍历类型GtraverseType在Gtree中介绍过。
下面是在Gnode中它的可能取值：
* G_IN_ORDER 先递归节点最左边的子树，并访问节点本身，然后递归节点子树的其他部分。
这不是很有用，因为多数情况用于Gtree中。
* G_PRE_ORDER 访问当前节点，然后递归每一个子树。
* G_POST_ORDER 按序递归每个子树，然后访问当前节点。
* G_LEVEL_ORDER 首先访问节点本身，然后每个子树，然后子树的子树，然后子树的子树的子树，以次类推。
也就是说，它先访问深度为0的节点，然后是深度为1，然后是深度为2，等等。
GNode的树遍历函数有一个GTraverseFlags参数。这是一个位域，用来改变遍历的种类。
当前仅有三个标志—只访问叶节点，非叶节点，或者所有节点：
* G_TRAVERSE_LEAFS 指仅遍历叶节点。
* G_TRAVERSE_NON_LEAFS 指仅遍历非叶节点。
* G_TRAVERSE_ALL 只是指( G_TRAVERSE_LEAFS | G_TRAVERSE_NON_LEAFS )快捷方式。

函数列表： 取得G N o d e属性
＃i nclude
guint g_node_n_nodes(GNode* root,GTraverseFlags flags)
GNode* g_node_get_root(GNode* node)
Gboolean g_node_is_ancestor(GNode* node,GNode* descendant)
Guint g_node_depth(GNode* node)
GNode* g_node_find(GNode* root,GTraverseType order,GTraverseFlags flags,gpointer data)

GNode有两个独有的函数类型定义：
typedef gboolean (*GNodeTraverseFunc) (GNode* node, gpointer data);
typedef void (*GNodeForeachFunc) (GNode* node, gpointer data);
这些函数调用以要访问的节点指针以及用户数据作为参数。GNodeTraverseFunc返回TRUE，停止任何正在进行的遍历，

这样就能将GnodeTraverseFunc与g_node_traverse()结合起来按值搜索树。

函数列表： 访问GNode
＃i nclude
/ *对Gnode进行遍历* /
void g_node_traverse( GNode* root,
GTraverseType order,
GTraverseFlags flags,
gint max_depth,
GNodeTraverseFunc func,
gpointer data )
/ *返回GNode的最大高度* /
guint g_node_max_height(GNode* root)
/ *对Gnode的每个子节点调用一次f u n c函数* /
void g_node_children_foreach( GNode* node,
GTraverseFlags flags,
GNodeForeachFunc func,
gpointer data )
/ *颠倒node的子节点顺序* /
void g_node_reverse_children(GNode* node)
/ *返回节点node的子节点个数* /
guint g_node_n_children(GNode* node)
/ *返回node的第n个子节点* /
GNode* g_node_nth_child(GNode* node,guint n)
/ *返回node的最后一个子节点* /
GNode* g_node_last_child(GNode* node)
/ *在node中查找值为d a t e的节点* /
GNode* g_node_find_child(GNode* node,GTraverseFlags flags,gpointer data)
/ *返回子节点child在node中的位置* /
gint g_node_child_position(GNode* node,GNode* child)
/ *返回数据data在node中的索引号* /
gint g_node_child_index(GNode* node,gpointer data)
/ *以子节点形式返回node的第一个兄弟节点* /
GNode* g_node_first_sibling(GNode* node)
/ *以子节点形式返回node的第一个兄弟节点* /
GNode* g_node_last_sibling(GNode* node)

哈希表~~~~~~~~~~`

GHashTable是一个简单的哈希表实现，提供一个带有连续时间查寻的关联数组。
要使用哈希表，必须提供一个GhashFunc函数，当向它传递一个哈希值时，会返回正整数：
typedef guint (*GHashFunc) (gconstpointer key);
除了GhashFunc，还需要一个GcompareFunc比较函数用来测试关键字是否相等。
不过，虽然GCompareFunc函数原型是一样的，但它在GHashTable中的用法和在GSList、Gtree中的用法不一样。
在GHashTable中可以将GcompareFunc看作是等式操作符，如果参数是相等的，则返回TRUE。

函数列表： GHashTable
＃i nclude
GHashTable* g_hash_table_new(GHashFunc hash_func,GCompareFunc key_compare_func)
void g_hash_table_destroy(GHashTable* hash_table)

函数列表： 哈希表/比较函数
＃i nclude
guint g_int_hash(gconstpointer v)
gint g_int_equal(gconstpointer v1,gconstpointer v2)
guint g_direct_hash(gconstpointer v)
gint g_direct_equal(gconstpointer v1,gconstpointer v2)
guint g_str_hash(gconstpointer v)
gint g_str_equal(gconstpointer v1,gconstpointer v2)

函数列表： 处理GHashTable
＃i nclude
void g_hash_table_insert(GHashTable* hash_table,gpointer key,gpointer value)
void g_hash_table_remove(GHashTable * hash_table,gconstpointer key)
gpointer g_hash_table_lookup(GHashTable * hash_table,gconstpointer key)
gboolean g_hash_table_lookup_extended( GHashTable* hash_table,
gconstpointer lookup_key,
gpointer* orig_key,
gpointer* value )

函数列表： 冻结和解冻GHashTable
＃i nclude
/ * *冻结哈希表/
void g_hash_table_freeze(GHashTable* hash_table)
/ *将哈希表解冻* /
void g_hash_table_thaw(GHashTable* hash_table)


####################################### GString #####################################

GString的定义：
struct GString
{
gchar *str; /* Points to the st’rsi ncgurrent \0-terminated value. */
gint len; /* Current length */
} ;

用下面的函数创建新的GString变量：
GString *g_string_new( gchar *init );
这个函数创建一个GString，将字符串值init复制到GString中，返回一个指向它的指针。
如果init参数是NULL，创建一个空GString。

void g_string_free( GString *string,gint free_segment );
这个函数释放string所占据的内存。free_segment参数是一个布尔类型变量。
如果free_segment参数是TRUE，它还释放其中的字符数据。

GString *g_string_assign( GString *lval,const gchar *rval );
这个函数将字符从rval复制到lval，销毁lval的原有内容。
注意，如有必要， lval会被加长以容纳字符串的内容。

下面的函数的意义都是显而易见的。其中以_c结尾的函数接受一个字符，而不是字符串。
截取string字符串，生成一个长度为l e n的子串：
GString *g_string_truncate( GString *string,gint len );
将字符串val追加在string后面，返回一个新字符串：
GString *g_string_append( GString *string,gchar *val );
将字符c追加到string后面，返回一个新的字符串：
GString *g_string_append_c( GString *string,gchar c );
将字符串val插入到string前面，生成一个新字符串：
GString *g_string_prepend( GString *string,gchar *val );
将字符c插入到string前面，生成一个新字符串：
GString *g_string_prepend_c( GString *string,gchar c );
将一个格式化的字符串写到string中，类似于标准的sprintf函数：
void g_string_sprintf( GString *string,gchar *fmt,. . . ) ;
将一个格式化字符串追加到string后面，与上一个函数略有不同：
void g_string_sprintfa ( GString *string,gchar *fmt,... );

################################## 计时器函数 ##################################

创建一个新的计时器：
GTimer *g_timer_new( void );
销毁计时器：
void g_timer_destroy( GTimer *timer );
开始计时：
void g_timer_start( GTimer *timer );
停止计时：
void g_timer_stop( GTimer *timer );
计时重新置零：
void g_timer_reset( GTimer *timer );
获取计时器流逝的时间：
gdouble g_timer_elapsed( GTimer *timer,gulong *microseconds );

################################## 错误处理函数 ##################################

gchar *g_strerror( gint errnum );
返回一条对应于给定错误代码的错误字符串信息，例如“ no such process”等。
使用g_strerror函数：
g_print("hello_world:open:%s:%s\n", filename, g_strerror(errno));

void g_error( gchar *format, ... );
打印一条错误信息。
格式与printf函数类似，但是它在信息前面添加“ ** ERROR **: ”，然后退出程序。它只用于致命错误。

void g_warning( gchar *format, ... );
与上面的函数类似，在信息前面添加“ ** WARNING **:”，不退出应用程序。它可以用于不太严重的错误。

void g_message( gchar *format, ... );
在字符串前添加“message: ”，用于显示一条信息。

gchar *g_strsignal( gint signum );
打印给定信号号码的Linux系统信号的名称。在通用信号处理函数中很有用。

################################## 其他实用函数 ##################################

glib还提供了一系列实用函数，可以用于获取程序名称、当前目录、临时目录等。
这些函数都是在glib.h中定义的。
/* 返回应用程序的名称* /
gchar* g_get_prgname (void);
/* 设置应用程序的名称* /
void g_set_prgname (const gchar *prgname);
/* 返回当前用户的名称* /
gchar* g_get_user_name (void);
/* 返回用户的真实名称。该名称来自“passwd”文件。返回当前用户的主目录* /
gchar* g_get_real_name (void);
/* 返回当前使用的临时目录，它按环境变量TMPDIR、TMPandTEMP 的顺序查找。
如果上面的环境变量都没有定义，返回“ / t m p”* /
gchar* g_get_home_dir (void);
gchar* g_get_tmp_dir (void);
/* 返回当前目录。返回的字符串不再需要时应该用g_free ( ) 释放* /
gchar* g_get_current_dir (void);
/ *获得文件名的不带任何前导目录部分的名称。它返回一个指向给定文件名字符串的指针* /
gchar* g_basename (const gchar *file_name);
/* 返回文件名的目录部分。如果文件名不包含目录部分，返回“ .”。
* 返回的字符串不再使用时应该用g_free() 函数释放* /
gchar* g_dirname (const gchar *file_name);
/* 如果给定的file_name是绝对文件名（包含从根目录开始的完整路径，比如/usr/local），返回TRUE * /
gboolean g_path_is_absolute (const gchar *file_name);
/* 返回一个指向文件名的根部标志（“/”）之后部分的指针。
* 如果文件名file_name不是一个绝对路径，返回NULL * /
gchar* g_path_skip_root (gchar *file_name);
/ *指定一个在正常程序终止时要执行的函数* /
void g_atexit (GVoidFunc func);

上面介绍的只是glib库中的一小部分， glib的特性远远不止这些。
如果想了解其他内容，参考glib.h文件。这里面的绝大多数函数都是简明易懂的。
另外，http://www.gtk.org上的glib文档也是极好的资源。

如果你需要一些通用的函数，但glib中还没有，考虑写一个glib风格的例程，将它贡献到glib库中！
你自己，以及全世界的glib使用者，都将因为你的出色工作而受益。

glib介绍

glib介绍
gnome是基于gtk+开发的一套桌面环境，gnome和KDE作为两大最流行的桌面环境，在全世界广泛使用。只要是在Linux下工作的开发人员，对于gtk+一定不陌生。而对于glib，这个gtk+下的无名英雄，其功能强大却鲜为人知。今天，在这里简要介绍一下，如果你是开发人员，看完本文，相信你会爱上它的。

glib不是gllibc，尽管两者都是基于(L)GPL的开源软件。但这一字之差却误之千里，glibc是GNU实现的一套标准C的库函数，而glib是gtk+的一套函数库。在linux平台上，像其它任何软件一样，glib依赖于glibc。

glib不是一个学院派的东西，也不是凭空想出来的，完全是在开发gtk+的过程中，慢慢总结和完善的结果。如果你是一个工作3年以上的C语言程序员，现在让你讲讲写程序的苦恼，你可能有很多话要说，但如果你有时间研究一下glib，你会发现，很多苦恼已不再成其为苦恼，glib里很多东西正是你期望已经久的。

gobject是glib的精粹，glib是用C实现的，但在很大程序是基于面向对象思想设计的，gobject是所有类的基类。signal在其中也是一大特色，signal与操作系统中的signal并不一样，它是类似消息一样的东西，让消息在各个对象间传递，但尽量降低对象间的耦合。仔细读一下它的代码，唯一想说的话就是“绝！”。

动态数组、链表、哈希表等通用容器，在不同的公司，在不同的时期，在不同的情况下，我们每个人对每一种容器，可能都实现过N次以上。甚至在同一个项目里，出现几份链表的实现，也并非罕见。一直在抱怨，标准C中为什么没有类似于STL的标准容器，让全世界的程序员在数以万次的重复实现它们。不过，还算走运，有了glib，恶梦在此终结了。glib提供了动态数组、单/双向链表、哈希表、多叉树、平衡二叉树、字符串等常用容器，完全是面向对象设计的，实现得非常精致。不用白不用，别客气了。

你开发过跨硬件平台的软件吗？是不是常常为硬件平台的差异而苦恼呢？字节顺序是常见的问题之一，大端格式，小端格式，还是PDP格式的？这样差异造成的BUG会浪费不少时间，同时让代码晦涩难读。glib提供了一套完整的宏，利用这些宏编写程序，问题大大简化了。

你开发过跨操作系统的软件吗？在不同的平台下，很多函数有相同的功能，但函数原型，返回值差异巨大，也有的貌合神离，相同的名称有着不同的意义，请看下面这张清单：
动态库加载函数
线程函数
信号量函数
互斥锁函数
事件函数
字符集转换函数
原子操作函数
创建进程函数
时间格式
IO函数

为完成相同的功能，你却要为此写出不同的代码。那怕只是一个简单的封装，这么多，你烦不烦？用glib吧，它的作者们都是高手中的高手，对不同的平台的理解程度，远远超出你和我，而且这些程序经过大量的应用程序测试，已经非常的稳定了，放心的用吧。

你写过读取配置文件的模块吧，像读取ini这样简单格式的文件，当然不在话下，要读markup语言格式的配置文件，难度可能大了点，虽然不是不可能，但除非是为了学习，何必自己找麻烦呢。glib里提供了词法分析、markup语言解析、ini文件存取等功能，你完全不用为此担忧。

不管是命令行程序，还是GUI程序，或者后台服务进程，通过命令参数来控制程序的行为，都是开发人员惯用的手法。从命令行参数取到有用的信息，不难，遍历一遍不就行了吗？但在每个程序中都来遍一次，你不觉得很单调吗？我们的时间很宝贵，浪费时间做这种事情，不值得吧。glib的作者们早考虑到了，它提供了这样的功能，你调用的它的函数，可能轻松的取得所要的命令行参数。


对于正则表达式，Win32下的开发人员可能用得少一点，而在Linux下的Shell里，它却是不可或缺之物。有没有想到在自己的程序中使用的它呢，在有的情况下，使用正则表达式，可能会大大降低开发的难度，提高易用性。glib也想到了这一点，它提供了简单的正则表达式功能，当然，用与不用完全取决于你自己。


在程序里，如果程序出错了，特别是调了不该调用的函数，你是不是很想知道是谁调了它？大多数时候用debuger是最好的选择，在某些情况下，没有debuger可用，或者在debuger里重现不了这个问题，你会不会觉得很无助？别怕，glib提供了一套跨平台的backtrace函数，有了它，你可以很容易找到元凶了。


如果读过一些大型的开源项目，你会发现，差不多每个项目都有一套自己的log函数，用于记录程序运行的调试或者审计信息。也有可能，你自己都曾在不同的项目里实现过好几次这个功能，第一次实现会觉得很好玩，会学到了一些东西，后来就会发现自己在做无用功。重复就是浪费，重复就是犯罪，glib想到了这一点，它实现了一套完整的log机制，供大家在不同的项目中使用。


产生质数的算法不难，在我们的程序里也像是星外来客，很少使用，常常忽略了它。所谓书到用时方恨少，有这样的东东，说不定就有用得到它的时候。glib提供了这样的功能，同时还提供了一个较好的随机数算法。

Linux Shell里的自动补完功能很好用吧，从Linux转移到Win32下工作的开发人员，常常抱怨Win32的Shell里没有这个功能，其实Win32下也是有的，把注册表里的一个选项打开就行了。不管怎么样，总之这个功能太有用了，没有它，你都会觉得少了点什么，全身不自在，glib里连这个功能都提供了，是不是很人性化呢？


内存问题！还是内存问题！如果你没有为内存问题而苦恼过，我都怀疑你是不是一个真正的C语言程序员。内存泄露、访问越界、空指针、野指针和内存优化等问题，是不是都曾让你夜不能昧？有些工具可以帮助你，但这不是万能的良药，好好写你的程序才是第一要义。glib提供了一些的手段，也可以在一定程度上减轻你的痛苦。

0pt;">

呵，怎么样？还快不去下载一个来玩玩？ftp://ftp.gtk.org/pub/gtk/v2.8/

Linux系统下的C语言开发都需要学些什么

　　一、工具的使用

　　1、学会使用vim/emacs，vim/emacs是linux下最常用的源码编辑具，不光要学会用它们编辑源码，还要学会用它们进行查找、定位、替换等。新手的话推荐使用vim，这也是我目前使用的文本编辑器。

　　2、学会makefile文件的编写规则，并结合使用工具aclocal、autoconf和automake生成makefile文件。

　　3、掌握gcc和gdb的基本用法。掌握gcc的用法对于构建一个软件包很有益处，当软件包包含的文件比较多的时候，你还能用gcc把它手动编译出来，你就会对软件包中各个文件间的依赖关系有一个清晰的了解。

　　4、掌握svn/cvs的基本用法。这是linux，也是开源社区最常用的版本管理系统。可以去试着参加sourceforge上的一些开源项目。

　　二、linux/unix系统调用与标准C库

　　系统调用应用软件与操作系统的接口，其重要性自然不用说，一定要掌握。推荐学习资料为steven先生的UNIX环境高级编程(简称APUE)。

　　三、库的学习

　　无论是在哪个平台做软件开发，对于库的学习都很重要，linux下的开发库很多，我主要介绍一下我常常用到的一些库。

　　1、glib库

　　glib 库是gtk+和gnome的基础库，并具是跨平台的，在linux、unix和windows下都可以用。glib库对于linux平台开发的影响就像 MFC对windows平台开发的影响一样，很多开源项目都大量的使用了glib库，包括gimp、gnome、gaim、evolution和 linux下的集群软件heartbeat.因为glib库自带有基本的数据结构实现，所以在学习glib库的时候可以顺便学习一下基本的数据结构(包括链表、树、队列和hash表)。

　　2、libxml库

　　libxml是linux平台下解析XML文件的一个基础库，现在很多实用软件都用XML格式的配置文件，所以也有必要学习一下。

　　3、readline库

　　readline 库是bash shell用的库，如果要开发命令行程序，那么使用readline库可以减少很多工作量，比如bash里的命令行自动补全，在readline里就已经有实现，当然你也可以用自己的实现替代库的行为。readline库有很多网站介绍的，只要google一下readline就可以找到一堆了。

　　4、curses库

　　curses 库以前是vi程序的一部分，后来从vi里提取出来成为一个独立的库。curses库对于编写终端相关的程序特别有用，比如要在终端某一行某一列定位输出，改变终端字体的颜色和终端模式。linux下的curses库用的是GNU实现的ncurses(new curses的意思)。

　　5、gtk+和KDE库

　　这两个库是开发GUI应用程序的基础库，现在linux下的大部份GUI程序都是基于这两个库开发的，对于它们 的学习也是很有必要的。

　　四、网络的学习

　　网络这个东西太宽了，推荐学习资料steven先生的UNIX网络编程(简称UNP)和TCP/IP协议详解，更进一步的话可以学习使用libnet编写网络程序。

头文件与之实现文件的的关系

今天在网上看到一篇解释.h与.c(.cpp)的文章,我读完后感到有些地方不妥,特此按照我的理解,给初学者一些指导~
说几句题外话,刚才让女朋友陪我出去一会,她说她要先化化妆,我随口就来--简单就是美丽啊!
你猜她说什么:美丽除了天生丽质外,保养也是很重要的~ 我倒~

你理解简单的含义吗?
关于两者以前的关系,要从N年以前说起了~ long long ago,once aupon a time .......
那是一个被遗忘的年代,在编译器只认识.c(.cpp))文件，而不知道.h是何物的年代。
那时的人们写了很多的.c(.cpp)文件，渐渐地，人们发现在很多.c(.cpp)文件中的声明语句就是相同的，但他们却不得不一个字一个字地重复地将这些内容敲入每个.c(.cpp)文件。但更为恐怖的是，当其中一个声明有变更时，就需要检查所有的.c(.cpp)文件，并修改其中的声明,啊~简直是世界末日降临!
终于，有人（或许是一些人）再不能忍受这样的折磨，他（们）将重复的部分提取出来，放在一个新文件里,然后在需要的.c(.cpp)文件中敲入#include XXXX这样的语句。这样即使某个声明发生了变更，也再不需要到处寻找与修改了---世界还是那么美好！
因为这个新文件，经常被放在.c(.cpp)文件的头部，所以就给它起名叫做“头文件”，扩展名是.h.
从此，编译器（其实是预处理器）就知道世上除了.c(.cpp)文件，还有个.h的文件，以及一个叫做#include命令。

虽然后来又发生很多的变化，但是这样的用法一直延续至今，只是时日久远了，人们便淡忘了当年的缘由罢了。
提到了头文件,就说说它的作用吧~
想到了林锐GG写的高质量C/C++编程上头文件的作用的简短描述:
（1）通过头文件来调用库功能。在很多场合，源代码不便（或不准）向用户公布，只要向用户提供头文件和二进制的库即可。用户只需要按照头文件中的接口声明来调用库功能，而不必关心接口怎么实现的。编译器会从库中提取相应的代码。
（2）头文件能加强类型安全检查。如果某个接口被实现或被使用时，其方式与头文件中的声明不一致，编译器就会指出错误，这一简单的规则能大大减轻程序员调试、改错的负担。


预处理是编译器的前驱,作用是把存储在不同文件里的程序模块集成为一个完整的源程序.
#include本身只是一个简单的文件包含预处理命令,即为把include的后面文件放到这条命令这里,除此之外,没有其它的用处(至少我也样认为).


我对乾坤一笑兄的观点,十分赞同,基础的东东一定要弄明白.
我下面就乾坤一笑兄的例子做讲,完备他的一些让人迷惑不解的时候~

例子:
//a.h
void foo();


//a.c
#include "a.h" //我的问题出来了：这句话是要，还是不要？
void foo()
{
return;
}

//main.c
#include "a.h"
int main(int argc, char *argv[])
{
foo();
　return 0;
}

针对上面的代码，请回答三个问题：
a.c 中的 #include "a.h" 这句话是不是多余的？
1.为什么经常见 xx.c 里面 include 对应的 xx.h？
2.如果 a.c 中不写，那么编译器是不是会自动把 .h 文件里面的东西跟同名的 .c 文件绑定在一起？
3.第三个问题我给他改了一下:如果 a.c 中不写include<>，那么编译器是不是会自动把 .h 文件里面的东西跟同名的.c文件绑定在一起？

下面是乾坤一笑的原话:

从C编译器角度看，.h和.c皆是浮云，就是改名为.txt、.doc也没有大的分别。换句话说，就是.h和.c没啥必然联系。.h中一般放的是同名.c文件中定义的变量、数组、函数的声明，需要让.c外部使用的声明。这个声明有啥用？只是让需要用这些声明的地方方便引用。因为 #include "xx.h" 这个宏其实际意思就是把当前这一行删掉，把 xx.h 中的内容原封不动的插入在当前行的位置。由于想写这些函数声明的地方非常多（每一个调用 xx.c 中函数的地方，都要在使用前声明一下子），所以用 #include "xx.h" 这个宏就简化了许多行代码——让预处理器自己替换好了。也就是说，xx.h 其实只是让需要写 xx.c 中函数声明的地方调用（可以少写几行字），至于 include 这个 .h 文件是谁，是 .h 还是 .c，还是与这个 .h 同名的 .c，都没有任何必然关系。
这样你可能会说：啊？那我平时只想调用 xx.c 中的某个函数，却 include了 xx.h 文件，岂不是宏替换后出现了很多无用的声明？没错，确实引入了很多垃圾 ，但是它却省了你不少笔墨，并且整个版面也看起来清爽的多。鱼与熊掌不可得兼，就是这个道理。反正多些声明（.h一般只用来放声明，而放不定义，参见拙著 “过马路，左右看”）也无害处，又不会影响编译，何乐而不为呢？
翻回头再看上面的3个问题，很好解答了吧？
它的解答如下:

答：1.不一定。这个例子中显然是多余的。但是如果.c中的函数也需要调用同个.c中的其它函数，那么这个.c往往会include同名的.h，这样就不需要为声明和调用顺序而发愁了（C语言要求使用之前必须声明，而include同名.h一般会放在.c的开头）。有很多工程甚至把这种写法约定为代码规范，以规范出清晰的代码来。
2.答：1中已经回答过了。
3.答：不会。问这个问题的人绝对是概念不清，要不就是想混水摸鱼。非常讨厌的是中国的很多考试出的都是这种烂题，生怕别人有个清楚的概念了，绝对要把考生搞晕。

over!

在此里要明确一点,编译器是按照编译单元进行编译的,所谓的编译单元,是指一个.c文件以及它所include的所有.h文件.最直观的理解就是一个文件,一个工程中可以包含很多文件,其中有一个程序的入口点,即我们通常所说的main()函数(当然也可以没有这个函数,程序照样能启动,详细见我的 blog中).在没有这个程序入口点的情况下,编译单元只生成目标文件object file(.o文件,windows下叫做.obj).

这个例子中总共包含了二个编译单元,分别是a.c,main.c,按照我所说的,在编译阶段只是生成各自的.o文件.这个阶段不和其它的文件发生任何的关系.
而include这个预处理指令发生在预处理阶段(早先编译阶段,只是编译器的一个前驱处理程序).


.h .c不见得是浮云,脱离了编译器谈这些没有任何的意义,抛开更深层次的这些,比如说,OS如何启动这个文件,PE结构(linux 下为elf)等等
编译器首先要识别这个文件才可能去编译它,这是前提.如果你改了它的扩展名那么你的编译器还能认识它吗~上升到一个更高的层次上看待这个问题,XX兄说的也不错~我想XX兄说的意思就是两者不可因为名字相同就认为两者有什么关系,名字是可以随便的~
两者之间的联系,我在前面说过了,是由于历史的原因造成的,再加上人的习惯,我想谁也不想多去记那么多文件名吧.(拿我举个例子,一个数
据表如果多于30个字段,我就觉得头大了,现在弄的表有的多达上百个字段,真希望那位高人研究出什么好的方法来~,也让我们的世界美好一些~)

乾坤一笑的第三个问题很有代表性,多次在网上看到,现在的编译器绝对没有那么智能,而且也没有必须那么做.下面我们主要聊聊编译器的处理过程.(我想初学者有疑问的正在于此,即是对于编译过程.h .c(.cpp)的变化不太了解,)

下面我说举个简单的例子来聊聊~
例子如下:
//a.h
class A
{
pubic:
int f(int t);
};

//a.cpp
#include "a.h"
int A::f(int t)
{
return t;
}

//main.cpp
#include "a.h"
void main()
{
A a;
a.f(3);
}
在预处理阶段,预处理器看到#include "文件名"就把这个文件读进来,比如它编译main.cpp，看到#include "a.h"，它就把a.h的内容读进来，它知道了，有一类A，包含一个成员函数f，这个函数接受一个int型的参数，返回一个int型的值。再往下编译很容易就把A a这行读懂了，它知道是要拿A这个类在栈上生成一个对象。再往下，它知道了下面要调用A的成员函数f了，参数是3，由于它知道这个函数要一个整形数用参数，这个3正好匹配，那就正好把它放到栈上，生成一条调用f(int)函数的指令（一般可能是一句call），至于这个f(int)函数到底在哪里，它不知道，它留着空，链接时再解决。它还知道f(int)函数要返回一个int，所以也许它也为这一点做好了准备（在例子中，我们没用这个返回值，也许它就不处理）。再往下到文件末尾了main.cpp编译好了，生成了main.obj。整个编译过程中根本就不需要知道a.cpp的内容。
同理，编译器再编译a.cpp，把f()函数编译好，编译a.cpp时，它也不用管别的，把f()编译好就行了。生成了a.obj。
最后一步就是链接的阶段了，链接器把项目中所有.cpp生成的所有.obj链接起来，
在这一步中，它就明确了f(int)函数的实现所在的地址，把main.obj中空着的这个地址位置填上正确的地址。最终生成了可执行文件main.exe。

明白了吗?不明白那就多说几句了,我们在学编译原理的时候都知道,编译器是分阶段进行的,每一个阶段将源程序从一种表示转换成另一种表示,一般情况下都进行如下顺序:源程序->词法分器->语法分析器->语义分析器->中间代码生成器->代码优化器->代码生成器->目标程序.
其中这中间6项活动都要涉及的两项主要活动是:符号管理器与错误处理器.
归根原因,这里有一个叫做符号表的东东在里面让你着魔一样不明白,其实符号表是一个数据结构.编译器的基本一项功能就是要记录源程序中使用的标识符并收集与每个标识符相关的各种属性信息.属性信息表明了该标识符的存储位置/类型/作用域(在那个阶段有效)等信息,通俗的说一下就是,当编译器看到一个符号声明时,例如你的函数名它就会把它放到这个符号表中去登记一下~符号表里存放着你的函数的入口地址,参数个数,返回信息等等一堆东西~而在联接阶段主要是处理工程中的符号表与调用对应处理关系,即我们通常所说的解引用.