linuxc位运算

『壹』 c语言位运算

只举一例，余下的楼主自己查阅“与”、“或”及其它概念的定义。

位与：
resand=czs1&czs2

czs1=521=0x209=0b1000001001
czs2=123=0x7B= 0b01111011
位与的意思是：将某两个数转换位二进制（即上述的0bxx），自最低位起将二进制的每一位进行比较，两个数的该位均为1时，最终位与的结果中该位也为1；否则最终位与结果中该位问0.
czs1与czs2位与后，最低位和第四位均为1，即最终位与结果为0b1001，即9.

『贰』 C语言中的位运算是怎样的

C语言是为描述系统而设计的，它的第一个应用就是UNIX操作系统的设计，因此必须具有低级语言的特点。指针运算和位运算就是其代表。
我们知道，计算机中的信息以及控制信号均是以二进制码的0、1的形式存储和处理的。每一个0或1称为一个“位”（bit），8位构成一个字节（byte）。在内存中，每一个字节均有一个编号，称为内存地址。
在以前的各章节中，我们都是将一个字节（如字符型）和若干字节（如整型、实型等）中的内容作为一个整体进行处理的（赋值、运算、I/O操作）。
位运算则是针对这些字节中的若干位进行操作。这在系统软件设计中和自动控制中是十分有用的。
C语言的位运算符有~,<<,
>>,
&,
|,
^共6个，并可与赋值运算符相结合（除~外）成为位运算赋值操作。
应注意：参与位运算的量只能是整型和字符型。

『叁』 c语言位运算符的用法

c语言位运算符的用法1

c语言位运算符的用法如下：

一、位运算符C语言提供了六种位运算符：

& 按位与

| 按位或

^ 按位异或

~ 取反

<< 左移

>> 右移

1. 按位与运算

按位与运算符"&"是双目运算符。其功能是参与运算的两数各对应的二进位相与。只有对应的两个二进位均为1时，结果位才为1 ，否则为0。参与运算的数以补码方式出现。

例如：9&5可写算式如下： 00001001 (9的二进制补码)&00000101 (5的二进制补码) 00000001 (1的二进制补码)可见9&5=1。

按位与运算通常用来对某些位清0或保留某些位。例如把a 的高八位清 0 ， 保留低八位， 可作 a&255 运算 ( 255 的二进制数为0000000011111111)。

main(){

int a=9,b=5,c;

c=a&b;

printf("a=%d/nb=%d/nc=%d/n",a,b,c);

}

2. 按位或运算

按位或运算符“|”是双目运算符。其功能是参与运算的两数各对应的二进位相或。只要对应的二个二进位有一个为1时，结果位就为1。参与运算的两个数均以补码出现。

例如：9|5可写算式如下： 00001001|00000101

00001101 (十进制为13)可见9|5=13

main(){

int a=9,b=5,c;

c=a|b;

printf("a=%d/nb=%d/nc=%d/n",a,b,c);

}

3. 按位异或运算

按位异或运算符“^”是双目运算符。其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。参与运算数仍以补码出现，例如9^5可写成算式如下： 00001001^00000101 00001100 (十进制为12)。

main(){

int a=9;

a=a^15;

printf("a=%d/n",a);

}

4. 求反运算

求反运算符～为单目运算符，具有右结合性。 其功能是对参与运算的数的各二进位按位求反。例如～9的运算为： ~(0000000000001001)结果为：1111111111110110。

5. 左移运算

左移运算符“<<”是双目运算符。其功能把“<< ”左边的运算数的各二进位全部左移若干位，由“<<”右边的数指定移动的位数，高位丢弃，低位补0。例如： a<<4 指把a的各二进位向左移动4位。如a=00000011(十进制3)，左移4位后为00110000(十进制48)。

6. 右移运算

右移运算符“>>”是双目运算符。其功能是把“>> ”左边的运算数的`各二进位全部右移若干位，“>>”右边的数指定移动的位数。

例如：设 a=15，a>>2 表示把000001111右移为00000011(十进制3)。 应该说明的是，对于有符号数，在右移时，符号位将随同移动。当为正数时， 最高位补0，而为负数时，符号位为1，最高位是补0或是补1 取决于编译系统的规定。Turbo C和很多系统规定为补1。

main(){

unsigned a,b;

printf("input a number: ");

scanf("%d",&a);

b=a>>5;

b=b&15;

printf("a=%d/tb=%d/n",a,b);

}

请再看一例!

main(){

char a='a',b='b';

int p,c,d;

p=a;

p=(p<<8)|b;

d=p&0xff;

c=(p&0xff00)>>8;

printf("a=%d/nb=%d/nc=%d/nd=%d/n",a,b,c,d);

}

c语言位运算符的用法2

C语言位运算。所谓位运算，就是对一个比特(Bit)位进行操作。比特(Bit)是一个电子元器件，8个比特构成一个字节(Byte)，它已经是粒度最小的可操作单元了。

C语言提供了六种位运算符：

按位与运算(&)

一个比特(Bit)位只有 0 和 1 两个取值，只有参与&运算的两个位都为 1 时，结果才为 1，否则为 0。例如1&1为 1，0&0为 0，1&0也为 0，这和逻辑运算符&&非常类似。

C语言中不能直接使用二进制，&两边的操作数可以是十进制、八进制、十六进制，它们在内存中最终都是以二进制形式存储，&就是对这些内存中的二进制位进行运算。其他的位运算符也是相同的道理。

例如，9 & 5可以转换成如下的运算：

0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (9 在内存中的存储)

& 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储)

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

0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0001 (1 在内存中的存储)

也就是说，按位与运算会对参与运算的两个数的所有二进制位进行&运算，9 & 5的结果为 1。

又如，-9 & 5可以转换成如下的运算：

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储)

& 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储)

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

0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储)

-9 & 5的结果是 5。

关于正数和负数在内存中的存储形式，我们已在教程《整数在内存中是如何存储的》中进行了讲解。

再强调一遍，&是根据内存中的二进制位进行运算的，而不是数据的二进制形式;其他位运算符也一样。以-9&5为例，-9 的在内存中的存储和 -9 的二进制形式截然不同：

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储)

-0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (-9 的二进制形式，前面多余的 0 可以抹掉)

按位与运算通常用来对某些位清 0，或者保留某些位。例如要把 n 的高 16 位清 0 ，保留低 16 位，可以进行n & 0XFFFF运算(0XFFFF 在内存中的存储形式为 0000 0000 -- 0000 0000 -- 1111 1111 -- 1111 1111)。

【实例】对上面的分析进行检验。

00001. #include

00002.

00003. int main(){

00004. int n = 0X8FA6002D;

00005. printf("%d, %d, %X ", 9 & 5, -9 & 5, n & 0XFFFF);

00006. return 0;

00007. }

运行结果：

1, 5, 2D

按位或运算(|)

参与|运算的两个二进制位有一个为 1 时，结果就为 1，两个都为 0 时结果才为 0。例如1|1为1，0|0为0，1|0为1，这和逻辑运算中的||非常类似。

例如，9 | 5可以转换成如下的运算：

0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (9 在内存中的存储)

| 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储)

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

0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1101 (13 在内存中的存储)

9 | 5的结果为 13。

又如，-9 | 5可以转换成如下的运算：

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储)

| 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储)

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

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储)

-9 | 5的结果是 -9。

按位或运算可以用来将某些位置 1，或者保留某些位。例如要把 n 的高 16 位置 1，保留低 16 位，可以进行n | 0XFFFF0000运算(0XFFFF0000 在内存中的存储形式为 1111 1111 -- 1111 1111 -- 0000 0000 -- 0000 0000)。

【实例】对上面的分析进行校验。

00001. #include

00002.

00003. int main(){

00004. int n = 0X2D;

00005. printf("%d, %d, %X ", 9 | 5, -9 | 5, n | 0XFFFF0000);

00006. return 0;

00007. }

运行结果：

13, -9, FFFF002D

按位异或运算(^)

参与^运算两个二进制位不同时，结果为 1，相同时结果为 0。例如0^1为1，0^0为0，1^1为0。

例如，9 ^ 5可以转换成如下的运算：

0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (9 在内存中的存储)

^ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储)

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

0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1100 (12 在内存中的存储)

9 ^ 5的结果为 12。

又如，-9 ^ 5可以转换成如下的运算：

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储)

^ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 (5 在内存中的存储)

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

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0010 (-14 在内存中的存储)

-9 ^ 5的结果是 -14。

按位异或运算可以用来将某些二进制位反转。例如要把 n 的高 16 位反转，保留低 16 位，可以进行n ^ 0XFFFF0000运算(0XFFFF0000 在内存中的存储形式为 1111 1111 -- 1111 1111 -- 0000 0000 -- 0000 0000)。

【实例】对上面的分析进行校验。

00001. #include

00002.

00003. int main(){

00004. unsigned n = 0X0A07002D;

00005. printf("%d, %d, %X ", 9 ^ 5, -9 ^ 5, n ^ 0XFFFF0000);

00006. return 0;

00007. }

运行结果：

12, -14, F5F8002D

取反运算(~)

取反运算符~为单目运算符，右结合性，作用是对参与运算的二进制位取反。例如~1为0，~0为1，这和逻辑运算中的!非常类似。。

例如，~9可以转换为如下的运算：

~ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (9 在内存中的存储)

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

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0110 (-10 在内存中的存储)

所以~9的结果为 -10。

例如，~-9可以转换为如下的运算：

~ 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储)

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

0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1000 (9 在内存中的存储)

所以~-9的结果为 8。

【实例】对上面的分析进行校验。

00001. #include

00002.

00003. int main(){

00004. printf("%d, %d ", ~9, ~-9 );

00005. return 0;

00006. }

运行结果：

-10, 8

左移运算(<<)

左移运算符<<用来把操作数的各个二进制位全部左移若干位，高位丢弃，低位补0。

例如，9<<3可以转换为如下的运算：

<< 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (9 在内存中的存储)

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

0000 0000 -- 0000 0000 -- 0000 0000 -- 0100 1000 (72 在内存中的存储)

所以9<<3的结果为 72。

又如，(-9)<<3可以转换为如下的运算：

<< 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储)

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

1111 1111 -- 1111 1111 -- 1111 1111 -- 1011 1000 (-72 在内存中的存储)

所以(-9)<<3的结果为 -72

如果数据较小，被丢弃的高位不包含 1，那么左移 n 位相当于乘以 2 的 n 次方。

【实例】对上面的结果进行校验。

00001. #include

00002.

00003. int main(){

00004. printf("%d, %d ", 9<<3, (-9)<<3 );

00005. return 0;

00006. }

运行结果：

72, -72

右移运算(>>)

右移运算符>>用来把操作数的各个二进制位全部右移若干位，低位丢弃，高位补 0 或 1。如果数据的最高位是 0，那么就补 0;如果最高位是 1，那么就补 1。

例如，9>>3可以转换为如下的运算：

>> 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 (9 在内存中的存储)

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

0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0001 (1 在内存中的存储)

所以9>>3的结果为 1。

又如，(-9)>>3可以转换为如下的运算：

>> 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 (-9 在内存中的存储)

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

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 1110 (-2 在内存中的存储)

所以(-9)>>3的结果为 -2

如果被丢弃的低位不包含 1，那么右移 n 位相当于除以 2 的 n 次方(但被移除的位中经常会包含 1)。

【实例】对上面的结果进行校验。

00001. #include

00002.

00003. int main(){

00004. printf("%d, %d ", 9>>3, (-9)>>3 );

00005. return 0;

00006. }

运行结果：

1, -2

c语言位运算符的用法3

一、位运算符

在计算机中，数据都是以二进制数形式存放的，位运算就是指对存储单元中二进制位的运算。C语言提供6种位运算符。

二、位运算

位运算符 & |~<< >> ∧ 按优先级从高到低排列的顺序是：

位运算符中求反运算“~“优先级最高，而左移和右移相同，居于第二，接下来的顺序是按位与 “&“、按位异或 “∧“和按位或 “|“。顺序为~ << >> & ∧ | 。

例1：左移运算符“<<”是双目运算符。其功能把“<< ”左边的运算数的各二进位全部左移若干位，由“<<”右边的数指定移动的位数，高位丢弃，低位补0。

例如：

a<<4

指把a的各二进位向左移动4位。如a=00000011(十进制3)，左移4位后为00110000(十进制48)。

例2：右移运算符“>>”是双目运算符。其功能是把“>> ”左边的运算数的各二进位全部右移若干位，“>>”右边的数指定移动的位数。

例如：

设 a=15，

a>>2

表示把000001111右移为00000011(十进制3)。

应该说明的是，对于有符号数，在右移时，符号位将随同移动。当为正数时，最高位补0，而为负数时，符号位为1，最高位是补0或是补1 取决于编译系统的规定。

例3：设二进制数a是00101101 ，若通过异或运算a∧b 使a的高4位取反，低4位不变，则二进制数b是。

解析：异或运算常用来使特定位翻转，只要使需翻转的位与1进行异或操作就可以了，因为原数中值为1的位与1进行异或运算得0 ，原数中值为0的位与1进行异或运算结果得1。而与0进行异或的位将保持原值。异或运算还可用来交换两个值，不用临时变量。

如 int a=3 , b=4;，想将a与b的值互换，可用如下语句实现：

a=a∧b;

b=b∧a;

a=a∧b;

所以本题的答案为： 11110000 。

『肆』 C语言中的位运算符有哪些

C 语言中有以下位运算符：

1. &（按位与）：将两个数的二进制每一位同时与（AND）起来，并将结果赋给左操作数。

2. |（按位或）：将两个数的二进制每一位同时或（OR）起来，并将结果赋给左操作数。

3. ^（按位异或）：将两个数的二进制每一位同时异或（XOR）起来，并将结果赋给左操作数。

4. <<（左移）：将左操作数的二进制数向左移动右操作数指定的位数，并将结果赋给左操作数。

5. >>（右移）：将左操作数的二进制数向右移动右操作数指定的位数，并将结果赋给左操作数。

6. ~（按位取反）：将左操作数的二进制数按位取反（即 1 变为 0，0 变为 1），并将结果赋给左操作数。

希望这些可以帮助到你。

『伍』 linux C - C基础篇（一）

1) 最高位是符号位，0表示正数，1表示负数。

2) 如果是正数，正常表示(即原码)，如果是负数，先求反码，再求补码（补码为反码加1）即为他的二进制表示。例如char型的1，用二进制表示为00000001；char型的-1用二进制表示为11111111。

常量，就是在程序运行过程中值无法被改变；变量，就是在程序运行过程中内部存储的值随时可以被改变。变量是“可读、可写”，而常量，是“只读”的。

整形常量：12、浮点型常量：12.35、实数型常量：1.3e-5、字符型常量：'a'、字符串型常量："abc"、标识符常量：#define LEN 10。

变量一般存放在内存中：栈区， 静态数据区，全局变量区， 堆区。函数中定义的变量，如果不加特殊修饰，都是保存在栈区，函数调用结束，栈空间被自动释放。

定义变量：

<存储类型> <数据类型> <变量名>

static/auto/... int/char a

例如：static int a；char c；

存储类型：

自动类型转换

将一种类型的数据赋值给另外一种类型的变量时就会发生自动类型转换，例如：float a = 10；10是int类型的数据，需要先转换成float类型然后再赋值给变量a。

在不同类型的混合运算中，编译器也会自动地转换数据类型，将参与运算的所有数据先转换为同一种类型，然后再进行计算。转换的规则如下：

强制类型转换

自动类型转换是编译器根据代码自己判断的，有时候我们需要手动的进行数据类型转换，称之为强制类型转换，例如：

(int)(a+b); //将a + b 求得结果的数据类型强制转换为int型。

运算符的优先级

特殊运算符>单目运算符>双目运算符>三目运算>赋值运算>逗号运算

『陆』 c语言位运算问题

c语言位运算问题解答：

要解答这个问题我们先来看一个例子，代码如下图一，图中右边是问题中得到代码，左边是这段代码的汇编指令。两种情况的不同点详细说明如下：

第一种情况：

printf("%d",2>>64);

由图中的汇编代码可以看出，如果两个数都是常数的情况下，代码中是不含对应的汇编指令的，因为编译器已经省略了，编译器算出结果为0，直接把0传入给printf函数。

第二种情况：

int i=2;

printf("%d",i>>64);

此时i是个变量，编译器没法在编译时算出结果，这时就需要通过SARL算术右移指令进行，这里考虑到溢出这个指令有一个调整机制，它会根据左操作数i类型来调整右操作数，比如这里i是4字节32位，也就是它最多右移32位，如果右操作数大于32它会进行64%32=0，所以i>>64相当于i>>0，如果是i>>63，63%32=31相当于i>>31。这种调整不同的编译器可能会不同，目前GCC是这样的。

所以这个代码在GCC环境下输出结果为：

0

2

补充说明：如果想要了解更多可以写出代码，然后观察编译出来的汇编代码。

gcc -S test.c

图一

『柒』 求高手解答：Windows和Linux下运行C代码运算，在速度上有什么不同么

我觉得会有影响吧。
windows在启动时会启动很多程序，占用系统资源。有很多程序和进程是不可控的。
也就是你必须要添加的。

而linux的运行是可控的，你可以使用系统启动时，负载很小，把更多的资源分配给你所要使用
的应用程序。这样一比，在处理速度上，你说谁更快。

『捌』 Linux C编程从初学到精通的目 录

第1部分 基础篇
第1章 Linux系统概述 1
1.1 什么是Linux 2
1.2 Linux系统特点及主要功能 2
1.2.1 Linux系统特点 3
1.2.2 Linux系统的主要功能 3
1.3 Linux的内核版本和发行版本 5
1.4 系统的安装 6
1.4.1 系统安装前的准备工作 6
1.4.2 从光盘安装Linux 6
1.4.3 从硬盘安装Linux 22
1.4.4 在虚拟机下安装Linux 22
1.5 Shell的使用 27
1.5.1 Shell简介 27
1.5.2 常见Shell的种类 28
1.5.3 Shell的简单使用 29
1.5.4 通配符 30
1.5.5 引号 31
1.5.6 注释符 33
1.6 Linux常用命令 33
1.6.1 与目录相关的命令 33
1.6.2 与文件相关的命令 34
1.6.3 与网络服务相关的命令 35
1.7 本章小结 35
实战演练 36
第2章 C语言编程基础 37
2.1 C语言的历史背景 38
2.2 C语言的特点 38
2.3 C语言的基本数据类型 39
2.3.1 整型 39
2.3.2 实型 40
2.3.3 字符型 41
2.4 运算符与表达式 43
2.4.1 算术运算符与算术表达式 43
2.4.2 赋值运算符与赋值表达式 44
2.4.3 逗号运算符与逗号表达式 45
2.5 C程序的3种基本结构 46
2.5.1 顺序结构 46
2.5.2 选择结构 47
2.5.3 循环结构 51
2.6 C语言中的数据输入与输出 54
2.6.1 字符输出函数putchar 54
2.6.2 字符输入函数getchar 54
2.6.3 格式输出函数printf 54
2.6.4 格式输入函数scanf 56
2.7 函数 57
2.7.1 函数的定义 57
2.7.2 函数的调用 58
2.7.3 变量的存储类别 59
2.8 数组 62
2.8.1 一维数组的定义和使用 63
2.8.2 二维数组的定义和使用 64
2.8.3 字符数组和字符串 65
2.8.4 常用字符串处理函数 66
2.9 指针 69
2.9.1 地址和指针 69
2.9.2 指针的定义和使用 70
2.9.3 数组与指针 71
2.9.4 字符串与指针 72
2.9.5 指向函数的指针 72
2.10 结构体和共用体 73
2.10.1 定义和引用结构体 73
2.10.2 结构体数组 74
2.10.3 指向结构体的指针 74
2.10.4 共用体 75
2.10.5 使用typedef定义类型 77
2.11 链表 77
2.11.1 链表概述 77
2.11.2 建立动态单向链表 78
2.11.3 单向链表的输出 80
2.11.4 对单向链表的删除操作 80
2.11.5 对单向链表的插入操作 81
2.11.6 循环链表 82
2.11.7 双向链表 82
2.12 位运算符和位运算 83
2.12.1 “按位与”运算符（&） 84
2.12.2 “按位或”运算符（|） 84
2.12.3 “取反”运算符（~） 84
2.12.4 “异或”运算符（^） 84
2.12.5 移位运算符（<<和>>） 85
2.12.6 位域 85
2.13 C语言预处理命令 86
2.13.1 宏定义 86
2.13.2 文件包含 87
2.13.3 条件编译 88
2.13.4 #error等其他常用预处理命令 89
2.14 本章小结 89
实战演练 89
第3章 vi与Emacs编辑器 91
3.1 vi的使用 92
3.1.1 启动与退出vi 92
3.1.2 vi的命令行模式 93
3.1.3 vi的插入模式 96
3.1.4 vi的底行模式 96
3.2 vi使用实例 97
3.3 Emacs的使用 100
3.3.1 启动与退出Emacs 101
3.3.2 Emacs下的基本操作 102
3.4 Emacs使用实例 107
3.5 本章小结 109
实战演练 109
第4章 gcc编译器与gdb调试器 110
4.1 gcc编译器简介 111
4.2 如何使用gcc 112
4.2.1 gcc编译初步 112
4.2.2 警告提示功能 114
4.2.3 优化gcc 116
4.2.4 连接库 119
4.2.5 同时编译多个源程序 120
4.2.6 管道 120
4.2.7 调试选项 121
4.3 gdb调试器 122
4.3.1 gdb简介 122
4.3.2 gdb常用命令 123
4.3.3 gdb调试初步 124
4.4 gdb的使用详解 126
4.4.1 调用gdb 127
4.4.2 使用断点 127
4.4.3 查看运行时数据 129
4.4.4 查看源程序 133
4.4.5 改变程序的执行 135
4.5 xxgdb调试器简介 138
4.6 本章小结 139
实战演练 139
第5章 make的使用和Makefile的编写 141
5.1 什么是make 142
5.1.1 make机制概述 142
5.1.2 make与Makefile的关系 144
5.2 Makefile的书写规则 147
5.2.1 Makefile的基本语法规则 148
5.2.2 在规则中使用通配符 149
5.2.3 伪目标 149
5.2.4 多目标 151
5.2.5 自动生成依赖性 151
5.3 Makefile的命令 152
5.4 变量 154
5.4.1 变量的基础 154
5.4.2 赋值变量 154
5.4.3 define关键字 156
5.4.4 override指示符 156
5.4.5 目标变量和模式变量 157
5.5 常用函数调用 158
5.5.1 字符串处理函数 158
5.5.2 文件名操作函数 162
5.5.3 循环函数 164
5.5.4 条件判断函数 165
5.5.5 其他常用函数 166
5.6 隐式规则 168
5.6.1 隐式规则举例 168
5.6.2 隐式规则中的变量 169
5.6.3 使用模式规则 170
5.7 本章小结 173
实战演练 173
第2部分 提高篇
第6章 文件I/O操作 174
6.1 Linux文件系统简介 175
6.1.1 Linux的文件系统结构 175
6.1.2 文件类型 176
6.1.3 文件访问权限 179
6.2 基于文件描述符的I/O操作 179
6.2.1 文件描述符 180
6.2.2 标准输入、标准输出和标准出错 180
6.2.3 文件重定向 181
6.2.4 文件的创建、打开与关闭 182
6.2.5 文件的定位 186
6.2.6 文件的读写 188
6.3 文件的属性操作 192
6.3.1 改变文件访问权限 192
6.3.2 改变文件所有者 193
6.3.3 重命名 193
6.3.4 修改文件长度 194
6.4 文件的其他操作 195
6.4.1 stat、fstat和lstat函数 195
6.4.2 p和p2函数 196
6.4.3 fcntl函数 197
6.4.4 sync和fsync函数 197
6.5 特殊文件的操作 198
6.5.1 目录文件的操作 198
6.5.2 链接文件的操作 201
6.5.3 管道文件的操作 204
6.5.4 设备文件 204
6.6 本章小结 205
实战演练 205
第7章 基于流的I/O操作 206
7.1 流与缓存 207
7.1.1 流和FILE对象 207
7.1.2 标准输入、标准输出和标准出错 207
7.1.3 缓存 207
7.1.4 对缓存的操作 210
7.2 流的打开与关闭 212
7.2.1 流的打开 212
7.2.2 流的关闭 214
7.2.3 流关闭前的工作 216
7.3 流的读写 216
7.3.1 基于字符的I/O 217
7.3.2 基于行的I/O 220
7.3.3 直接I/O 222
7.3.4 格式化I/O 224
7.4 本章小结 226
实战演练 227
第8章 进程控制 228
8.1 进程的基本概念 229
8.1.1 Linux进程简介 229
8.1.2 进程与作业 230
8.1.3 进程标识 230
8.2 进程控制的相关函数 232
8.2.1 fork和vfork函数 232
8.2.2 exec函数 237
8.2.3 exit和_exit函数 242
8.2.4 wait和waitpid函数 245
8.2.5 进程的一生 251
8.2.6 用户ID和组ID 251
8.2.7 system函数 253
8.3 多个进程间的关系 255
8.3.1 进程组 255
8.3.2 会话期 256
8.3.3 控制终端 257
8.4 本章小结 259
实战演练 259
第9章 信号 260
9.1 Linux信号简介 261
9.1.1 信号的基本概念 261
9.1.2 信号处理机制 265
9.2 信号操作的相关函数 267
9.2.1 信号的处理 267
9.2.2 信号的发送 274
9.2.3 信号的阻塞 282
9.2.4 计时器与信号 284
9.3 本章小结 286
实战演练 287
第10章 进程间通信 288
10.1 进程间通信简介 289
10.2 管道 290
10.2.1 管道的概念 290
10.2.2 管道的创建与关闭 291
10.2.3 管道的读写 292
10.3 命名管道 297
10.3.1 命名管道的概念 297
10.3.2 命名管道的创建 297
10.3.3 命名管道的读写 299
10.4 消息队列 303
10.4.1 消息队列的概念 303
10.4.2 消息队列的创建与打开 305
10.4.3 消息队列的读写 306
10.4.4 获得或设置消息队列属性 308
10.5 共享内存 312
10.5.1 共享内存的概念 312
10.5.2 共享内存的相关操作 313
10.6 信号量 318
10.6.1 信号量的概念 319
10.6.2 信号量集的相关操作 320
10.7 本章小结 325
实战演练 326
第11章 网络编程 327
11.1 网络编程的基础知识 328
11.1.1 计算机网络体系结构 328
11.1.2 传输控制协议TCP 333
11.1.3 用户数据报协议UDP 335
11.1.4 客户机/服务器模式 336
11.2 套接口编程基础 336
11.2.1 什么是套接口 337
11.2.2 端口号的概念 338
11.2.3 套接口的数据结构 338
11.2.4 基本函数 340
11.3 TCP套接口编程 343
11.3.1 TCP套接口通信工作流程 343
11.3.2 TCP套接口Client/Server程序实例 356
11.4 UDP套接口编程 360
11.4.1 UDP套接口通信工作流程 360
11.4.2 UDP套接口Client/Server程序实例 362
11.5 原始套接口编程 365
11.5.1 原始套接口的创建 365
11.5.2 原始套接口程序实例 365
11.6 本章小结 376
实战演练 376
第12章 Linux图形界面编程 377
12.1 Linux下的图形界面编程简介 378
12.1.1 Qt简介 378
12.1.2 GTK+简介 378
12.2 界面基本元件 381
12.2.1 一个简单的例子 381
12.2.2 窗口 383
12.2.3 标签 385
12.2.4 按钮 386
12.2.5 文本框 387
12.3 界面布局元件 389
12.3.1 表格 390
12.3.2 框 393
12.3.3 窗格 395
12.4 其他常用元件 398
12.4.1 进度条、微调按钮、组合框 398
12.4.2 单选按钮、复选按钮 402
12.4.3 下拉菜单 404
12.5 信号与回调函数 406
12.6 本章小结 409
实战演练 409
第3部分 实战篇
第13章 设计Linux下的计算器 411
13.1 软件功能分析 412
13.2 程序模块的划分 413
13.3 软件的具体实现 415
13.3.1 头文件 415
13.3.2 十六进制界面显示函数 416
13.3.3 十进制界面显示函数 417
13.3.4 八进制界面显示函数 418
13.3.5 二进制界面显示函数 419
13.3.6 进制间转换函数 420
13.3.7 信号处理模块 423
13.3.8 主函数 432
13.4 软件使用效果演示 438
13.5 本章小结 439
第14章 Linux平台下聊天软件的设计 440
14.1 软件功能概述 441
14.1.1 服务器端功能需求 441
14.1.2 客户端功能需求 442
14.1.3 错误处理需求 442
14.2 Glade集成开发工具简介 443
14.3 软件功能模块划分 444
14.3.1 服务器功能模块划分 444
14.3.2 客户端功能模块划分 445
14.3.3 消息标识的定义 445
14.3.4 消息结构体的设计 446
14.4 服务器程序的具体实现 447
14.4.1 服务器消息处理流程 447
14.4.2 服务器主要函数和变量 448
14.4.3 服务器消息处理模块的设计与实现 449
14.4.4 服务器数据存储的方法 450
14.4.5 用户注册流程 450
14.5 客户端程序的具体实现 451
14.5.1 客户端操作流程 451
14.5.2 客户端发送和接收消息流程 451
14.5.3 客户端主要函数和变量 452
14.5.4 客户端功能模块的设计与实现 453
14.6 聊天软件使用效果演示 455
14.7 本章小结 459
第15章 Linux远程管理工具的设计 460
15.1 软件功能概述 461
15.1.1 Webmin简介 461
15.1.2 软件总体设计 461
15.2 服务器端程序设计 463
15.2.1 服务器端工作流程 463
15.2.2 系统用户管理操作 464
15.2.3 系统用户组的管理操作 466
15.2.4 系统服务启动管理 468
15.2.5 DNS管理操作 469
15.2.6 Apache服务管理操作 471
15.2.7 FTP服务管理操作 474
15.3 客户端程序 475
15.3.1 连接界面 475
15.3.2 主界面 477
15.4 本章小结 479
第16章 Linux下简易防火墙软件的设计 480
16.1 Netfilter基础 481
16.1.1 什么是Netfilter 481
16.1.2 Netfilter的HOOK机制 482
16.1.3 HOOK的调用 485
16.1.4 HOOK的实现 486
16.1.5 IPTables简介 488
16.1.6 Netfilter可以实现的控制功能 489
16.2 软件设计概述 491
16.2.1 软件整体框架 491
16.2.2 管理端的设计 492
16.2.3 控制端的设计 493
16.3 用Netfilter设计控制端功能模块 495
16.3.1 ICMP管理控制模块 495
16.3.2 FTP管理控制模块 497
16.3.3 HTTP管理控制模块 499
16.3.4 模块的编译、加载与卸载 499
16.4 软件功能测试 501
16.5 本章小结 503
第17章 基于Linux的嵌入式家庭网关远程交互操作平台的设计 504
17.1 嵌入式技术简介 505
17.1.1 嵌入式系统的概念 505
17.1.2 嵌入式操作系统 506
17.1.3 嵌入式处理器 507
17.2 家庭网关的概念及其网络体系结构 509
17.2.1 智能家庭网络的概念 509
17.2.2 家庭网关的远程交互操作技术简介 510
17.2.3 嵌入式家庭网关的网络体系结构 510
17.3 嵌入式家庭网关的开发平台 511
17.3.1 S3C2410微处理器简介 511
17.3.2 交叉编译环境的建立 513
17.4 远程交互平台的设计 515
17.4.1 应用软件的开发模式 515
17.4.2 嵌入式Web服务器 516
17.4.3 通用网关接口CGI 519
17.5 Linux下软件模块的具体实现 520
17.5.1 登录验证模块 521
17.5.2 串口通信模块 521
17.5.3 中央空调控制模块 522
17.5.4 智能水表数据采集模块 528
17.5.5 试验结果 528
17.6 本章小结 529

『玖』 LinuxC编程一站式学习的前 言

本书最初是为北京亚嵌教育研究中心的嵌入式Linux系统工程师就业班课程量身定做的教材之一。该课程是为期四个月的全日制职业培训，要求学员毕业时具备非常Solid的C语言编程能力，能熟练地使用Linux系统，同时对计算机体系结构与指令集、操作系统原理和设备驱动程序都有比较深入的了解。然而学员入学时的水平是非常初级而且参差不齐的：学历有专科、本科也有研究生；专业有和计算机相关的，也有很不相关的（例如会计专业）；以前从事的职业有和技术相关的也有完全不相关的（例如HR）；年龄从二十岁出头到三十五六岁的都有。这么多背景、基础、思维习惯和理解能力完全不同的人来听同一堂课，大家都迫切希望学会嵌入式开发技术，投身IT行业，这就是职业教育的特点，也是我编写本书时需要考虑的主要问题。
学习编程绝不是一件简单的事，尤其是对于零基础的初学者来说。大学的计算机专业有四年时间从零基础开始培养一个人，微积分、线性代数、概率论、离散数学、组合数学、自动机、编译原理、操作系统、计算机组成原理等一堆基础课，再加上C/C++、Java、数据库、网络工程、软件工程、计算机图形学等一堆专业课，最后培养出一个能找到工作的学生。很遗憾这最后一条很多学校没有做好，据我们考查，来亚嵌培训的很多学生基础几乎为零，我不知道为什么。与之形成鲜明对比的是，只给我们四个月的时间，同样要求从零基础开始，最后培养出一个能找到工作的学生，而且还要保证他找到好工作，这就是职业教育的特点。
为什么我说“只给我们四个月的时间”？我们倒是想教四年呢，但学时的长短我们做不了主，是由市场规律决定的。四年的任务要求四个月做好，要怎么完成这样一个几乎不可能的任务呢？有些职业教育给出的答案是“实用主义”，打出了“有用就学，没有用就不学”的口号，大肆贬低说大学里教的基础课都是过时的、无用的，只有他们教的技术才是实用的。这种炒作很不好，我认为大学里教的每一门课都是非常有用的，基础知识在任何时候都不会过时，倒是那些时髦的“实用技术”有可能很快就会过时了。
四年的任务怎么才能用四个月做好？我们给出的答案是“优化”。现在大学里安排的课程体系最大的缺点就是根本不考虑优化。每个过来人都会有这样的感觉：大一大二学了好多数学课，却不知道都是干什么用的，不明白为什么要学。连它有什么用都不知道怎么能有兴趣学好呢？到大三大四学专业课时，用到以前的知识了，才发现以前学的数学是多么有用，然而早就忘得一干二净了，考完试都还给老师了。回头重新学，才发现很多东西以前根本没学明白，现在真的学明白了，那么前两年的时间岂不是都浪费了？大学里的课程体系还有一个缺点就是不灵活，每门课必须占用一个学期，必须由一个老师教，不同课程的老师之间没有任何沟通和衔接，其实这些课程之间是相互依赖的，把它们强行拆开是不符合人的认知规律的。比如我刚上大学的时候，大一上半学期就被逼着学习C语言，其实C语言是一门很难的编程语言，不懂编译原理、操作系统和计算机体系结构根本不可能学明白，那半个学期自然就浪费掉了。当时几乎所有学校的计算机相关专业都是这样，大一刚来就学C语言，有的学校更疯狂，上来就学C++，导致大多数学生都以为自己会C语言，但其实都是半吊子水平，到真正写代码的时候经常为一个Bug搞得焦头烂额，却没有机会再系统地学一遍C语言。因为在学校看来，C语言早在大一就给你“上完了”，就像一顿饭已经吃完了，不管你吃饱没吃饱，不会再让你重吃一遍了。显而易见，如果要认真地对这些课程进行优化，的确是有很多水分可以挤的。
本书有什么特点
 本书不是孤立地讲C语言，而是和编译原理、操作系统、计算机体系结构结合起来讲。或者说，本书的内容只是以C语言为载体，真正讲的是计算机和程序的原理。
 强调基本概念和基本原理，在编排顺序上重视概念之间的依赖关系，每次引入一个新的概念，只依赖于前面章节已经讲过的概念，而绝不会依赖于后面章节要讲的概念。有些地方为了叙述得完整，也会引用后面要讲的内容，比如说“有关××我们到第×章再仔细讲解”，凡是这种引用都不是必要的依赖，可以当它不存在，只管继续往下学习就行了。
 尽量做到每个知识点直到要用的时候才引入。过早引入一个知识点，讲完了又不用它，读者很快就会遗忘，这是不符合认知规律的。
本书面向什么样的读者
这是一本从零基础开始学习编程的书，不要求读者有任何编程经验，但读者至少需要具备以下素质：
 熟悉Linux系统的基本操作。如果不具备这一点，请先参考其他教材学习相关知识，熟练之后再学习本书，《鸟哥的Linux私房菜》据说是Linux系统管理和应用方面比较好的一本书。但学习本书并不需要会很多系统管理技术，只要会用基本命令、会自己安装系统和软件包就足够了。
 具有高中毕业的数学水平。本书会用到高中的数学知识。事实上，如果不具有高中毕业的数学水平，也不必考虑做程序员了。但并不是说只要具有高中毕业的数学水平就足够做程序员了，只能说看这本书应该没有问题，数学是程序员最重要的修养，计算机科学其实就是数学的一个分支，如果你的数学功底很差，日后还需要恶补一下。
 具有高中毕业的英文水平。理由同上。
 对计算机的原理和本质深感兴趣，不是为就业而学习，不是为拿高薪而学习，而是真的感兴趣，想把一切来龙去脉搞得清清楚楚而学习。
 勤于思考。本书尽最大努力理清概念之间的依赖关系，力求一站式学习，读者不需要为了找一个概念的定义去翻阅其他书籍，也不需要为了搞清楚一个概念在本书中乱翻一通，只需要从前到后按顺序学习即可。但一站式学习并不等于傻瓜式学习，有些章节有一定的难度，需要读者积极思考才能领会。本书可以替你节省时间，但不能替你思考，不要指望像看小说一样走马观花看一遍就能学会。
为什么要学这本书而不是K&R
《The C Programming Language》（后文简称[K&R]）是公认的世界上最经典的C语言教程之一，这点毫无疑问。在C标准出台之前，K&R第一版就是事实上的C标准。C89标准出台之后，K&R跟着推出了第二版，可惜此后就没有更新过了，所以不能反映C89之后C语言的发展以及最新的C99标准。本书在这方面做了很多补充。本书与其说是讲C语言，不如说是以C语言为载体讲计算机和操作系统的原理，而K&R只是为了讲C语言而讲C语言，侧重点不同，内容编排也很不相同。K&R写得非常好，代码和语言都非常简洁，但很可惜，只有会C语言的人才懂得欣赏它，K&R是非常不适合入门学习的，尤其不适合零基础的学生学习。
本书“是什么”和“不是什么”
本书包括两大部分：
 C语言入门。介绍基本的C语法，帮助没有任何编程经验的读者理解什么是程序以及怎么写程序，培养程序员的思维习惯，找到编程的感觉。前半部分改编自《How To Think Like A Computer Scientist: Learning with C++》（后文简称[ThinkCpp]）。
 C语言本质。结合计算机和操作系统的原理讲解C程序是怎么编译、链接、运行的，同时全面介绍C的语法。位运算的章节改编自林小竹老师的讲义；链表和二叉树的章节改编自朱仲涛老师的讲义；汇编语言的章节改编自《Programming from the Ground Up: An Introction to Programming using Linux Assembly Language》（后文简称[GroundUp]），在该书的最后一章中提到，学习编程有两种Approach，一种是“Bottom Up”，一种是“Top Down”，它们各有优缺点，而我们需要将两者结合起来。所以我编写本书的思路是：第一部分Top Down；第二部分Bottom Up；第三部分可以算填补了中间的空隙，三部分全都围绕C语言展开。
这本书定位在入门级，虽然内容很多，但不是一本网络全书，除了C语言的基础知识要讲透之外其他内容都不深入，书中列出了很多参考资料，是读者进一步学习的起点。[K&R]的第1章是一个Whirlwind Tour，把全书的内容简单概括了一遍，然后再逐个深入讲解。本书也可以看作是计算机专业课程体系的一个Whirlwind Tour，学习完本书之后读者有了一个全局观，再去学习那些参考资料就应该很容易上手了。
为什么要在Linux平台上学C语言？
用Windows学C语言不好吗？
用Windows还真的是学不好C语言。C语言是一种面向底层的编程语言，要写好C程序，必须对操作系统的工作原理非常清楚，因为操作系统也是用C语言编写的，我们用C语言编写应用程序可以直接使用操作系统提供的接口。既然你选择了本书，你一定了解：Linux是一种开源的操作系统，你有任何疑问都可以从源代码和文档中找到答案，即使你看不懂源代码，也找不到文档，也很容易找个高手教你，各种邮件列表、新闻组和论坛上从来都不缺乐于助人的高手；而Windows是一种封闭的操作系统，除了微软的员工别人都看不到它的源代码，只能通过文档去猜测它的工作原理。更糟糕的是，微软向来喜欢藏着掖着，好用的功能留着自己用，而不会写到文档里公开。本书的第一部分在Linux或Windows平台上学习都可以，但第二部分和第三部分介绍了很多Linux操作系统的原理以帮助读者更深入地理解C语言，所以后两部分只能在Linux平台上学习。
Windows平台上的开发工具往往和各种集成开发环境（Integrated Development Environment，IDE）绑在一起，例如Visual Studio、Eclipse等。使用IDE确实很便捷，但IDE对于初学者绝对不是好东西。微软喜欢宣扬傻瓜式编程的理念，告诉你用鼠标拖几个控件，然后单击一个按钮就可以编译出程序来，但是真正有用的程序有哪个是这么拖出来的？很多从Windows平台入门学编程的人，编了好几年程序，还是只知道编完程序单击一个按钮就完事了，把几个源文件拖到一个项目里就可以编译到一起了，如果有更复杂的需求他们就傻眼了，因为他们脑子里只有按钮、菜单的概念，根本没有编译器、链接器、Makefile的概念，甚至连命令行都没用过，然而这些都是初学编程就应该建立起来的基本概念。另一方面，编译器、链接器和C语言的语法有着密切的关系，不了解编译器、链接器的工作原理，也不可能真正掌握C语言的语法。所以，IDE并没有帮助你学习，而是阻碍了你的学习，本来要学好C编程只要把语法和编译命令学会就行了，现在有了IDE，除了学会语法和编译命令，你还得弄清楚编译命令和IDE是怎么集成的，这才算学明白了，本来就很复杂的学习任务被IDE搞得更加复杂了。Linux用户的使用习惯从来都是以敲命令为主，以鼠标操作为辅，从学编程的第一天起就要敲命令编译程序，等到你把这些基本概念都搞清楚了，你觉得哪个IDE好用你再去用，不过到那时候你可能会更喜欢vi或emacs而不是IDE了。
体例说明
像The quick brown fox jumps over the lazy dog这样的字体在本书中是代码字体。这种字体的名称是Dejavu Sans Mono，为什么我要提倡用这种字体呢？第一，它是等宽字体，因此适合做代码字体。第二，它的1和l、0和O区分得非常清楚（我在教学中发现初学者很容易把这些字符抄错），因此它比Courier New更适合做代码字体。第三， 它是我的Linux图形终端的默认字体，采用这种字体排版可以使得看书和看屏幕的感觉很一致，希望读者在看这本书时也会有这种Dejavu（似曾相识）的感觉。
像下面这样有边线的是代码：
#! /bin/sh
VAR=1
VAR=$(($VAR+1))
echo $VAR
没有边线的是终端显示，包括输入的命令和程序运行结果，例如：
$ VAR=1
$ VAR=$(($VAR+1))
$ echo $VAR
2
本书中统一用$表示Shell提示符。
加粗的字句表示强调。
在定义一个名词时会给出它的英文名称，例如集成开发环境（Integrated Development Environment，IDE），通过书后的索引可以找到这些定义在书中首次出现的位置。
致谢
本书的写作得到了北京亚嵌教育研究中心的全力支持，尤其感谢李明老师和何家胜老师。没有公司的支持，我不可能有时间有条件写这本书，也不可能有机会将这本书公开在网上。
然后要感谢亚嵌教育的历届学员和各位老师，在教学和讨论的过程中我经常会得到有益的启发，这些都促使本书更加完善。在本书的写作过程中，很多读者为本书提出了很有价值的建议，很多建议是热心网友通过在线评论提出的，有些网友我只知道ID或E-mail。在此向他们表示感谢。
感谢帮助过我的老师们：李明、何家胜、邸海霞、郎铁山、朱仲涛、廖文江、韩超、秦蔚、吴岳、张 、邢文鹏、何晓龙、林小竹、卫剑钒、郭同彬、王波、王磊。
感谢热心网友：ddd、wuyulei、commapopo、田伟、田雨、daidai、邓楠、杜朴风、Zoom.Quiet、陈莉君老师、杨景、章钰、chen、Jiawei Zhang、waterloo、张现超、曾宇、董俊波、RobinXiang、刘艳明、been2100、cleverd、juicerococo、徐斌、cyy、Linux_Xfce、冯海云、侯延祥、churchmice、codycody23、syfeagle、王公仆、刘敏、Laciq、yuchen、陆杨、陈杨希、love_wc3、姚磊、芝麻、wadenx、沈震、sunbingfly、mick、baaluck、曹帅军、zhoudy、朱夜光、刺猬、leezhenfeng、王兆宏、徐凯、码匠、况海斌、尹志伟、王星。
还要感谢电子工业出版社博文视点资讯有限公司的周筠老师和李冰老师的大力支持，感谢江立编辑严谨细致的工作。
在写作过程中我遇到过很多困难：工作繁忙、对未来迷茫、生活压力大、缺乏安全感、个人琐事等。然而有这么多热心的同学、老师、朋友、网友在等着阅读我的书在线更新的内容，给我提建议，希望我把书改得更完善，这是我坚持写下去的最大动力。谢谢你们！
由于作者水平十分有限，没写过C编译器和C标准库，所以疏漏之处在所难免，如有错误欢迎广大读者朋友批评指正。写书是一件严肃的事，书中的错误所有人都看得见，白纸黑字赖不掉的。我教过的很多学生都在大学里学过C语言，甚至考过二级，但程序写得一塌糊涂，连最基本的概念都搞错了，以前学过的C语言教材中的错误在他们脑子里根深蒂固，即使我纠正多次，他们仍然只记得以前学过的错误概念。这种有基础的学生还不如没有任何基础的学生教起来容易。我非常害怕我教给别人的知识也是错的，所以我仔细研究了C99之后才敢动笔写书。这本书涵盖的话题比较广泛，我竭尽全力也不足以保证书中的内容全部正确，还要依靠社区的力量一起来完善这本书，这样才能真正对读者负责，所以我选择将这本书开源。。
希望本书能成为你求学道路上的第一个伙伴。
宋劲杉
2009年7月22日

『拾』 LinuxC编程一站式学习的目 录

上篇 C语言入门
第1章 程序的基本概念 2
1.1 程序和编程语言 2
1.2 自然语言和形式语言 6
1.3 程序的调试 7
1.4 第一个程序 9
第2章 常量、变量和表达式 12
2.1 继续Hello World 12
2.2 常量 15
2.3 变量 16
2.4 赋值 18
2.5 表达式 19
2.6 字符类型与字符编码 23
第3章 简单函数 24
3.1 数学函数 24
3.2 自定义函数 26
3.3 形参和实参 31
3.4 全局变量、局部变量和作用域 35
第4章 分支语句 41
4.1 if语句 41
4.2 if/else语句 43
4.3 布尔代数 45
4.4 switch语句 49
第5章 深入理解函数 51
5.1 return语句 51
5.2 增量式开发 54
5.3 递归 58
第6章 循环语句 64
6.1 while语句 64
6.2 do/while语句 66
6.3 for语句 67
6.4 break和continue语句 69
6.5 嵌套循环 70
6.6 goto语句和标号 71
第7章 结构体 74
7.1 复合类型与结构体 74
7.2 数据抽象 78
7.3 数据类型标志 82
7.4 嵌套结构体 84
第8章 数组 85
8.1 数组的基本概念 85
8.2 数组应用实例：统计随机数 88
8.3 数组应用实例：直方图 91
8.4 字符串 94
8.5 多维数组 95
第9章 编码风格 100
9.1 缩进和空白 100
9.2 注释 104
9.3 标识符命名 107
9.4 函数 108
9.5 indent工具 108
第10章 gdb 110
10.1 单步执行和跟踪函数调用 110
10.2 断点 117
10.3 观察点 121
10.4 段错误 125
第11章 排序与查找 128
11.1 算法的概念 128
11.2 插入排序 129
11.3 算法的时间复杂度分析 131
11.4 归并排序 133
11.5 线性查找 138
11.6 折半查找 139
第12章 栈与队列 144
12.1 数据结构的概念 144
12.2 堆栈 144
12.3 深度优先搜索 146
12.4 队列与广度优先搜索 152
12.5 环形队列 156
本阶段总结 159
下篇 C语言本质
第13章 计算机中数的表示 162
13.1 为什么计算机用二进制计数 162
13.2 不同进制之间的换算 164
13.3 整数的加减运算 165
13.3.1 Sign and Magnitude表示法 165
13.3.2 1's Complement表示法 166
13.3.3 2's Complement表示法 167
13.3.4 有符号数和无符号数 168
13.4 浮点数 169
第14章 数据类型详解 172
14.1 整型 172
14.2 浮点型 176
14.3 类型转换 177
14.3.1 Integer Promotion 177
14.3.2 Usual Arithmetic Conversion 178
14.3.3 由赋值产生的类型转换 179
14.3.4 强制类型转换 179
14.3.5 编译器如何处理类型转换 179
第15章 运算符详解 182
15.1 位运算 182
15.1.1 按位与、或、异或、取反运算 182
15.1.2 移位运算 183
15.1.3 掩码 184
15.1.4 异或运算的一些特性 185
15.2 其他运算符 186
15.2.1 复合赋值运算符 186
15.2.2 条件运算符 186
15.2.3 逗号运算符 187
15.2.4 sizeof运算符与typedef类型声明 187
15.3 Side Effect与Sequence Point 189
15.4 运算符总结 191
第16章 计算机体系结构基础 193
16.1 内存与地址 193
16.2 CPU 193
16.3 设备 196
16.4 MMU 198
16.5 Memory Hierarchy 201
第17章 x86汇编程序基础 205
17.1 最简单的汇编程序 205
17.2 x86的寄存器 208
17.3 第二个汇编程序 209
17.4 寻址方式 211
17.5 ELF文件 212
17.5.1 目标文件 213
17.5.2 可执行文件 218
第18章 汇编与C之间的关系 224
18.1 函数调用 224
18.2 main函数、启动例程和退出状态 230
18.3 变量的存储布局 237
18.4 结构体和联合体 244
18.5 C内联汇编 248
18.6 volatile限定符 250
第19章 链接详解 255
19.1 多目标文件的链接 255
19.2 定义和声明 260
19.2.1 extern和static关键字 260
19.2.2 头文件 264
19.2.3 定义和声明的详细规则 268
19.3 静态库 271
19.4 共享库 274
19.4.1 编译、链接、运行 274
19.4.2 函数的动态链接过程 281
19.4.3 共享库的命名惯例 282
19.5 虚拟内存管理 284
第20章 预处理 290
20.1 预处理的步骤 290
20.2 宏定义 291
20.2.1 函数式宏定义 291
20.2.2 内联函数 294
20.2.3 #、##运算符和可变参数 296
20.2.4 #undef预处理指示 298
20.2.5 宏展开的步骤 299
20.3 条件预处理指示 300
20.4 其他预处理特性 303
第21章 Makefile基础 306
21.1 基本规则 306
21.2 隐含规则和模式规则 313
21.3 变量 317
21.4 自动处理头文件的依赖关系 321
21.5 常用的make命令行选项 324
第22章 指针 327
22.1 指针的基本概念 327
22.2 指针类型的参数和返回值 331
22.3 指针与数组 332
22.4 指针与const限定符 335
22.5 指针与结构体 337
22.6 指向指针的指针与指针数组 337
22.7 指向数组的指针与多维数组 340
22.8 函数类型和函数指针类型 341
22.9 不完全类型和复杂声明 344
第23章 函数接口 349
23.1 本章的预备知识 349
23.1.1 strcpy与strncpy 349
23.1.2 malloc与free 354
23.2 传入参数与传出参数 358
23.3 两层指针的参数 360
23.4 返回值是指针的情况 362
23.5 回调函数 365
23.6 可变参数 368
第24章 C标准库 372
24.1 字符串操作函数 373
24.1.1 给字符串赋初值 373
24.1.2 取字符串的长度 374
24.1.3 拷贝字符串 375
24.1.4 连接字符串 377
24.1.5 比较字符串 378
24.1.6 搜索字符串 379
24.1.7 分割字符串 380
24.2 标准I/O库函数 383
24.2.1 文件的基本概念 383
24.2.2 fopen/fclose 384
24.2.3 stdin/stdout/stderr 387
24.2.4 errno与perror/strerror函数 388
24.2.5 以字节为单位的I/O函数 391
24.2.6 操作读写位置的函数 393
24.2.7 以字符串为单位的I/O函数 395
24.2.8 以记录为单位的I/O函数 397
24.2.9 格式化I/O函数 399
24.2.10 C标准库的I/O缓冲区 406
24.2.11 本节综合练习 410
24.3 数值字符串转换函数 412
24.4 分配内存的函数 414
第25章 链表、二叉树和哈希表 415
25.1 链表 415
25.1.1 单链表 415
25.1.2 双向链表 421
25.1.3 静态链表 425
25.1.4 本节综合练习 426
25.2 二叉树 426
25.2.1 二叉树的基本概念 426
25.2.2 排序二叉树 432
25.3 哈希表 437
本阶段总结 439
附录A 字符编码 442
索引 449
参考书目 474