关于小话C语言集合贴，C 语言常见问题集,c语言-优化C代码常用的几招，高效程序的秘密_hacker's delight读书笔记

落日映苍穹つ 2022-08-20 15:06 767阅读 0赞

1～4：  
前言----小话c语言(1)   
printf函数，能不能简单点？----小话c语言(2)   
scanf函数，想说输入不容易！----小话c语言(3)   
基本输入输出，基本但不简单----小话c语言(4)   
[http://tieba.baidu.com/p/1699650877][http_tieba.baidu.com_p_1699650877]  
  
5：  
预处理，果然是预处理----小话c语言(5)   
[http://tieba.baidu.com/p/1699671617][http_tieba.baidu.com_p_1699671617]  
  
6：  
数组，也就是数据块而已----小话c语言(6)  
[http://tieba.baidu.com/p/1699674924][http_tieba.baidu.com_p_1699674924]  
  
7：  
指针，自然而又危险----小话c语言(7)  
[http://tieba.baidu.com/p/1699677781][http_tieba.baidu.com_p_1699677781]  
  
8：  
运算符，一种特殊的标识符----小话c语言(8)  
[http://tieba.baidu.com/p/1699679658][http_tieba.baidu.com_p_1699679658]  
  
9：  
函数，它们的分工和人类的分工没什么不同----小话C语言(9)   
[http://tieba.baidu.com/p/1699689740][http_tieba.baidu.com_p_1699689740]  
  
10：  
递归，到处都是递归----小话c语言(10)  
[http://tieba.baidu.com/p/1699695288][http_tieba.baidu.com_p_1699695288]  
  
11：  
结构体，面向对象的基础----小话c语言(11)  
[http://tieba.baidu.com/p/1699696963][http_tieba.baidu.com_p_1699696963]  
  
12：  
异常处理，保证代码稳定的必经之步----小话c语言(12)

[http://tieba.baidu.com/p/1699700204][http_tieba.baidu.com_p_1699700204]

# c语言-优化C代码常用的几招 #

**在性能优化方面永远注意80-20原则，即20%的程序消耗了80%的运行时间，因而我们要改进效率，最主要是考虑改进那20%的代码。不要优化程序中开销不大的那80%，这是劳而无功的。**

第一招：以空间换时间

计算机程序中最大的矛盾是空间和时间的矛盾，那么，从这个角度出发逆向思维来考虑程序的效率问题，我们就有了解决问题的第1招--以空间换时间。比如说字符串的赋值：

方法A：通常的办法

\#define LEN 32

char string1 \[LEN\];

memset (string1,0,LEN);

strcpy (string1,"This is a example!!"）;

方法B：

const char string2\[LEN\] ="This is a example!";

char \* cp;

cp = string2 ;

使用的时候可以直接用指针来操作。

从上面的例子可以看出，A和B的效率是不能比的。在同样的存储空间下，B直接使用指针就可以操作了，而A需要调用两个字符函数才能完成。B的缺点在于灵活性没有A好。在需要频繁更改一个字符串内容的时候，A具有更好的灵活性；如果采用方法B，则需要预存许多字符串，虽然占用了大量的内存，但是获得了程序执行的高效率。

如果系统的实时性要求很高，内存还有一些，那我推荐你使用该招数。

第二招： 使用宏而不是函数。

这也是第一招的变招。函数和宏的区别就在于，宏占用了大量的空间，而函数占用了时间。大家要知道的是，函数调用是要使用系统的栈来保存数据的，如果编译器里有栈检查选 项，一般在函数的头会嵌入一些汇编语句对当前栈进行检查；同时，CPU也要在函数调用时保存和恢复当前的现场，进行压栈和弹栈操作，所以，函数调用需要一 些CPU时间。 而宏不存在这个问题。宏仅仅作为预先写好的代码嵌入到当前程序，不会产生函数调用，所以仅仅是占用了空间，在频繁调用同一个宏的时候，该现象尤其突出。

举例如下：

方法C：

\#define bwMCDR2\_ADDRESS 4

\#define bsMCDR2\_ADDRESS 17

int BIT\_MASK(int \_\_bf)

return ((1U << (bw \#\# \_\_bf)) - 1)<< (bs \#\# \_\_bf);

void SET\_BITS(int \_\_dst,

int \_\_bf, int \_\_val)

\_\_dst = ((\_\_dst) & ~(BIT\_MASK(\_\_bf))) |

(((\_\_val) << (bs \#\# \_\_bf))

& (BIT\_MASK(\_\_bf))))

SET\_BITS(MCDR2, MCDR2\_ADDRESS,ReGISterNumber);

方法D：

\#define bwMCDR2\_ADDRESS 4

\#define bsMCDR2\_ADDRESS 17

\#define bmMCDR2\_ADDRESS BIT\_MASK(MCDR2\_ADDRESS)

\#define BIT\_MASK(\_\_bf)

(((1U << (bw \#\# \_\_bf)) - 1)

<< (bs \#\# \_\_bf))

\#define SET\_BITS(\_\_dst, \_\_bf, \_\_val)

((\_\_dst) = ((\_\_dst) & ~(BIT\_MASK(\_\_bf)))

(((\_\_val) << (bs \#\# \_\_bf))

& (BIT\_MASK(\_\_bf))))

SET\_BITS(MCDR2, MCDR2\_ADDRESS,

RegisterNumber);

D方法是我看到的最好的置位操作函数，是arm公司源码的一部分，在短短的三行内实现了很多功能，几乎涵盖了所有的位操作功能。C方法是其变体，其中滋味还需大家仔细体会。

第三招：数学方法解决问题

现在我们演绎高效C语言编写的第二招--采用数学方法来解决问题。数学是计算机之母，没有数学的依据和基础，就没有计算机的发展，所以在编写程序的时候，采用一些数学方法会对程序的执行效率有数量级的提高。举例如下，求 1~100的和。

方法E：

int I , j;

for (I = 1 ;I<=100; I ++）

j += I;

方法F

int I;

I = (100 \* (1+100)) / 2

这个例子是我印象最深的一个数学用例，是我的计算机启蒙老师考我的。当时我只有小学三年级，可惜我当时不知道用公式 N×（N+1）/ 2 来解决这个问题。方法E循环了100次才解决问题，也就是说最少用了100个赋值，100个判断，200个加法（I和j）；而方法F仅仅用了1个加法，1 次乘法，1次除法。效果自然不言而喻。所以，现在我在编程序的时候，更多的是动脑筋找规律，最大限度地发挥数学的威力来提高程序运行的效率。

第四招：使用位操作

使用位操作。减少除法和取模的运算。在计算机程序中数据的位是可以操作的最小数据单位，理论上可以用"位运算"来完成所有的运算和操作。一般的位操作是用来控制硬件的，或者做数据变换使用，但是，灵活的位操作可以有效地提高程序运行的效率。举例如下：

方法G

int I,J;

I = 257 /8;

J = 456 % 32;

方法H

int I,J;

I = 257 >>3;

J = 456 - (456 >> 4 << 4);

在字面上好像H比G麻烦了好多，但是，仔细查看产生的汇编代码就会明白，方法G调用了基本的取模函数和除法函数，既有函数调用，还有很多汇编代码和寄存器参与运算；而方法H则仅仅是几句相关的汇编，代码更简洁，效率更高。当然，由于编译器的不同，可能效率的差距不大，但是，以我目前遇到的MS C ,arm C 来看，效率的差距还是不小。

对于以2的指数次方为"\*"、"/"或"%"因子的数学运算，转化为移位运算"<< >>"通常可以提高算法效率。因为乘除运算指令周期通常比移位运算大。

C语言位运算除了可以提高运算效率外，在嵌入式系统的编程中，它的另一个最典型的应用，而且十分广泛地正在被使用着的是位间的与（&）、或（|）、非（~）操作，这跟嵌入式系统的编程特点有很大关系。我们通常要对硬件寄存器进行位设置，譬如，我们通过将AM186ER型80186处理器的中断屏蔽控制寄存器的第低6位设置为0（开中断2），最通用的做法是：

\#define INT\_I2\_MASK 0x0040

wTemp = inword(INT\_MASK);

outword(INT\_MASK, wTemp &~INT\_I2\_MASK);

而将该位设置为1的做法是：

\#define INT\_I2\_MASK 0x0040

wTemp = inword(INT\_MASK);

outword(INT\_MASK, wTemp | INT\_I2\_MASK);

判断该位是否为1的做法是：

\#define INT\_I2\_MASK 0x0040

wTemp = inword(INT\_MASK);

if(wTemp & INT\_I2\_MASK)

… /\* 该位为1 \*/

运用这招需要注意的是，因为CPU的不同而产生的问题。比如说，在PC上用这招编写的程序，并在PC上调试通过，在移植到一个16位机平台上的时候，可能会产生代码隐患。所以只有在一定技术进阶的基础下才可以使用这招。

第五招：汇编嵌入

在熟悉汇编语言的人眼里，C语言编写的程序都是垃圾"。这种说法虽然偏激了一些，但是却有它的道理。汇编语言是效率最高的计算机语言，但是，不可能靠着它来写一个操作系统吧?所以，为了获得程序的高效率，我们只好采用变通的方法--嵌入汇编，混合编程。嵌入式C程序中主要使用在线汇编，即在C程序中直接插入\_asm\{ \}内嵌汇编语句。

举例如下，将数组一赋值给数组二,要求每一字节都相符。

char string1\[1024\],string2\[1024\];

方法I

int I;

for (I =0 ;I<1024;I++)

\*(string2 + I) = \*(string1 + I)

方法J

\#ifdef \_PC\_

int I;

for (I =0 ;I<1024;I++)

\*(string2 + I) = \*(string1 + I);

\#else

\#ifdef \_arm\_

\_\_asm

MOV R0,string1

MOV R1,string2

MOV R2,\#0

loop:

LDMIA R0!, \[R3-R11\]

STMIA R1!, \[R3-R11\]

ADD R2,R2,\#8

CMP R2, \#400

BNE loop

\#endif

再举个例子：

/\* 把两个输入参数的值相加，结果存放到另外一个全局变量中 \*/

int result;

void Add(long a, long \*b)

\_asm

MOV AX, a

MOV BX, b

ADD AX, \[BX\]

MOV result, AX

方法I是最常见的方法，使用了1024次循环；方法J则根据平台不同做了区分，在arm平台下，用嵌入汇编仅用128次循环就完成了同样的操作。这里有朋友会说，为什么不用标准的内存拷贝函数呢?这是因为在源数据里可能含有数据为0的字节，这样的话，标准库函数会提前结束而不会完成我们要求的操作。这个例程典型应用于LCD数据的拷贝过程。根据不同的CPU，熟练使用相应的嵌入汇编，可以大大提高程序执行的效率。

虽然是必杀技，但是如果轻易使用会付出惨重的代价。这是因为，使用了嵌入汇编，便限制了程序的可移植性，使程序在不同平台移植的过程中，卧虎藏龙，险象环生！同时该招数也与现代软件工程的思想相违背，只有在迫不得已的情况下才可以采用。

第六招， 使用寄存器变量

当对一个变量频繁被读写时，需要反复访问内存，从而花费大量的存取时间。为此，C语言提供了一种变量，即寄存器变量。这种变量存放在CPU的寄存器中，使用时，不需要访问内存，而直接从寄存器中读写，从而提高效率。寄存器变量的说明符是register。对于循环次数较多的循环控制变量及循环体内反复使用的变量均可定义为寄存器变量，而循环计数是应用寄存器变量的最好候选者。

(1) 只有局部自动变量和形参才可以定义为寄存器变量。因为寄存器变量属于动态存储方式，凡需要采用静态存储方式的量都不能定义为寄存器变量，包括：模块间全局变量、模块内全局变量、局部static变量；

(2) register是一个"建议"型关键字，意指程序建议该变量放在寄存器中，但最终该变量可能因为条件不满足并未成为寄存器变量，而是被放在了存储器中，但编译器中并不报错（在C++语言中有另一个"建议"型关键字：inline）。

下面是一个采用寄存器变量的例子：

/\* 求1+2+3+….+n的值 \*/

WORD Addition(BYTE n)

for(i=1;i<=n;i++)

s=s+i;

return s;

本程序循环n次，i和s都被频繁使用，因此可定义为寄存器变量。

/\*www.cyuyan.com.cn\*/

第七招： 利用硬件特性

首先要明白CPU对各种存储器的访问速度，基本上是：

CPU内部RAM　>　外部同步RAM　>　外部异步RAM　>　FLASH/ROM

对于程序代码，已经被烧录在FLASH或ROM中，我们可以让CPU直接从其中读取代码执行，但通常这不是一个好办法，我们最好在系统启动后将FLASH或ROM中的目标代码拷贝入RAM中后再执行以提高取指令速度；

对于UART等设备，其内部有一定容量的接收BUFFER，我们应尽量在BUFFER被占满后再向CPU提出中断。例如计算机终端在向目标机通过RS-232传递数据时，不宜设置UART只接收到一个BYTE就向CPU提中断，从而无谓浪费中断处理时间；

如果对某设备能采取DMA方式读取，就采用DMA读取，DMA读取方式在读取目标中包含的存储信息较大时效率较高，其数据传输的基本单位是块，而所传输的数据是从设备直接送入内存的（或者相反）。DMA方式较之中断驱动方式，减少了CPU 对外设的干预，进一步提高了CPU与外设的并行操作程度。

# [高效程序的秘密\_hacker's delight读书笔记][hacker_s delight] #

摘要：

本书用来介绍一些基于bit位的算法。充分利用计算机本身的指令，来进行高效的算法。读书笔记摘录了其中的一些算法。读书笔记中的章节跟书中的章节保持一致。

第2章. 对bit位的一些操作

2.1 操作最右侧位

1. 这里有一个基本的定理：

将字映射到字的函数可以用字并行加、减、与、或、非指令实现，当且仅当函数的结果的每一位只依赖于每个输入操作数的相应位以及相应位右侧的位。

2. 将一个字最右侧的1位改成0位

例如 0101 1000 => 0101 0000 ：  x&(x-1)

3. 检测一个无符号整数是否是2^n -1的形式：

x&(x+1)

4. 析出(isolate)最右侧的1位， 如果没有1位则生成所有位均为0的字

例如 0101 1000 => 0000 1000 : x&(-x)

5. 析出(isolate)最右侧的0位， 如果没有0位则生成所有位均为0的字

例如 0101 0111 => 0000 1000 : ~x&(x+1) ，注意这里第一项是x按位取反

6.再举最后一个复杂一点的，其它的位操作算法就不一一列举了。可以依据定理，只要符合定理的bit操作，都可以用这种方式实现。

将最右侧连续的1改成0. 例如0101 1000 => 0100 0000

((x|(x-1))+1) & x

2.7 符号函数

符号函数的定义是：

\[  -1 , x< 0 \]

sign(x) = \[  0 ,  x=0 \]

\[  1,  x>0 \]

1. 最直观的解法是：

(x>0)-(x<0) 或(x>=0)-(x<=0)。

这种方式可以扩展到比较函数

\[  -1 , x< y \]

cmp(x,y) = \[  0 , x=y \]

\[  1,  x>y \]

(x>y)-(x<y) 或 (x>=y)-(x<=y)

2. 用移位指令实现

( (带符号右移)x>>31 ) |((无符号右移)-x>>31)

或者

\-(x>>31) | (-x>>31) , 这里都是无符号右移，但对x=-2^31这个边界数会失败。

2.12 如何检测溢出

这里讨论的是如何不使用cpu的“溢出状态位”来检测溢出。因为有些cpu比如MIPS根本就没有这个状态位。这个对于大整数的加减和绝对值运算很重要。后面会讲基于这个方法的大整数（比如128bit, 256bit）的加减算法。

1. 带符号加法的溢出检测

x+y+c, 其中c表示进位，只能是1或者0.

溢出检测:  ((x+y+c) xor x) &((x+y+c) xor y)

其结果再符号位给出，可以再其后面加入右移位31位，然后得到1或者0的值。

x-y-c, 其中c表示借位，只能是1或者0。

溢出检测：(x xor y) & ((x-y-c) xor x)

其结果再符号位给出，可以再其后面加入右移位31位，然后得到1或者0的值。

2. 借位和进位的计算

进位：(x+y+c) xor x xor y

进位：(x-y-c) xor x xor y

3. 无符号加减和乘法的溢出这里不详述。具体看书。

2.15 大数字的加减算法

设操作数是(x1,x0)和(y1,y0), 结果是(z1,z0),则大数加法：

z0=x0+y0

c=\[ (x0&y0) | ((x0|y0) &~z0)\]>>31 (这里计算进位)

z1=x1+y1+c

减法

z0=x0-y0

b=\[ (~x0&y0) | ((x0 按位等值 y0)& z0)\] >>31 (这里计算补位)

z1=x1-y1-b

这里的算法，基本上比现在网上能查到的算法效率都高。十个左右的指令可以完成。但代价就是可移植性差了。算法没有具体验证，仅仅是从书中摘录。如果需要工程使用请自行验证。

2.16 双字长移位

2.17 多字节大数的加减和绝对值计算

这两个算法不在这里叙述。可以参考书本身。

2.19 交换寄存器

这个就是两个变量互相交换并且不借助第三个变量。

c语言实现可以为：

x=x+y

y=x-y

x=x-y

用bit位操作也能实现

x=x xor y

y=y xor x

x=x xor y

第三章 2的幂边界

3.1 上舍入和下舍入到2的幂的操作

这个就是如何将一个数，如何获取离他最近（大于或者小于）的2的幂的数。

不具体叙述。看书上描述。

第五章位计数

5.1  “1”位计数

统计一个字（比如32bit）中，有多少个bit是1，有多少个bit是0。

这里以32bit为例来说明算法，这里基本思想类似折半计算。算法复杂度O(lgn)

x = (x & 0x55555555) + ((x>>1)& 0x55555555);

x = (x & 0x33333333) + ((x>>2)& 0x33333333);

x = (x & 0x0F0F0F0F) + ((x>>4)& 0x0F0F0F0F);

x = (x & 0x00FF00FF) + ((x>>8)& 0x00FF00FF);

x = (x & 0x0000FFFF) + ((x>>16)& 0x0000FFFF);

通过优化，还可以减少几个指令。具体优化就看书上介绍。但基本原理就是上面这个。

统计这种个数，这里还有一个查表的算法。就是把8bit的数，做成0-255的表。直接查数组可以算出多少个bit。这个方式在很多情况下都可以很有用。

5.2 奇偶性

统计一个数里面，bit是1的个数是奇数个还是偶数个。

具体算法见书上的说明

5.3 前导零和后缀零的计算

就是计算一个数，有多少bit是前导0，有多少bit是后缀0.

具体算法见书上说明。

第六章字搜索

6.1 搜索第一个为0的字节

这个很有用的一个功能就是找字符串的结尾字符'\\0'. 传统的算法就是一个byte一个byte的去寻找是否等于0。书中给出了一个算法，对于64bit的机器，可以节省一半的指令。不具体细述。可以参考strlen的实现，看看strlen如何实现的。

6.2 寻找第一个给定长度的1位串

一般这个问题用来做压缩算法之类的有用。不细述。需要的时候再来查书。

第7章位和字节的重排列

暂时不太关心这种操作，没怎么看。

第8章乘法

第9章除法

第10章整数常量除法

这几章有个很有用的东西，就是大数的乘法和除法。128bit或者256bit大数的乘除如何高效实现。乘法有算法，但除法很麻烦。第十章就是将如何尽量避免使用除法。

具体算法也不在这里细述了。

这里可以看看，开源的加密算法，是如何实现大数的加减乘除的。书上讲的效率很高，但可移植性不好。相信开源的加密算法，对这个问题的处理，会更多考虑可移植性。

第11-16章

是一些数值计算的高效方法。不太关心。没看。

http://c-faq-chn.sourceforge.net/ccfaq/index.html

# C 语言常见问题集 #

**原著：Steve Summit**

*翻译：朱群英, 孙 云*

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

*  [目录][Link 1]
 *  [1. 前言][1.]
 *  [2. 声明和初始化][2.]
    
     *  [2.1 我如何决定使用那种整数类型？][2.1]
     *  [2.2 64 位机上的 64 位类型是什么样的？][2.2_64_64]
     *  [2.3 怎样定义和声明全局变量和函数最好？][2.3]
     *  [2.4 extern 在函数声明中是什么意思？][2.4_extern]
     *  [2.5 关键字 auto 到底有什么用途？][2.5_auto]
     *  [2.6 我似乎不能成功定义一个链表。我试过  typedef struct \{ char \*item; NODEPTR next; \} \*NODEPTR; 但是编译器报了错误信息。难道在C语言中一个 结构不能包含指向自己的指针吗？][2.6_ _typedef struct _ char _item_ NODEPTR next_ _ _NODEPTR_C_]
     *  [2.7 怎样建立和理解非常复杂的声明？例如定义一个包含 N 个指向返 回指向字符的指针的函数的指针的数组？][2.7_N_]
     *  [2.8 函数只定义了一次, 调用了一次, 但编译器提示非法重定义了。][2.8_ _]
     *  [2.9 main() 的正确定义是什么？  void main() 正确吗？][2.9_main_ _void main]
     *  [2.10 对于没有初始化的变量的初始值可以作怎样的假定？ 如果一个全局变量初始值为 \`\`零", 它可否作为空指针或浮点零？][2.10_ _]
     *  [2.11 代码 int f() \{ char a\[\] = "Hello, world!";\} 不能编译。][2.11_int f_ _ char a_ _Hello_ world]
     *  [2.12 这样的初始化有什么问题？char \*p = malloc(10);  编译器提示 \`\`非法初始式" 云云。][2.12_char _p _ malloc_10_]
     *  [2.13 以下的初始化有什么区别？char a\[\] = "string literal"; char \*p = "string literal"; 当我向 p\[i\] 赋值的时候, 我的 程序崩溃了。][2.13_char a_ _string literal_ char _p _string literal_ _p_i_ _]
     *  [2.14 我总算弄清除函数指针的声明方法了, 但怎样才能初始化呢？][2.14_]
    
      
    
 *  [3. 结构、联合和枚举][3.]
    
     *  [3.1 声明 struct x1 \{ ...\}; 和 typedef struct \{ ...\} x2; 有什么不同？][3.1_struct x1 _ ..._typedef struct _ ..._ x2_]
     *  [3.2 为什么 struct x \{ ...\}; x thestruct; 不对？][3.2_struct x _ ..._ x thestruct]
     *  [3.3 一个结构可以包含指向自己的指针吗？][3.3]
     *  [3.4 在 C 语言中实现抽象数据类型什么方法最好?][3.4_C]
     *  [3.5 在 C 中是否有模拟继承等面向对象程序设计特性的好方法？][3.5_C]
     *  [3.6 我遇到这样声明结构的代码: struct name \{ int namelen; char namestr\[1\];\}; 然后又使用一些内存分配技巧使 namestr  数组用起来好像有多个元素。这样合法和可移植吗？][3.6_ struct name _ int namelen_ char namestr_1_namestr_]
     *  [3.7 是否有自动比较结构的方法？][3.7]
     *  [3.8 如何向接受结构参数的函数传入常数值？][3.8]
     *  [3.9 怎样从/向数据文件读/写结构？][3.9]
     *  [3.10 我的编译器在结构中留下了空洞, 这导致空间浪费而且无法 与外部数据文件进行 "二进制" 读写。能否关掉填充, 或者控制结构域的 对齐方式?][3.10_ _ _ _]
     *  [3.11 为什么 sizeof 返回的值大于结构的期望值, 是不是尾部有填充?][3.11_sizeof_]
     *  [3.12 如何确定域在结构中的字节偏移？][3.12]
     *  [3.13 怎样在运行时用名字访问结构中的域？][3.13]
     *  [3.14 程序运行正确, 但退出时却 \`\`core dump''了，怎么回事？][3.14_ _core dump]
     *  [3.15 可以初始化一个联合吗？][3.15]
     *  [3.16 枚举和一组预处理的 \#define 有什么不同？][3.16_define]
     *  [3.17 有什么容易的显示枚举值符号的方法？][3.17]
    
      
    
 *  [4. 表达式][4.]
    
     *  [4.1 为什么这样的代码:  a\[i\] = i++; 不能工作？][4.1_ _a_i_ _ i]
     *  [4.2 使用我的编译器,下面的代码  int i=7; printf("%d\\n", i++ \* i++); 返回 49？不管按什么顺序计算, 难道不该打印出56吗？][4.2_ _int i_7_ printf_d_n_ i_ _ i_49_ _56]
     *  [4.3 对于代码  int i = 3; i = i++; 不同编译器给出不同的结果, 有的为 3, 有的为 4, 哪个是正确的？][4.3_ _int i _ 3_ i _ i_ _3_ _4_]
     *  [4.4 这是个巧妙的表达式:  a ^= b ^= a ^= b  它不需要临时变量就可以交换 a 和 b 的值。][4.4_ _a _ b _ a _ b_ _a_b]
     *  [4.5 我可否用括号来强制执行我所需要的计算顺序？][4.5]
     *  [4.6 可是 && 和 || 运算符呢？ 我看到过类似  while((c = getchar()) != EOF && c != '\\n')  的代码 ……][4.6_ _ _while_c _ getchar_ _ EOF _ c _n_]
     *  [4.7 我怎样才能理解复杂表达式？\`\`序列点" 是什么？][4.7]
     *  [4.8 那么, 对于 a\[i\] = i++; 我们不知道 a\[\] 的哪 一个分量会被改写,但 i 的确会增加 1, 对吗？][4.8_ _a_i_ _ i_a_ _i_1_]
     *  [4.9 ++i 和 i++ 有什么区别？][4.9_i_i]
     *  [4.10 如果我不使用表达式的值, 我应该用 ++i 或 i++  来自增一个变量吗？][4.10_ _i_i_]
     *  [4.11 为什么如下的代码  int a = 100, b = 100; long int c = a \* b; 不能工作？][4.11_ int a _ 100_ b _ 100_ long int c _ a _ b]
     *  [4.12 我需要根据条件把一个复杂的表达式赋值给两个变量中的 一个。可以用下边这样的代码吗？  ((condition) ? a : b) = complicated\_expression;][4.12_ _ _condition_ _ a _ b_ _ complicated_expression]
    
      
    
 *  [5. 指针][5.]
    
     *  [5.1 我想声明一个指针并为它分配一些空间, 但却不行。这些代码有什么问题？ char \*p; \*p = malloc(10);][5.1_ _ char _p_ _p _ malloc_10]
     *  [5.2 \*p++ 自增 p 还是 p 所指向的变量？][5.2_p_p_p]
     *  [5.3 我有一个 char \* 型指针正巧指向一些 int 型变 量, 我想跳过它们。为什么如下的代码 ((int \*)p)++; 不行？][5.3_char _int_ _ _ _int _p_]
     *  [5.4 我有个函数,它应该接受并初始化一个指针  void f(int \*ip) \{ static int dummy = 5; ip = &dummy;\} 但是当我如下调用时: int \*ip; f(ip); 调用者的指针却没有任何变化。][5.4_ _void f_int _ip_ _ static int dummy _ 5_ ip _ _dummy_ _ int _ip_ f_ip_]
     *  [5.5 我能否用 void\*\* 指针作为参数, 使函数按引用接受一 般指针？][5.5_void_ _]
     *  [5.6 我有一个函数 extern int f(int \*); 它接受指向  int 型的指针。我怎样用引用方式传入一个常数？下面这样的 调用 f(&5); 似乎不行。][5.6_extern int f_int _ _int_ _f_5]
     *  [5.7 C 有 \`\`按引用传递" 吗？][5.7_C]
     *  [5.8 我看到了用指针调用函数的不同语法形式。到底怎么回事？][5.8]
     *  [5.9 我怎样把一个 int 变量转换为 char \* 型？ 我试了类型转换, 但是不行。][5.9_int_char _ _]
    
      
    
 *  [6. 空 (null) 指针][6. _null]
    
     *  [6.1 臭名昭著的空指针到底是什么？][6.1]
     *  [6.2 怎样在程序里获得一个空指针？][6.2]
     *  [6.3 用缩写的指针比较 \`\`if(p)" 检查空指针是否可靠？ 如果空指针的内部表达不是 0 会怎么样？][6.3_if_p_ _0]
     *  [6.4 NULL 是什么, 它是怎么定义的？][6.4_NULL_]
     *  [6.5 在使用非全零作为空指针内部表达的机器上, NULL 是如何定义的？][6.5_ NULL]
     *  [6.6 如果 NULL 定义成 \#define NULL ((char \*)0)  难道不就可以向函数传入不加转换的 NULL 了吗？][6.6_NULL_define NULL _char _0_ _NULL]
     *  [6.7 如果 NULL 和 0 作为空指针常数是等价的, 那我到底该用哪一个呢？][6.7_NULL_0_]
     *  [6.8 但是如果 NULL 的值改变了, 比如在使用非零内部空指针的机器上, 难道用 NULL (而不是 0) 不是更好吗？][6.8_NULL_ _ _NULL _0]
     *  [6.9 用预定义宏 \#define Nullptr(type) (type \*)0 帮助创建正确 类型的空指针。][6.9_define Nullptr_type_ _type _0_]
     *  [6.10 这有点奇怪。NULL 可以确保是 0, 但空 (null) 指针却不一定？][6.10_NULL_0_ _null]
     *  [6.11 为什么有那么多关于空指针的疑惑？为什么这些问题如此经常地出现？][6.11]
     *  [6.12 我很困惑。我就是不能理解这些空指针一类的东西。][6.12]
     *  [6.13 考虑到有关空指针的所有这些困惑, 难道把要求它们内部表达都必须 为 0 不是更简单吗？][6.13_ _ _0]
     *  [6.14 说真的, 真有机器用非零空指针吗, 或者不同类型用不同的表达？][6.14_ _]
     *  [6.15 运行时的 \`\`空指针赋值" 错误是什么意思？][6.15]
    
      
    
 *  [7. 数组和指针][7.]
    
     *  [7.1 我在一个源文件中定义了 char a\[6\], 在另一个中声明了  extern char \*a 。为什么不行 ？][7.1_char a_6_ _ _extern char _a_]
     *  [7.2 可是我听说 char a\[ \] 和 char \*a 是一样的。][7.2_char a_ _char _a]
     *  [7.3 那么, 在 C 语言中 \`\`指针和数组等价" 到底是什么意思 ？][7.3_ _C_]
     *  [7.4 那么为什么作为函数形参的数组和指针申明可以互换呢 ？][7.4_]
     *  [7.5 如果你不能给它赋值, 那么数组如何能成为左值呢 ？][7.5_ _]
     *  [7.6 现实地讲, 数组和指针地区别是什么 ？][7.6_ _]
     *  [7.7 有人跟我讲, 数组不过是常指针。][7.7_]
     *  [7.8 我遇到一些 \`\`搞笑" 的代码, 包含 5\["abcdef"\]  这样的 \`\`表达式"。 这为什么是合法的 C 表达式呢 ？][7.8_ _5_abcdef_ _ _C_]
     *  [7.9 既然数组引用会蜕化为指针, 如果 arr 是数组, 那么 arr 和 &arr  又有什么区别呢 ？][7.9_ _arr_ _arr_arr_ _]
     *  [7.10 我如何声明一个数组指针 ？][7.10_]
     *  [7.11 我如何在运行期设定数组的大小 ？ 我怎样才能避免固定大小的数组 ？][7.11_ _ _]
     *  [7.12 我如何声明大小和传入的数组一样的局部数组 ？][7.12_]
     *  [7.13 我该如何动态分配多维数组 ？][7.13_]
     *  [7.14 有个灵巧的窍门: 如果我这样写  int realarray\[10\]; int \*array = &realarray\[-1\];  我就可以把 \`\`array" 当作下标从 1 开始的数组。][7.14_ _ _int realarray_10_ int _array _ _realarray_-1_ _array_1]
     *  [7.15 当我向一个接受指针的指针的函数传入二维数组的时候, 编译器报错了。][7.15_]
     *  [7.16 我怎样编写接受编译时宽度未知的二维数组的函数 ？][7.16_]
     *  [7.17 我怎样在函数参数传递时混用静态和动态多维数组 ？][7.17_]
     *  [7.18 当数组是函数的参数时, 为什么 sizeof 不能正确报告数组的大小 ？][7.18_ _sizeof_]
    
      
    
 *  [8. 内存分配][8.]
    
     *  [8.1 为什么这段代码不行？char \*answer; printf("Type something:\\n"); gets(answer); printf("You typed \\"%s\\"\\n", answer);][8.1_char _answer_ printf_Type something_n_ gets_answer_ printf_You typed _s_n_ answer]
     *  [8.2 我的 strcat() 不行.我试了  char \*s1 = "Hello, "; char \*s2 = "world!"; char \*s3 = strcat(s1, s2);  但是我得到了奇怪的结果。][8.2_strcat_._ _char _s1 _Hello_ char _s2 _world_ char _s3 _ strcat_s1_ s2_]
     *  [8.3 但是 strcat 的手册页说它接受两个 char \* 型参数。 我怎么知道 (空间) 分配的事情呢？][8.3_strcat_char _]
     *  [8.4 我刚才试了这样的代码  char \*p; strcpy(p, "abc"); 而它运行正常？怎么回事？ 为什么它没有崩溃？][8.4_ char _p_ strcpy_p_abc_]
     *  [8.5 一个指针变量分配多少内存？][8.5]
     *  [8.6 我有个函数, 本该返回一个字符串, 但当它返回调用者的时候, 返回串却是垃圾信息。][8.6_ _ _]
     *  [8.7 那么返回字符串或其它集合的争取方法是什么呢？][8.7]
     *  [8.8 为什么在调用 malloc() 时, 我得到 \`\`警告: 整数赋向指针需要类型转换"？][8.8_malloc_ _]
     *  [8.9 为什么有些代码小心地把 malloc 返回的值转换为分配的指针类型。][8.9_malloc]
     *  [8.10 在调用 malloc() 的时候, 错误 \`\`不能把 void \* 转换为 int \*"  是什么意思？][8.10_malloc_ _void _int _]
     *  [8.11 我见到了这样的代码  char \*p = malloc(strlen(s) + 1); strcpy(p, s);  难道不应该是 malloc((strlen(s) + 1) \* sizeof(char))？][8.11_ _char _p _ malloc_strlen_s_ _ 1_ strcpy_p_ s_ _malloc_strlen_s_ _ 1_ _ sizeof_char]
     *  [8.12 我如何动态分配数组？][8.12]
     *  [8.13 我听说有的操作系统程序使用的时候才真正分配 malloc 申请 的内存。这合法吗？][8.13_malloc_]
     *  [8.14 我用一行这样的代码分配一个巨大的数组, 用于数字运算:  double \*array = malloc(300 \* 300 \* sizeof( double ));  malloc() 并没有返回 null, 但是程序运行得有些奇怪, 好像改写了某些内存, 或者 malloc() 并没有分配我申请的那么多内存, 云云。][8.14_ _ _double _array _ malloc_300 _ 300 _ sizeof_ double _ malloc_null_ _ _ _malloc_]
     *  [8.15 我的 PC 有 8 兆内存。为什么我只能分配 640K 左右的内存？][8.15_PC_8_640K]
     *  [8.16 我的程序总是崩溃, 显然在 malloc 内部的某个地方。 但是我看不出 哪里有问题。是 malloc() 有 bug 吗？][8.16_ _malloc_ _ _malloc_bug]
     *  [8.17 动态分配的内存一旦释放之后你就不能再使用, 是吧？][8.17_]
     *  [8.18 为什么在调用 free() 之后指针没有变空？使用 (赋值, 比较)  释放之后的指针有多么不安全？][8.18_free_ _]
     *  [8.19 当我 malloc() 为一个函数的局部指针分配内存时, 我还需要用  free() 明确的释放吗？][8.19_malloc_ _ _free]
     *  [8.20 我在分配一些结构, 它们包含指向其它动态分配的对象的指针。 我在释放结构的时候, 还需要释放每一个下级指针吗？][8.20_ _ _]
     *  [8.21 我必须在程序退出之前释放分配的所有内存吗？][8.21]
     *  [8.22 我有个程序分配了大量的内存, 然后又释放了。但是从操作系统看, 内存的占用率却并没有回去。][8.22_ _]
     *  [8.23 free() 怎么知道有多少字节需要释放？][8.23_free]
     *  [8.24 那么我能否查询 malloc 包, 可分配的最大块是多大？][8.24_malloc_]
     *  [8.25 向 realloc() 的第一个参数传入空指针合法吗？你为什么要这样做？][8.25_realloc]
     *  [8.26 calloc() 和 malloc() 有什么区别？利用 calloc 的零填充功能安全吗？ free() 可以释放 calloc() 分配的内存吗, 还是需要一个 cfree()？][8.26_calloc_malloc_calloc_ free_calloc_ _cfree]
     *  [8.27 alloca() 是什么？为什么不提倡使用它？][8.27_alloca]
    
      
    
 *  [9. 字符和字符串][9.]
    
     *  [9.1 为什么 strcat(string, '!'); 不行？][9.1_strcat_string]
     *  [9.2 我在检查一个字符串是否跟某个值匹配。 为什么这样不行？ char \*string; ... if(string == "value") \{ /\* string matches "value" \*/ ... \}][9.2_ _ char _string_ ... if_string _value_ _ _ string matches _value_ _ ...]
     *  [9.3 如果我可以写  char a\[\] = "Hello, world!";  为什么我不能写  char a\[14\]; a = "Hello, world!";][9.3_ _char a_ _Hello_ world_ _ _char a_14_ a _Hello_ world]
     *  [9.4 我怎么得到对应字符的数字 (字符集) 值, 或者相反？][9.4_]
     *  [9.5 我认为我的编译器有问题: 我注意到 sizeof('a') 是 2 而不是  1 (即, 不是 sizeof(char))。][9.5_ _sizeof_a_2_ _1_ _sizeof_char]
    
      
    
 *  [10. 布尔表达式和变量][10.]
    
     *  [10.1 C 语言中布尔值的候选类型是什么？为什么它不是一个 标准类型？我应该用 \#define 或 enum 定义 true 和 false 值吗？][10.1_C_ _define_enum_true_false]
     *  [10.2 因为在 C 语言中所有的非零值都被看作 \`\`真", 是不是把 TRUE  定义为 1 很危险？如果某个内置的函数或关系操作符 \`\`返回" 不是 1 的 其它值怎么办？][10.2_C_ _TRUE_ _1_1_]
     *  [10.3 当 p 是指针时, if(p) 是合法的表达式吗？][10.3_p_if_p]
    
      
    
 *  [11. C 预处理器][11. C]
    
     *  [11.1 这些机巧的预处理宏:  \#define begin \{  \#define end \}  你觉得怎么样？][11.1_ _define begin _ _define end _]
     *  [11.2 怎么写一个一般用途的宏交换两个值？][11.2]
     *  [11.3 书写多语句宏的最好方法是什么？][11.3]
     *  [11.4 我第一次把一个程序分成多个源文件, 我不知道该把什么放到 .c 文件, 把什么放到 .h 文件。(\`\`.h" 到底是什么意思？)][11.4_ _.c_ _.h_.h]
     *  [11.5 一个头文件可以包含另一头文件吗？][11.5]
     *  [11.6 \#include <> 和 \#include 有什么区别？][11.6_include _include]
     *  [11.7 完整的头文件搜索规则是怎样的？][11.7]
     *  [11.8 我在文件的第一个声明就遇到奇怪的语法错误, 但是看上去没什么问题。][11.8_]
     *  [11.9 我包含了我使用的库函数的正确头文件, 可是连接器还是说它没有定义。][11.9_]
     *  [11.10 我在编译一个程序, 看起来我好像缺少需要的一个或多个头文件。 谁能发给我一份？][11.10_ _]
     *  [11.11 我怎样构造比较字符串的 \#if 预处理表达式？][11.11_if]
     *  [11.12 sizeof 操作符可以用于 \#if 预编译指令中吗？][11.12_sizeof_if]
     *  [11.13 我可以在 \#include 行里使用 \#ifdef 来定义两个不同的东西吗？][11.13_include_ifdef]
     *  [11.14 对 typdef 的类型定义有没有类似 \#ifdef的东西？][11.14_typdef_ifdef]
     *  [11.15 我如何用 \#if 表达式来判断机器是高字节在前还是低字节在前？][11.15_if]
     *  [11.16 我得到了一些代码, 里边有太多的 \#ifdef。 我不想使用预处理器 把所有的 \#include 和 \#ifdef 都扩展开, 有什么办法只保留一种条件的 代码呢？][11.16_ _ifdef_ _ _include_ifdef_ _]
     *  [11.17 如何列出所有的预定义标识符？][11.17]
     *  [11.18 我有些旧代码, 试图用这样的宏来构造标识符  \#define Paste(a, b) a/\*\*/b 但是现在不行了。][11.18_ _ _define Paste_a_ b_ a_b]
     *  [11.19 为什么宏  \#define TRACE(n) printf("TRACE: %d\\n", n)  报出警告 \`\`用字符串常量代替宏"？它似乎应该把  TRACE(count);  扩展为  printf("TRACE: %d\\count", count);][11.19_ _define TRACE_n_ printf_TRACE_ _d_n_ n_ _ TRACE_count_ _ printf_TRACE_ _d_count_ count]
     *  [11.20 使用 \# 操作符时, 我在字符串常量内使用宏参数有问题。][11.20_]
     *  [11.21 我想用预处理做某件事情, 但却不知道如何下手。][11.21_]
     *  [11.22 怎样写参数个数可变的宏？][11.22]
    
      
    
 *  [12. ANSI/ISO 标准 C][12. ANSI_ISO_C]
    
     *  [12.1 什么是 \`\`ANSI C 标准"？][12.1_ANSI C]
     *  [12.2 我如何得到一份标准的副本？][12.2]
     *  [12.3 我在哪里可以找到标准的更新？][12.3]
     *  [12.4 很多 ANSI 编译器在遇到以下代码时都会警告类型不匹配。  extern int func(float); int func(x) float x; \{ ...][12.4_ANSI_ _extern int func_float_ int func_x_ float x_ _ ...]
     *  [12.5 能否混用旧式的和新型的函数语法？][12.5]
     *  [12.6 为什么声明  extern int f(struct x \*p);  报出了一个奇怪的警告信息 \`\`结构 x 在参数列表中声明"？][12.6_ extern int f_struct x _p_ _x]
     *  [12.7 我不明白为什么我不能象这样在初始化和数组维度中使用常量: const int n = 5; int a\[n\];][12.7_ const int n _ 5_ int a_n]
     *  [12.8 既然不能修改字符串常量, 为什么不把它们定义为字符常量的数组？][12.8_]
     *  [12.9 \`\`const char \*p" 和 \`\`char \* const p" 有何区别？][12.9_const char _p_char _ const p]
     *  [12.10 为什么我不能向接受 const char \*\* 的函数传入 char \*\*？][12.10_const char _char]
     *  [12.11 怎样正确声明 main()？][12.11_main]
     *  [12.12 我能否把 main() 定义为 void, 以避免扰人的 \`\`main无返回值" 警告？][12.12_main_void_ _main]
     *  [12.13 可 main() 的第三个参数 envp 是怎么回事？][12.13_main_envp]
     *  [12.14 我觉得把 main() 声明为 void 不会失败, 因为我调用了 exit()  而不是 return , 况且我的操作系统也忽略了程序的退出/返回状态。][12.14_main_void_ _exit_ _return_]
     *  [12.15 那么到底会出什么问题？真的有什么系统不支持 void main() 吗？][12.15_void main]
     *  [12.16 我一直用的那本书《熟练傻瓜C语言》总是使用 void main()。][12.16_C_void main]
     *  [12.17 从 main() 中, exit(status) 和返回同样的 status 真的等价吗？][12.17_main_ exit_status_status]
     *  [12.18 我试图用 ANSI \`\`字符串化" 预处理操作符 \# 向信息中插入符号 常量的值, 但它字符串化的总是宏的名字而不是它的值。][12.18_ANSI _ _]
     *  [12.19 警告信息 \`\`warning: macro replacement within a string literal" 是什么意思？][12.19_warning_ macro replacement within a string literal]
     *  [12.20 在我用 \#ifdef 去掉的代码里出现了奇怪的语法错误。][12.20_ifdef]
     *  [12.21 \#pragma 是什么, 有什么用？][12.21_pragma_]
     *  [12.22 \`\`\#pragma once" 是什么意思？我在一些头文件中看到了它。][12.22_pragma once]
     *  [12.23 a\[3\] = "abc"; 合法吗？它是什么意思？][12.23_a_3_ _abc]
     *  [12.24 为什么我不能对 void\* 指针进行运算？][12.24_void]
     *  [12.25 memcpy() 和 memmove() 有什么区别？][12.25_memcpy_memmove]
     *  [12.26 malloc(0) 有什么用？返回一个控指针还是指向 0  字节的指针？][12.26_malloc_0_0_]
     *  [12.27 为什么 ANSI 标准规定了外部标示符的长度和大小写限制？][12.27_ANSI]
     *  [12.28 我的编译对最简单的测试程序报出了一大堆的语法错误。][12.28]
     *  [12.29 为什么有些 ASNI/ISO 标准库函数未定义？我明明使用 的就是 ANSI 编译器。][12.29_ASNI_ISO_ _ANSI]
     *  [12.30 谁有把旧的 C 程序转化为 ANSI C 或相反的工具, 或者自动生成原型的工具？][12.30_C_ANSI C_]
     *  [12.31 为什么声称兼容 ANSI 的 Frobozz Magic C 编译器不能 编译这些代码？我知道这些代码是 ANSI 的, 因为 gcc 可以编译。][12.31_ANSI_Frobozz Magic C_ _ANSI_ _gcc]
     *  [12.32 人们好像有些在意实现定义 (implementation-defin-ed)、未明确  (unspecified) 和无定义 (undefined) 行为的区别。它们的区别到底在哪里？][12.32_implementation-defin-ed_ _unspecified_undefined]
     *  [12.33 一个程序的 \`\`合法", \`\`有效" 或 \`\`符合" 到底是什么意思？][12.33_]
     *  [12.34 我很吃惊, ANSI 标准竟然有那么多没有定义的东西。 标准的唯一任务不就是让这些东西标准化吗？][12.34_ ANSI_]
     *  [12.35 有人说 i = i++ 的行为是未定义的, 但是我刚在一个兼容 ANSI  的编译器上测试, 得到了我希望的结果。][12.35_i _ i_ _ANSI_ _]
    
      
    
 *  [13. 标准输入输出库][13.]
    
     *  [13.1 这样的代码有什么问题？ char c; while((c = getchar()) != EOF) ...][13.1_ char c_ while_c _ getchar_ _ EOF_ ...]
     *  [13.2 我有个读取直到 EOF 的简单程序, 但是我如何才能在键盘上输入那个  \`\`EOF" 呢？][13.2_EOF_ _ _EOF]
     *  [13.3 为什么这些代码  while(!feof(infp)) \{ fgets(buf, MAXLINE, infp); fputs(buf, outfp); \}  把最后一行复制了两遍？][13.3_ while_feof_infp_ _ fgets_buf_ MAXLINE_ infp_ fputs_buf_ outfp_ _]
     *  [13.4 我的程序的屏幕提示和中间输出有时显示在屏幕上, 尤其是当我用管道向 另一个程序输出的时候。][13.4_ _]
     *  [13.5 我怎样不等待回车键一次输入一个字符？][13.5]
     *  [13.6 我如何在 printf 的格式串中输出一个 '%'？ 我试过 \\%, 但是不行。][13.6_printf_ _]
     *  [13.7 有人告诉我在 printf 中使用 %lf 不正确。那么, 如果 scanf()  需要 %lf, 怎么可以用在 printf() 中用 %f 输出双精度数呢？][13.7_printf_lf_ _scanf_ _lf_ _printf_f]
     *  [13.8 对于 size\_t 那样的类型定义, 当我不知道它到底是 long  还是其它类型的时候, 我应该使用什么样的 printf 格式呢？][13.8_size_t_ _long_ _ _printf]
     *  [13.9 我如何用 printf 实现可变的域宽度？就是说, 我想在运行时确定宽度 而不是使用 %8d？][13.9_printf_ _ _8d]
     *  [13.10 如何输出在千位上用逗号隔开的数字？金额数字呢？][13.10]
     *  [13.11 为什么 scanf("%d", i) 调用不行？][13.11_scanf_d_ i]
     *  [13.12 为什么  char s\[30\]; scanf("%s", s);  不用 & 也可以？][13.12_ char s_30_ scanf_s_ s_]
     *  [13.13 为什么这些代码  double d; scanf("%f", &d);  不行？][13.13_ double d_ scanf_f_ _d_]
     *  [13.14 怎样在 scanf() 格式串中指定可变的宽度？][13.14_scanf]
     *  [13.15 当我用 \`\`%d\\n" 调用 scanf 从键盘读取数字 的时候, 好像要多输入一行函数才返回。][13.15_d_n_scanf_ _]
     *  [13.16 我用 scanf %d 读取一个数字, 然后再用 gets() 读取字符串, 但是 编译器好像跳过了 gets() 调用！][13.16_scanf _d_ _gets_ _ _gets]
     *  [13.17 我发现如果坚持检查返回值以确保用户输入的是我期待的数值, 则 scanf() 的使用会安全很多, 但有的时候好像会陷入无限循环。][13.17_ _scanf_]
     *  [13.18 为什么大家都说不要使用 scanf()？那我该用什么来代替呢？][13.18_scanf]
     *  [13.19 我怎样才知道对于任意的 sprintf 调用需要多大的目标缓冲区？ 怎样才能避免 sprintf() 目标缓冲区溢出？][13.19_sprintf_ _sprintf]
     *  [13.20 为什么大家都说不要使用 gets()？][13.20_gets]
     *  [13.21 为什么调用 printf() 之后 errno 内有 ENOTTY？][13.21_printf_errno_ENOTTY]
     *  [13.22 fgetops/fsetops 和 ftell/fseek 之间有什么区别？ fgetops()  和 fsetops() 到底有什么用处？][13.22_fgetops_fsetops_ftell_fseek_fgetops_ _fsetops]
     *  [13.23 如何清除多余的输入, 以防止在下一个提示符下读入？ fflush(stdin) 可以吗？][13.23_ _ fflush_stdin]
     *  [13.24 既然 fflush() 不能, 那么怎样才能清除输入呢？][13.24_fflush_]
     *  [13.25 对某些路径文件名调用 fopen() 总是失败。][13.25_fopen]
     *  [13.26 我想用 \`\`r+" 打开一个文件, 读出一个字符串, 修改之后再写入, 从而就地更新一个文件。可是这样不行。][13.26_r_ _ _]
     *  [13.27 怎样在程序里把 stdin 或 stdout 重定向到文件？][13.27_stdin_stdout]
     *  [13.28 一旦使用 freopen() 之后, 怎样才能恢复原来的 stdout (或 stdin)？][13.28_freopen_ _stdout _stdin]
     *  [13.29 怎样同时向两个地方输出, 如同时输出到屏幕和文件？][13.29_]
     *  [13.30 怎样正确的读取二进制文件？我有时看到 0x0a 和 0x0d 混淆了, 而且如果数据中包含 0x1a 的话, 我好像会提前遇到 EOF。][13.30_0x0a_0x0d_ _0x1a_ _EOF]
    
      
    
 *  [14. 库函数][14.]
    
     *  [14.1 怎样把数字转为字符串 (与 atoi 相反)？有 itoa() 函数吗？][14.1_atoi_itoa]
     *  [14.2 为什么 strncpy() 不能总在目标串放上终止符  '\\0'？][14.2_strncpy_ _0]
     *  [14.3 为什么有些版本的 toupper() 对大写字符会有奇怪的反应？ 为什么有的代码在调用 toupper() 前先调用 tolower()？][14.3_toupper_ _toupper_tolower]
     *  [14.4 怎样把字符串分隔成用空白作间隔符的段？怎样实现类似传递给  main() 的 argc 和 argv？][14.4_ _main_argc_argv]
     *  [14.5 我需要一些处理正则表达式或通配符匹配的代码。][14.5]
     *  [14.6 我想用 strcmp() 作为比较函数, 调用 qsort() 对一个字符串数组 排序, 但是不行。][14.6_strcmp_ _qsort_ _]
     *  [14.7 我想用 qsort() 对一个结构数组排序。我的比较函数接受结构指针, 但是编译器认为这个函数对于 qsort() 是错误类型。我要怎样转换这个函数指针 才能避免这样的警告？][14.7_qsort_ _qsort_]
     *  [14.8 怎样对一个链表排序？][14.8]
     *  [14.9 怎样对多于内存的数据排序？][14.9]
     *  [14.10 怎样在 C 程序中取得当前日期或时间？][14.10_C]
     *  [14.11 我知道库函数 localtime() 可以把 time\_t 转换成结构  struct tm, 而 ctime() 可以把 time\_t 转换成为可打印的字符串。 怎样才能进行反向操作, 把 struct tm 或一个字符串转换成 time\_t？][14.11_localtime_time_t_ _struct tm_ _ctime_time_t_ _ _struct tm_time_t]
     *  [14.12 怎样在日期上加 N 天？怎样取得两个日期的时间间隔？][14.12_N]
     *  [14.13 我需要一个随机数生成器。][14.13]
     *  [14.14 怎样获得在一定范围内的随机数？][14.14]
     *  [14.15 每次执行程序, rand() 都返回相同顺序的数字。][14.15_rand]
     *  [14.16 我需要随机的真/假值, 所以我用直接用 rand() % 2, 可是我得到 交替的 0, 1, 0, 1, 0 ……][14.16_ _rand_ _ 2_ _ _0_ 1_ 0_ 1_ 0]
     *  [14.17 怎样产生标准分布或高斯分布的随机数？][14.17]
     *  [14.18 我不断得到库函数未定义错误, 但是我已经 \#inlude 了所有用到的头文件了。][14.18_ _inlude]
     *  [14.19 虽然我在连接时明确地指定了正确的函数库, 我还是得到库函数未定义错误。][14.19_]
     *  [14.20 连接器说 \_end 未定义代表什么意思？][14.20_end]
     *  [14.21 我的编译器提示 printf 未定义！这怎么可能？][14.21_printf]
    
      
    
 *  [15. 浮点运算][15.]
    
     *  [15.1 一个 float 变量赋值为 3.1 时, 为什么 printf 输出的值为 3.0999999？][15.1_float_3.1_ _printf_3.0999999]
     *  [15.2 执行一些开方根运算, 可是得到一些疯狂的数字。][15.2_]
     *  [15.3 做一些简单的三角函数运算, 也引用了 \#include <math.h>, 可是一直得到编译错误 \`\`undefined: sin" (函数 sin 未定义)。][15.3_ _include _math.h_ _undefined_ sin_sin]
     *  [15.4 浮点计算程序表现奇怪, 在不同的机器上给出不同的结果。][15.4_]
     *  [15.5 有什么好的方法来验对浮点数在 \`\`足够接近" 情况下的等值？][15.5]
     *  [15.6 怎样取整数？][15.6]
     *  [15.7 为什么 C 不提供乘幂的运算符？][15.7_C]
     *  [15.8 为什么我机器上的 <math.h> 没有预定 义常数 M\_PI？][15.8_math.h_ _M_PI]
     *  [15.9 怎样测试 IEEE NaN 以及其它特殊值？][15.9_IEEE NaN]
     *  [15.10 在 C 中如何很好的实现复数？][15.10_C]
     *  [15.11 我要寻找一些实现以下功能的程序源代码： 快速傅立叶变换 (FFT)、矩阵算术 (乘法、倒置等函数)、 复数算术。][15.11_ _FFT_]
     *  [15.12 Turbo C 的程序崩溃, 显示错误为 \`\`floating point formats not linked" (浮点格式未连接)。][15.12_Turbo C_ _floating point formats not linked_]
    
      
    
 *  [16. 可变参数][16.]
    
     *  [16.1 为什么调用 printf() 前, 必须要用 \#include <stdio.h>？][16.1_printf_ _include _stdio.h]
     *  [16.2 为什么 %f 可以在 printf() 参数中, 同时表示 float 和  double？他们难道不是不同类型吗？][16.2_f_printf_ _float_ _double]
     *  [16.3 为什么当 n 为 long int, printf("%d", n);  编译时没有匹配警告？我以为 ANSI 函数原型可以防止这样的类型不匹配。][16.3_n_long int_ printf_d_ n_ _ANSI]
     *  [16.4 怎样写一个有可变参数的函数？][16.4]
     *  [16.5 怎样写类似 printf() 的函数, 再把参数转传给 printf() 去 完成大部分工作？][16.5_printf_ _printf_]
     *  [16.6 怎样写类似 scanf() 的函数, 再把参数转传给 scanf() 去 完成大部分工作？][16.6_scanf_ _scanf_]
     *  [16.7 怎样知道实际上有多少个参数传入函数？][16.7]
     *  [16.8 为什么编译器不让我定义一个没有固定参数项的可变参数函数？][16.8]
     *  [16.9 我有个接受 float 的可变参函数, 为什么  va\_arg(argp, float) 不工作？][16.9_float_ _ _va_arg_argp_ float]
     *  [16.10 va\_arg() 不能得到类型为函数指针的参数。][16.10_va_arg]
     *  [16.11 怎样实现一个可变参数函数, 它把参数再传给另一个可变参数函数？][16.11_]
     *  [16.12 怎样调用一个参数在执行是才建立的函数？][16.12]
    
      
    
 *  [17. 奇怪的问题][17.]
    
     *  [17.1 遇到不可理解的不合理语法错误, 似乎大段的程序没有编译。][17.1_]
     *  [17.2 为什么过程调用不工作？编译器似乎直接跳过去了。][17.2]
     *  [17.3 程序在执行用之前就崩溃了, 用调试器单步跟进, 在 main()  之前就死了。][17.3_ _ _main_]
     *  [17.4 程序执行正确, 但退出时崩溃在 main() 最后一个语句之后。 为什么会这样？][17.4_ _main_]
     *  [17.5 程序在一台机器上执行完美, 但在另一台上却得到怪异的结果。更奇怪的是, 增加或去除调试的打印语句, 就改变了症状……][17.5_ _ _]
     *  [17.6 为什么代码: char \*p = "hello, worl!"; p\[0\] = 'H'; 会崩溃？][17.6_ char _p _hello_ worl_ p_0_ _H_]
     *  [17.7 \`\`Segmentation violation", \`\`Bus error" 和  \`\`General protection fault"  意味着什么？][17.7_Segmentation violation_ _Bus error_ _General protection fault_]
    
      
    
 *  [18. 风格][18.]
    
     *  [18.1 什么是 C 最好的代码布局风格？][18.1_C]
     *  [18.2 用 if(!strcmp(s1, s2)) 比较两个字符串等值,是否是个好风格？][18.2_if_strcmp_s1_ s2]
     *  [18.3 为什么有的人用 if (0 == x) 而不是 if (x == 0)？][18.3_if _0 _ x_if _x _ 0]
     *  [18.4 原型说明 extern int func \_\_((int, int)); 中, 那些多出来的括号和下划线代表了什么？][18.4_extern int func _int_ int_]
     *  [18.5 为什么有些代码在每次调用 printf() 前, 加了类型转换 (void)？][18.5_printf_ _void]
     *  [18.6 什么是 \`\`匈牙利标志法" (Hungarian Notation)？是否值得用？][18.6_ _Hungarian Notation]
     *  [18.7 哪里可以找到 \`\`印第安山风格指南" (Indian Hill Style Guide) 及其它编码标准？][18.7_ _Indian Hill Style Guide_]
     *  [18.8 有些人说 goto 是邪恶的, 我应该永不用它。那是否太极端了？][18.8_goto_]
    
      
    
 *  [19. 工具和资源][19.]
    
     *  [19.1 常用工具列表。][19.1]
     *  [19.2 怎样抓捕棘手的 malloc 问题？][19.2_malloc]
     *  [19.3 有什么免费或便宜的编译器可以使用？][19.3]
     *  [19.4 刚刚输入完一个程序, 但它表现的很奇怪。你可以发现有什么错误的地方吗？][19.4_]
     *  [19.5 哪里可以找到兼容 ANSI 的 lint？][19.5_ANSI_lint]
     *  [19.6 难道 ANSI 函数原型说明没有使 lint 过时吗？][19.6_ANSI_lint]
     *  [19.7 网上有哪些 C 的教程或其它资源？][19.7_C]
     *  [19.8 哪里可以找到好的源代码实例, 以供研究和学习？][19.8_]
     *  [19.9 有什么好的学习 C 的书？有哪些高级的书和参考？][19.9_C]
     *  [19.10 哪里可以找到标准 C 函数库的源代码？][19.10_C]
     *  [19.11 是否有一个在线的 C 参考指南？][19.11_C]
     *  [19.12 哪里可以得到 ANSI/ISO C 标准？][19.12_ANSI_ISO C]
     *  [19.13 我需要分析和评估表达式的代码。][19.13]
     *  [19.14 哪里可以找到 C 的 BNF 或 YACC 语法？][19.14_C_BNF_YACC]
     *  [19.15 谁有 C 编译器的测试套件？][19.15_C]
     *  [19.16 哪里有一些有用的源代码片段和例子的收集？][19.16]
     *  [19.17 我需要执行多精度算术的代码。][19.17]
     *  [19.18 在哪里和怎样取得这些可自由发布的程序？][19.18]
    
      
    
 *  [20. 系统依赖][20.]
    
     *  [20.1 怎样从键盘直接读入字符而不用等 RETURN 键？怎样 防止字符输入时的回显？][20.1_RETURN_]
     *  [20.2 怎样知道有未读的字符, 如果有, 有多少？如果没有字符, 怎样使读入不阻断？][20.2_ _ _]
     *  [20.3 怎样显示一个百分比或 \`\`转动的短棒" 的进展表示器？][20.3]
     *  [20.4 怎样清屏？怎样输出彩色文本？怎样移动光标到指定位置？][20.4]
     *  [20.5 怎样读入方向键, 功能键？][20.5_]
     *  [20.6 怎样读入鼠标输入？][20.6]
     *  [20.7 怎样做串口 (\`\`comm") 的输入输出？][20.7_comm]
     *  [20.8 怎样直接输出到打印机？][20.8]
     *  [20.9 怎样发送控制终端或其它设备的逃逸指令序列？][20.9]
     *  [20.10 怎样直接访问输入输出板？][20.10]
     *  [20.11 怎样做图形？][20.11]
     *  [20.12 怎样显示 GIF 和 JPEG 图象？][20.12_GIF_JPEG]
     *  [20.13 怎样检验一个文件是否存在？][20.13]
     *  [20.14 怎样在读入文件前, 知道文件大小？][20.14_]
     *  [20.15 怎样得到文件的修改日期和时间？][20.15]
     *  [20.16 怎样缩短一个文件而不用清除或重写？][20.16]
     *  [20.17 怎样在文件中插入或删除一行 (或记录)？][20.17]
     *  [20.18 怎样从一个打开的流或文件描述符得到文件名？][20.18]
     *  [20.19 怎样删除一个文件？][20.19]
     *  [20.20 怎样复制一个文件？][20.20]
     *  [20.21 为什么用了详尽的路径还不能打开文件？  fopen("c:\\ newdir \\file.dat", "r")  返回错误。][20.21_ _fopen_c_newdir_file.dat_r_]
     *  [20.22 fopen() 不让我打开文件: "$HOME/.profile"  和 "~/ .myrcfile"。][20.22_fopen_HOME_.profile_ _.myrcfile]
     *  [20.23 怎样制止 MS-DOS 下令人担忧的 \`\`Abort, Retry, Ignore?" 信息？][20.23_MS-DOS_Abort_ Retry_ Ignore]
     *  [20.24 遇到 \`\`Too many open files (打开文件太多）" 的错误, 怎样增加同时打开文件的允许数目？][20.24_Too many open files _]
     *  [20.25 怎样在 C 中读入目录？][20.25_C]
     *  [20.26 怎样找出系统还有多少内存可用？][20.26]
     *  [20.27 怎样分配大于 64K 的数组或结构？][20.27_64K]
     *  [20.28 错误信息 \`\`DGROUP data allocation exceeds 64K (DGROUP 数据分配内存超过 64K)" 说明什么？我应该 怎么做？我以为使用了大内存模型, 那我就可以使用多于 64K 的数据！][20.28_DGROUP data allocation exceeds 64K _DGROUP _64K_ _ _64K]
     *  [20.29 怎样访问位于某的特定地址的内存 (内存映射的设备或图显内存)？][20.29]
     *  [20.30 怎样在一个 C 程序中调用另一个程序 (独立可执行的程序, 或系统命令)？][20.30_C_]
     *  [20.31 怎样调用另一个程序或命令, 同时收集它的输出？][20.31_]
     *  [20.32 怎样才能发现程序自己的执行文件的全路径？][20.32]
     *  [20.33 怎样找出和执行文件在同一目录的配置文件？][20.33]
     *  [20.34 一个进程如何改变它的调用者的环境变量？][20.34]
     *  [20.35 怎样读入一个对象文件并跳跃到其中的地址？][20.35]
     *  [20.36 怎样实现精度小于秒的延时或记录用户回应的时间？][20.36]
     *  [20.37 怎样抓获或忽略像 control-C 这样的键盘中断？][20.37_control-C]
     *  [20.38 怎样很好地处理浮点异常？][20.38]
     *  [20.39 怎样使用 socket？ 网络化？ 写客户/服务器程序？][20.39_socket_ _]
     *  [20.40 怎样调用 BIOS 函数？写 ISR？创建 TSR？][20.40_BIOS_ISR_TSR]
     *  [20.41 编译程序, 编译器出示 \`\`union REGS" 未定义错误信息, 连接器出示 \`\`int86()" 的未定义错误信息。][20.41_ _union REGS_ _int86]
     *  [20.42 什么是 \`\`near" 和 \`\`far" 指针？][20.42_near_far]
     *  [20.43 我不能使用这些非标准、依赖系统的函数, 程序需要兼容 ANSI!][20.43_ _ANSI]
    
      
    
 *  [21. 杂项][21.]
    
     *  [21.1 怎样从一个函数返回多个值？][21.1]
     *  [21.2 怎样访问命令行参数？][21.2]
     *  [21.3 怎样写数据文件, 使之可以在不同字大小、字节顺序或浮点 格式的机器上读入？][21.3_ _]
     *  [21.4 怎样调用一个由 char \* 指针指向函数名的函数？][21.4_char]
     *  [21.5 怎样实现比特数组或集合？][21.5]
     *  [21.6 怎样判断机器的字节顺序是高字节在前还是低字节在前？][21.6]
     *  [21.7 怎样掉换字节？][21.7]
     *  [21.8 怎样转换整数到二进制或十六进制？][21.8]
     *  [21.9 我可以使用二进制常数吗？有 printf() 的二 进制的格式符吗？][21.9_printf_]
     *  [21.10 什么是计算整数中比特为 1 的个数的最有效的方法？][21.10_1]
     *  [21.11 什么是提高程序效率的最好方法？][21.11]
     *  [21.12 指针真得比数组快吗？函数调用会拖慢程序多少？  ++i 比 i = i +1 快吗？][21.12_ _i_i _ i _1]
     *  [21.13 人们说编译器优化的很好, 我们不在 需要为速度而写汇编了, 但我的编译器连用移位代替  i/=2 都做不到。][21.13_ _ _ _ _i_2]
     *  [21.14 怎样不用临时变量而交换两个值？][21.14]
     *  [21.15 是否有根据字符串做切换的方法？][21.15]
     *  [21.16 是否有使用非常量 case 标志的方法  (例如范围或任意的表达式)？][21.16_case_]
     *  [21.17 return 语句外层的括号是否真的可选择？][21.17_return]
     *  [21.18 为什么 C 注释不能嵌套？怎样注释掉含有注释的代码？引用字符串 内的注释是否合法？][21.18_C_]
     *  [21.19 C 是个伟大的语言还是别的？哪个其它语言可以写象  a+++++b 这样的代码？][21.19_C_ _a_b]
     *  [21.20 为什么 C 没有嵌套函数？][21.20_C]
     *  [21.21 assert() 是什么？怎样用它？][21.21_assert]
     *  [21.22 怎样从 C 中调用 FORTRAN (C++, BASIC, Pascal, Ada, LISP) 的函数？反之亦然？][21.22_C_FORTRAN _C_ BASIC_ Pascal_ Ada_ LISP_]
     *  [21.23 有什么程序可以做从 Pascal 或 Fortran (或 LISP, Ada, awk, \`\`老" C) 到 C 的转换？][21.23_Pascal_Fortran_LISP_ Ada_ awk_ _ C_C]
     *  [21.24 C++ 是 C 的超集吗？可以用 C++ 编译器来编译 C 代码吗？][21.24_C_C_C_C]
     *  [21.25 需要用到 \`\`近似" 的 strcmp, 比较两个字符串的近似度, 并不需要完全一样。][21.25_strcmp_ _]
     *  [21.26 什么是散列法？][21.26]
     *  [21.27 由一个日期, 怎样知道是星期几？][21.27_]
     *  [21.28 (year%4 == 0) 是否足够判断润年？2000 年是闰年吗？][21.28_year_4 _ 0_2000]
     *  [21.29 一个难题: 怎样写一个输出自己源代码的程序？][21.29_]
     *  [21.30 什么是 \`\`达夫设备" (Duff's Device)？][21.30_ _Duff_s Device]
     *  [21.31 下届国际 C 混乱代码竞赛 (IOCCC) 什么时候进行？哪里可以找到当前和 以前的获胜代码？][21.31_C_IOCCC_]
     *  [21.32 \[K&R1\]  提到的关健字 entry 是什么？][21.32_K_R1_ _entry]
     *  [21.33 C 的名字从何而来？][21.33_C]
     *  [21.34 \`\`char" 如何发音？][21.34_char]
     *  [21.35 \`\`lvalue" 和 \`\`rvalue" 代表什么意思？][21.35_lvalue_rvalue]
     *  [21.36 哪里可以取得本 FAQ (英文版) 的额外副本？][21.36_FAQ]
    
      
    
 *  [22. 感谢][22.]
 *  [文献][Link 2]

[http_tieba.baidu.com_p_1699650877]: http://jump.bdimg.com/safecheck/index?url=x+Z5mMbGPAs95UolpNuq+CwM2BpViN6QF0BYrUCVRu+cfyP267TRsKdVp2Fr+jY+T9PR10UbgCVAbiD7O61qc5DyqawPc1zkwy+wzuuHIgPp6QW1p3H4Op0IwWYmbzH4i4lb8jpPDoh0ZkIQAvkr7nY9qHh6BM0y
[http_tieba.baidu.com_p_1699671617]: http://jump.bdimg.com/safecheck/index?url=x+Z5mMbGPAs95UolpNuq+CwM2BpViN6QF0BYrUCVRu+cfyP267TRsACbFExlbulcT9PR10UbgCVAbiD7O61qc5DyqawPc1zkwy+wzuuHIgPp6QW1p3H4Op0IwWYmbzH4i4lb8jpPDoh0ZkIQAvkr7nY9qHh6BM0y
[http_tieba.baidu.com_p_1699674924]: http://jump.bdimg.com/safecheck/index?url=x+Z5mMbGPAs95UolpNuq+CwM2BpViN6QF0BYrUCVRu+cfyP267TRsOVYkRjnmA+OT9PR10UbgCVAbiD7O61qc5DyqawPc1zkwy+wzuuHIgPp6QW1p3H4Op0IwWYmbzH4i4lb8jpPDoh0ZkIQAvkr7nY9qHh6BM0y
[http_tieba.baidu.com_p_1699677781]: http://jump.bdimg.com/safecheck/index?url=x+Z5mMbGPAs95UolpNuq+CwM2BpViN6QF0BYrUCVRu+cfyP267TRsDEhBeUPyOxzT9PR10UbgCVAbiD7O61qc5DyqawPc1zkwy+wzuuHIgPp6QW1p3H4Op0IwWYmbzH4i4lb8jpPDoh0ZkIQAvkr7nY9qHh6BM0y
[http_tieba.baidu.com_p_1699679658]: http://jump.bdimg.com/safecheck/index?url=x+Z5mMbGPAs95UolpNuq+CwM2BpViN6QF0BYrUCVRu+cfyP267TRsBXUc0X9wmQcT9PR10UbgCVAbiD7O61qc5DyqawPc1zkwy+wzuuHIgPp6QW1p3H4Op0IwWYmbzH4i4lb8jpPDoh0ZkIQAvkr7nY9qHh6BM0y
[http_tieba.baidu.com_p_1699689740]: http://jump.bdimg.com/safecheck/index?url=x+Z5mMbGPAs95UolpNuq+CwM2BpViN6QF0BYrUCVRu+cfyP267TRsPOpL5Y6bqZBT9PR10UbgCVAbiD7O61qc5DyqawPc1zkwy+wzuuHIgPp6QW1p3H4Op0IwWYmbzH4i4lb8jpPDoh0ZkIQAvkr7nY9qHh6BM0y
[http_tieba.baidu.com_p_1699695288]: http://jump.bdimg.com/safecheck/index?url=x+Z5mMbGPAs95UolpNuq+CwM2BpViN6QF0BYrUCVRu+cfyP267TRsL3afWBAK7ejT9PR10UbgCVAbiD7O61qc5DyqawPc1zkwy+wzuuHIgPp6QW1p3H4Op0IwWYmbzH4i4lb8jpPDoh0ZkIQAvkr7nY9qHh6BM0y
[http_tieba.baidu.com_p_1699696963]: http://jump.bdimg.com/safecheck/index?url=x+Z5mMbGPAs95UolpNuq+CwM2BpViN6QF0BYrUCVRu+cfyP267TRsCo45DQhjZnOT9PR10UbgCVAbiD7O61qc5DyqawPc1zkwy+wzuuHIgPp6QW1p3H4Op0IwWYmbzH4i4lb8jpPDoh0ZkIQAvkr7nY9qHh6BM0y
[http_tieba.baidu.com_p_1699700204]: http://jump.bdimg.com/safecheck/index?url=x+Z5mMbGPAs95UolpNuq+CwM2BpViN6QF0BYrUCVRu/rqL8KmT/amHkGDRANZKBRT9PR10UbgCVAbiD7O61qc5DyqawPc1zkwy+wzuuHIgPp6QW1p3H4Op0IwWYmbzH4i4lb8jpPDoh0ZkIQAvkr7nY9qHh6BM0y
[hacker_s delight]: http://blog.csdn.net/uestc_huan/article/details/48190609
[Link 1]: http://c-faq-chn.sourceforge.net/ccfaq/node1.html
[1.]: http://c-faq-chn.sourceforge.net/ccfaq/node2.html
[2.]: http://c-faq-chn.sourceforge.net/ccfaq/node3.html
[2.1]: http://c-faq-chn.sourceforge.net/ccfaq/node4.html
[2.2_64_64]: http://c-faq-chn.sourceforge.net/ccfaq/node5.html
[2.3]: http://c-faq-chn.sourceforge.net/ccfaq/node6.html
[2.4_extern]: http://c-faq-chn.sourceforge.net/ccfaq/node7.html
[2.5_auto]: http://c-faq-chn.sourceforge.net/ccfaq/node8.html
[2.6_ _typedef struct _ char _item_ NODEPTR next_ _ _NODEPTR_C_]: http://c-faq-chn.sourceforge.net/ccfaq/node9.html
[2.7_N_]: http://c-faq-chn.sourceforge.net/ccfaq/node10.html
[2.8_ _]: http://c-faq-chn.sourceforge.net/ccfaq/node11.html
[2.9_main_ _void main]: http://c-faq-chn.sourceforge.net/ccfaq/node12.html
[2.10_ _]: http://c-faq-chn.sourceforge.net/ccfaq/node13.html
[2.11_int f_ _ char a_ _Hello_ world]: http://c-faq-chn.sourceforge.net/ccfaq/node14.html
[2.12_char _p _ malloc_10_]: http://c-faq-chn.sourceforge.net/ccfaq/node15.html
[2.13_char a_ _string literal_ char _p _string literal_ _p_i_ _]: http://c-faq-chn.sourceforge.net/ccfaq/node16.html
[2.14_]: http://c-faq-chn.sourceforge.net/ccfaq/node17.html
[3.]: http://c-faq-chn.sourceforge.net/ccfaq/node18.html
[3.1_struct x1 _ ..._typedef struct _ ..._ x2_]: http://c-faq-chn.sourceforge.net/ccfaq/node19.html
[3.2_struct x _ ..._ x thestruct]: http://c-faq-chn.sourceforge.net/ccfaq/node20.html
[3.3]: http://c-faq-chn.sourceforge.net/ccfaq/node21.html
[3.4_C]: http://c-faq-chn.sourceforge.net/ccfaq/node22.html
[3.5_C]: http://c-faq-chn.sourceforge.net/ccfaq/node23.html
[3.6_ struct name _ int namelen_ char namestr_1_namestr_]: http://c-faq-chn.sourceforge.net/ccfaq/node24.html
[3.7]: http://c-faq-chn.sourceforge.net/ccfaq/node25.html
[3.8]: http://c-faq-chn.sourceforge.net/ccfaq/node26.html
[3.9]: http://c-faq-chn.sourceforge.net/ccfaq/node27.html
[3.10_ _ _ _]: http://c-faq-chn.sourceforge.net/ccfaq/node28.html
[3.11_sizeof_]: http://c-faq-chn.sourceforge.net/ccfaq/node29.html
[3.12]: http://c-faq-chn.sourceforge.net/ccfaq/node30.html
[3.13]: http://c-faq-chn.sourceforge.net/ccfaq/node31.html
[3.14_ _core dump]: http://c-faq-chn.sourceforge.net/ccfaq/node32.html
[3.15]: http://c-faq-chn.sourceforge.net/ccfaq/node33.html
[3.16_define]: http://c-faq-chn.sourceforge.net/ccfaq/node34.html
[3.17]: http://c-faq-chn.sourceforge.net/ccfaq/node35.html
[4.]: http://c-faq-chn.sourceforge.net/ccfaq/node36.html
[4.1_ _a_i_ _ i]: http://c-faq-chn.sourceforge.net/ccfaq/node37.html
[4.2_ _int i_7_ printf_d_n_ i_ _ i_49_ _56]: http://c-faq-chn.sourceforge.net/ccfaq/node38.html
[4.3_ _int i _ 3_ i _ i_ _3_ _4_]: http://c-faq-chn.sourceforge.net/ccfaq/node39.html
[4.4_ _a _ b _ a _ b_ _a_b]: http://c-faq-chn.sourceforge.net/ccfaq/node40.html
[4.5]: http://c-faq-chn.sourceforge.net/ccfaq/node41.html
[4.6_ _ _while_c _ getchar_ _ EOF _ c _n_]: http://c-faq-chn.sourceforge.net/ccfaq/node42.html
[4.7]: http://c-faq-chn.sourceforge.net/ccfaq/node43.html
[4.8_ _a_i_ _ i_a_ _i_1_]: http://c-faq-chn.sourceforge.net/ccfaq/node44.html
[4.9_i_i]: http://c-faq-chn.sourceforge.net/ccfaq/node45.html
[4.10_ _i_i_]: http://c-faq-chn.sourceforge.net/ccfaq/node46.html
[4.11_ int a _ 100_ b _ 100_ long int c _ a _ b]: http://c-faq-chn.sourceforge.net/ccfaq/node47.html
[4.12_ _ _condition_ _ a _ b_ _ complicated_expression]: http://c-faq-chn.sourceforge.net/ccfaq/node48.html
[5.]: http://c-faq-chn.sourceforge.net/ccfaq/node49.html
[5.1_ _ char _p_ _p _ malloc_10]: http://c-faq-chn.sourceforge.net/ccfaq/node50.html
[5.2_p_p_p]: http://c-faq-chn.sourceforge.net/ccfaq/node51.html
[5.3_char _int_ _ _ _int _p_]: http://c-faq-chn.sourceforge.net/ccfaq/node52.html
[5.4_ _void f_int _ip_ _ static int dummy _ 5_ ip _ _dummy_ _ int _ip_ f_ip_]: http://c-faq-chn.sourceforge.net/ccfaq/node53.html
[5.5_void_ _]: http://c-faq-chn.sourceforge.net/ccfaq/node54.html
[5.6_extern int f_int _ _int_ _f_5]: http://c-faq-chn.sourceforge.net/ccfaq/node55.html
[5.7_C]: http://c-faq-chn.sourceforge.net/ccfaq/node56.html
[5.8]: http://c-faq-chn.sourceforge.net/ccfaq/node57.html
[5.9_int_char _ _]: http://c-faq-chn.sourceforge.net/ccfaq/node58.html
[6. _null]: http://c-faq-chn.sourceforge.net/ccfaq/node59.html
[6.1]: http://c-faq-chn.sourceforge.net/ccfaq/node60.html
[6.2]: http://c-faq-chn.sourceforge.net/ccfaq/node61.html
[6.3_if_p_ _0]: http://c-faq-chn.sourceforge.net/ccfaq/node62.html
[6.4_NULL_]: http://c-faq-chn.sourceforge.net/ccfaq/node63.html
[6.5_ NULL]: http://c-faq-chn.sourceforge.net/ccfaq/node64.html
[6.6_NULL_define NULL _char _0_ _NULL]: http://c-faq-chn.sourceforge.net/ccfaq/node65.html
[6.7_NULL_0_]: http://c-faq-chn.sourceforge.net/ccfaq/node66.html
[6.8_NULL_ _ _NULL _0]: http://c-faq-chn.sourceforge.net/ccfaq/node67.html
[6.9_define Nullptr_type_ _type _0_]: http://c-faq-chn.sourceforge.net/ccfaq/node68.html
[6.10_NULL_0_ _null]: http://c-faq-chn.sourceforge.net/ccfaq/node69.html
[6.11]: http://c-faq-chn.sourceforge.net/ccfaq/node70.html
[6.12]: http://c-faq-chn.sourceforge.net/ccfaq/node71.html
[6.13_ _ _0]: http://c-faq-chn.sourceforge.net/ccfaq/node72.html
[6.14_ _]: http://c-faq-chn.sourceforge.net/ccfaq/node73.html
[6.15]: http://c-faq-chn.sourceforge.net/ccfaq/node74.html
[7.]: http://c-faq-chn.sourceforge.net/ccfaq/node75.html
[7.1_char a_6_ _ _extern char _a_]: http://c-faq-chn.sourceforge.net/ccfaq/node76.html
[7.2_char a_ _char _a]: http://c-faq-chn.sourceforge.net/ccfaq/node77.html
[7.3_ _C_]: http://c-faq-chn.sourceforge.net/ccfaq/node78.html
[7.4_]: http://c-faq-chn.sourceforge.net/ccfaq/node79.html
[7.5_ _]: http://c-faq-chn.sourceforge.net/ccfaq/node80.html
[7.6_ _]: http://c-faq-chn.sourceforge.net/ccfaq/node81.html
[7.7_]: http://c-faq-chn.sourceforge.net/ccfaq/node82.html
[7.8_ _5_abcdef_ _ _C_]: http://c-faq-chn.sourceforge.net/ccfaq/node83.html
[7.9_ _arr_ _arr_arr_ _]: http://c-faq-chn.sourceforge.net/ccfaq/node84.html
[7.10_]: http://c-faq-chn.sourceforge.net/ccfaq/node85.html
[7.11_ _ _]: http://c-faq-chn.sourceforge.net/ccfaq/node86.html
[7.12_]: http://c-faq-chn.sourceforge.net/ccfaq/node87.html
[7.13_]: http://c-faq-chn.sourceforge.net/ccfaq/node88.html
[7.14_ _ _int realarray_10_ int _array _ _realarray_-1_ _array_1]: http://c-faq-chn.sourceforge.net/ccfaq/node89.html
[7.15_]: http://c-faq-chn.sourceforge.net/ccfaq/node90.html
[7.16_]: http://c-faq-chn.sourceforge.net/ccfaq/node91.html
[7.17_]: http://c-faq-chn.sourceforge.net/ccfaq/node92.html
[7.18_ _sizeof_]: http://c-faq-chn.sourceforge.net/ccfaq/node93.html
[8.]: http://c-faq-chn.sourceforge.net/ccfaq/node94.html
[8.1_char _answer_ printf_Type something_n_ gets_answer_ printf_You typed _s_n_ answer]: http://c-faq-chn.sourceforge.net/ccfaq/node95.html
[8.2_strcat_._ _char _s1 _Hello_ char _s2 _world_ char _s3 _ strcat_s1_ s2_]: http://c-faq-chn.sourceforge.net/ccfaq/node96.html
[8.3_strcat_char _]: http://c-faq-chn.sourceforge.net/ccfaq/node97.html
[8.4_ char _p_ strcpy_p_abc_]: http://c-faq-chn.sourceforge.net/ccfaq/node98.html
[8.5]: http://c-faq-chn.sourceforge.net/ccfaq/node99.html
[8.6_ _ _]: http://c-faq-chn.sourceforge.net/ccfaq/node100.html
[8.7]: http://c-faq-chn.sourceforge.net/ccfaq/node101.html
[8.8_malloc_ _]: http://c-faq-chn.sourceforge.net/ccfaq/node102.html
[8.9_malloc]: http://c-faq-chn.sourceforge.net/ccfaq/node103.html
[8.10_malloc_ _void _int _]: http://c-faq-chn.sourceforge.net/ccfaq/node104.html
[8.11_ _char _p _ malloc_strlen_s_ _ 1_ strcpy_p_ s_ _malloc_strlen_s_ _ 1_ _ sizeof_char]: http://c-faq-chn.sourceforge.net/ccfaq/node105.html
[8.12]: http://c-faq-chn.sourceforge.net/ccfaq/node106.html
[8.13_malloc_]: http://c-faq-chn.sourceforge.net/ccfaq/node107.html
[8.14_ _ _double _array _ malloc_300 _ 300 _ sizeof_ double _ malloc_null_ _ _ _malloc_]: http://c-faq-chn.sourceforge.net/ccfaq/node108.html
[8.15_PC_8_640K]: http://c-faq-chn.sourceforge.net/ccfaq/node109.html
[8.16_ _malloc_ _ _malloc_bug]: http://c-faq-chn.sourceforge.net/ccfaq/node110.html
[8.17_]: http://c-faq-chn.sourceforge.net/ccfaq/node111.html
[8.18_free_ _]: http://c-faq-chn.sourceforge.net/ccfaq/node112.html
[8.19_malloc_ _ _free]: http://c-faq-chn.sourceforge.net/ccfaq/node113.html
[8.20_ _ _]: http://c-faq-chn.sourceforge.net/ccfaq/node114.html
[8.21]: http://c-faq-chn.sourceforge.net/ccfaq/node115.html
[8.22_ _]: http://c-faq-chn.sourceforge.net/ccfaq/node116.html
[8.23_free]: http://c-faq-chn.sourceforge.net/ccfaq/node117.html
[8.24_malloc_]: http://c-faq-chn.sourceforge.net/ccfaq/node118.html
[8.25_realloc]: http://c-faq-chn.sourceforge.net/ccfaq/node119.html
[8.26_calloc_malloc_calloc_ free_calloc_ _cfree]: http://c-faq-chn.sourceforge.net/ccfaq/node120.html
[8.27_alloca]: http://c-faq-chn.sourceforge.net/ccfaq/node121.html
[9.]: http://c-faq-chn.sourceforge.net/ccfaq/node122.html
[9.1_strcat_string]: http://c-faq-chn.sourceforge.net/ccfaq/node123.html
[9.2_ _ char _string_ ... if_string _value_ _ _ string matches _value_ _ ...]: http://c-faq-chn.sourceforge.net/ccfaq/node124.html
[9.3_ _char a_ _Hello_ world_ _ _char a_14_ a _Hello_ world]: http://c-faq-chn.sourceforge.net/ccfaq/node125.html
[9.4_]: http://c-faq-chn.sourceforge.net/ccfaq/node126.html
[9.5_ _sizeof_a_2_ _1_ _sizeof_char]: http://c-faq-chn.sourceforge.net/ccfaq/node127.html
[10.]: http://c-faq-chn.sourceforge.net/ccfaq/node128.html
[10.1_C_ _define_enum_true_false]: http://c-faq-chn.sourceforge.net/ccfaq/node129.html
[10.2_C_ _TRUE_ _1_1_]: http://c-faq-chn.sourceforge.net/ccfaq/node130.html
[10.3_p_if_p]: http://c-faq-chn.sourceforge.net/ccfaq/node131.html
[11. C]: http://c-faq-chn.sourceforge.net/ccfaq/node132.html
[11.1_ _define begin _ _define end _]: http://c-faq-chn.sourceforge.net/ccfaq/node133.html
[11.2]: http://c-faq-chn.sourceforge.net/ccfaq/node134.html
[11.3]: http://c-faq-chn.sourceforge.net/ccfaq/node135.html
[11.4_ _.c_ _.h_.h]: http://c-faq-chn.sourceforge.net/ccfaq/node136.html
[11.5]: http://c-faq-chn.sourceforge.net/ccfaq/node137.html
[11.6_include _include]: http://c-faq-chn.sourceforge.net/ccfaq/node138.html
[11.7]: http://c-faq-chn.sourceforge.net/ccfaq/node139.html
[11.8_]: http://c-faq-chn.sourceforge.net/ccfaq/node140.html
[11.9_]: http://c-faq-chn.sourceforge.net/ccfaq/node141.html
[11.10_ _]: http://c-faq-chn.sourceforge.net/ccfaq/node142.html
[11.11_if]: http://c-faq-chn.sourceforge.net/ccfaq/node143.html
[11.12_sizeof_if]: http://c-faq-chn.sourceforge.net/ccfaq/node144.html
[11.13_include_ifdef]: http://c-faq-chn.sourceforge.net/ccfaq/node145.html
[11.14_typdef_ifdef]: http://c-faq-chn.sourceforge.net/ccfaq/node146.html
[11.15_if]: http://c-faq-chn.sourceforge.net/ccfaq/node147.html
[11.16_ _ifdef_ _ _include_ifdef_ _]: http://c-faq-chn.sourceforge.net/ccfaq/node148.html
[11.17]: http://c-faq-chn.sourceforge.net/ccfaq/node149.html
[11.18_ _ _define Paste_a_ b_ a_b]: http://c-faq-chn.sourceforge.net/ccfaq/node150.html
[11.19_ _define TRACE_n_ printf_TRACE_ _d_n_ n_ _ TRACE_count_ _ printf_TRACE_ _d_count_ count]: http://c-faq-chn.sourceforge.net/ccfaq/node151.html
[11.20_]: http://c-faq-chn.sourceforge.net/ccfaq/node152.html
[11.21_]: http://c-faq-chn.sourceforge.net/ccfaq/node153.html
[11.22]: http://c-faq-chn.sourceforge.net/ccfaq/node154.html
[12. ANSI_ISO_C]: http://c-faq-chn.sourceforge.net/ccfaq/node155.html
[12.1_ANSI C]: http://c-faq-chn.sourceforge.net/ccfaq/node156.html
[12.2]: http://c-faq-chn.sourceforge.net/ccfaq/node157.html
[12.3]: http://c-faq-chn.sourceforge.net/ccfaq/node158.html
[12.4_ANSI_ _extern int func_float_ int func_x_ float x_ _ ...]: http://c-faq-chn.sourceforge.net/ccfaq/node159.html
[12.5]: http://c-faq-chn.sourceforge.net/ccfaq/node160.html
[12.6_ extern int f_struct x _p_ _x]: http://c-faq-chn.sourceforge.net/ccfaq/node161.html
[12.7_ const int n _ 5_ int a_n]: http://c-faq-chn.sourceforge.net/ccfaq/node162.html
[12.8_]: http://c-faq-chn.sourceforge.net/ccfaq/node163.html
[12.9_const char _p_char _ const p]: http://c-faq-chn.sourceforge.net/ccfaq/node164.html
[12.10_const char _char]: http://c-faq-chn.sourceforge.net/ccfaq/node165.html
[12.11_main]: http://c-faq-chn.sourceforge.net/ccfaq/node166.html
[12.12_main_void_ _main]: http://c-faq-chn.sourceforge.net/ccfaq/node167.html
[12.13_main_envp]: http://c-faq-chn.sourceforge.net/ccfaq/node168.html
[12.14_main_void_ _exit_ _return_]: http://c-faq-chn.sourceforge.net/ccfaq/node169.html
[12.15_void main]: http://c-faq-chn.sourceforge.net/ccfaq/node170.html
[12.16_C_void main]: http://c-faq-chn.sourceforge.net/ccfaq/node171.html
[12.17_main_ exit_status_status]: http://c-faq-chn.sourceforge.net/ccfaq/node172.html
[12.18_ANSI _ _]: http://c-faq-chn.sourceforge.net/ccfaq/node173.html
[12.19_warning_ macro replacement within a string literal]: http://c-faq-chn.sourceforge.net/ccfaq/node174.html
[12.20_ifdef]: http://c-faq-chn.sourceforge.net/ccfaq/node175.html
[12.21_pragma_]: http://c-faq-chn.sourceforge.net/ccfaq/node176.html
[12.22_pragma once]: http://c-faq-chn.sourceforge.net/ccfaq/node177.html
[12.23_a_3_ _abc]: http://c-faq-chn.sourceforge.net/ccfaq/node178.html
[12.24_void]: http://c-faq-chn.sourceforge.net/ccfaq/node179.html
[12.25_memcpy_memmove]: http://c-faq-chn.sourceforge.net/ccfaq/node180.html
[12.26_malloc_0_0_]: http://c-faq-chn.sourceforge.net/ccfaq/node181.html
[12.27_ANSI]: http://c-faq-chn.sourceforge.net/ccfaq/node182.html
[12.28]: http://c-faq-chn.sourceforge.net/ccfaq/node183.html
[12.29_ASNI_ISO_ _ANSI]: http://c-faq-chn.sourceforge.net/ccfaq/node184.html
[12.30_C_ANSI C_]: http://c-faq-chn.sourceforge.net/ccfaq/node185.html
[12.31_ANSI_Frobozz Magic C_ _ANSI_ _gcc]: http://c-faq-chn.sourceforge.net/ccfaq/node186.html
[12.32_implementation-defin-ed_ _unspecified_undefined]: http://c-faq-chn.sourceforge.net/ccfaq/node187.html
[12.33_]: http://c-faq-chn.sourceforge.net/ccfaq/node188.html
[12.34_ ANSI_]: http://c-faq-chn.sourceforge.net/ccfaq/node189.html
[12.35_i _ i_ _ANSI_ _]: http://c-faq-chn.sourceforge.net/ccfaq/node190.html
[13.]: http://c-faq-chn.sourceforge.net/ccfaq/node191.html
[13.1_ char c_ while_c _ getchar_ _ EOF_ ...]: http://c-faq-chn.sourceforge.net/ccfaq/node192.html
[13.2_EOF_ _ _EOF]: http://c-faq-chn.sourceforge.net/ccfaq/node193.html
[13.3_ while_feof_infp_ _ fgets_buf_ MAXLINE_ infp_ fputs_buf_ outfp_ _]: http://c-faq-chn.sourceforge.net/ccfaq/node194.html
[13.4_ _]: http://c-faq-chn.sourceforge.net/ccfaq/node195.html
[13.5]: http://c-faq-chn.sourceforge.net/ccfaq/node196.html
[13.6_printf_ _]: http://c-faq-chn.sourceforge.net/ccfaq/node197.html
[13.7_printf_lf_ _scanf_ _lf_ _printf_f]: http://c-faq-chn.sourceforge.net/ccfaq/node198.html
[13.8_size_t_ _long_ _ _printf]: http://c-faq-chn.sourceforge.net/ccfaq/node199.html
[13.9_printf_ _ _8d]: http://c-faq-chn.sourceforge.net/ccfaq/node200.html
[13.10]: http://c-faq-chn.sourceforge.net/ccfaq/node201.html
[13.11_scanf_d_ i]: http://c-faq-chn.sourceforge.net/ccfaq/node202.html
[13.12_ char s_30_ scanf_s_ s_]: http://c-faq-chn.sourceforge.net/ccfaq/node203.html
[13.13_ double d_ scanf_f_ _d_]: http://c-faq-chn.sourceforge.net/ccfaq/node204.html
[13.14_scanf]: http://c-faq-chn.sourceforge.net/ccfaq/node205.html
[13.15_d_n_scanf_ _]: http://c-faq-chn.sourceforge.net/ccfaq/node206.html
[13.16_scanf _d_ _gets_ _ _gets]: http://c-faq-chn.sourceforge.net/ccfaq/node207.html
[13.17_ _scanf_]: http://c-faq-chn.sourceforge.net/ccfaq/node208.html
[13.18_scanf]: http://c-faq-chn.sourceforge.net/ccfaq/node209.html
[13.19_sprintf_ _sprintf]: http://c-faq-chn.sourceforge.net/ccfaq/node210.html
[13.20_gets]: http://c-faq-chn.sourceforge.net/ccfaq/node211.html
[13.21_printf_errno_ENOTTY]: http://c-faq-chn.sourceforge.net/ccfaq/node212.html
[13.22_fgetops_fsetops_ftell_fseek_fgetops_ _fsetops]: http://c-faq-chn.sourceforge.net/ccfaq/node213.html
[13.23_ _ fflush_stdin]: http://c-faq-chn.sourceforge.net/ccfaq/node214.html
[13.24_fflush_]: http://c-faq-chn.sourceforge.net/ccfaq/node215.html
[13.25_fopen]: http://c-faq-chn.sourceforge.net/ccfaq/node216.html
[13.26_r_ _ _]: http://c-faq-chn.sourceforge.net/ccfaq/node217.html
[13.27_stdin_stdout]: http://c-faq-chn.sourceforge.net/ccfaq/node218.html
[13.28_freopen_ _stdout _stdin]: http://c-faq-chn.sourceforge.net/ccfaq/node219.html
[13.29_]: http://c-faq-chn.sourceforge.net/ccfaq/node220.html
[13.30_0x0a_0x0d_ _0x1a_ _EOF]: http://c-faq-chn.sourceforge.net/ccfaq/node221.html
[14.]: http://c-faq-chn.sourceforge.net/ccfaq/node222.html
[14.1_atoi_itoa]: http://c-faq-chn.sourceforge.net/ccfaq/node223.html
[14.2_strncpy_ _0]: http://c-faq-chn.sourceforge.net/ccfaq/node224.html
[14.3_toupper_ _toupper_tolower]: http://c-faq-chn.sourceforge.net/ccfaq/node225.html
[14.4_ _main_argc_argv]: http://c-faq-chn.sourceforge.net/ccfaq/node226.html
[14.5]: http://c-faq-chn.sourceforge.net/ccfaq/node227.html
[14.6_strcmp_ _qsort_ _]: http://c-faq-chn.sourceforge.net/ccfaq/node228.html
[14.7_qsort_ _qsort_]: http://c-faq-chn.sourceforge.net/ccfaq/node229.html
[14.8]: http://c-faq-chn.sourceforge.net/ccfaq/node230.html
[14.9]: http://c-faq-chn.sourceforge.net/ccfaq/node231.html
[14.10_C]: http://c-faq-chn.sourceforge.net/ccfaq/node232.html
[14.11_localtime_time_t_ _struct tm_ _ctime_time_t_ _ _struct tm_time_t]: http://c-faq-chn.sourceforge.net/ccfaq/node233.html
[14.12_N]: http://c-faq-chn.sourceforge.net/ccfaq/node234.html
[14.13]: http://c-faq-chn.sourceforge.net/ccfaq/node235.html
[14.14]: http://c-faq-chn.sourceforge.net/ccfaq/node236.html
[14.15_rand]: http://c-faq-chn.sourceforge.net/ccfaq/node237.html
[14.16_ _rand_ _ 2_ _ _0_ 1_ 0_ 1_ 0]: http://c-faq-chn.sourceforge.net/ccfaq/node238.html
[14.17]: http://c-faq-chn.sourceforge.net/ccfaq/node239.html
[14.18_ _inlude]: http://c-faq-chn.sourceforge.net/ccfaq/node240.html
[14.19_]: http://c-faq-chn.sourceforge.net/ccfaq/node241.html
[14.20_end]: http://c-faq-chn.sourceforge.net/ccfaq/node242.html
[14.21_printf]: http://c-faq-chn.sourceforge.net/ccfaq/node243.html
[15.]: http://c-faq-chn.sourceforge.net/ccfaq/node244.html
[15.1_float_3.1_ _printf_3.0999999]: http://c-faq-chn.sourceforge.net/ccfaq/node245.html
[15.2_]: http://c-faq-chn.sourceforge.net/ccfaq/node246.html
[15.3_ _include _math.h_ _undefined_ sin_sin]: http://c-faq-chn.sourceforge.net/ccfaq/node247.html
[15.4_]: http://c-faq-chn.sourceforge.net/ccfaq/node248.html
[15.5]: http://c-faq-chn.sourceforge.net/ccfaq/node249.html
[15.6]: http://c-faq-chn.sourceforge.net/ccfaq/node250.html
[15.7_C]: http://c-faq-chn.sourceforge.net/ccfaq/node251.html
[15.8_math.h_ _M_PI]: http://c-faq-chn.sourceforge.net/ccfaq/node252.html
[15.9_IEEE NaN]: http://c-faq-chn.sourceforge.net/ccfaq/node253.html
[15.10_C]: http://c-faq-chn.sourceforge.net/ccfaq/node254.html
[15.11_ _FFT_]: http://c-faq-chn.sourceforge.net/ccfaq/node255.html
[15.12_Turbo C_ _floating point formats not linked_]: http://c-faq-chn.sourceforge.net/ccfaq/node256.html
[16.]: http://c-faq-chn.sourceforge.net/ccfaq/node257.html
[16.1_printf_ _include _stdio.h]: http://c-faq-chn.sourceforge.net/ccfaq/node258.html
[16.2_f_printf_ _float_ _double]: http://c-faq-chn.sourceforge.net/ccfaq/node259.html
[16.3_n_long int_ printf_d_ n_ _ANSI]: http://c-faq-chn.sourceforge.net/ccfaq/node260.html
[16.4]: http://c-faq-chn.sourceforge.net/ccfaq/node261.html
[16.5_printf_ _printf_]: http://c-faq-chn.sourceforge.net/ccfaq/node262.html
[16.6_scanf_ _scanf_]: http://c-faq-chn.sourceforge.net/ccfaq/node263.html
[16.7]: http://c-faq-chn.sourceforge.net/ccfaq/node264.html
[16.8]: http://c-faq-chn.sourceforge.net/ccfaq/node265.html
[16.9_float_ _ _va_arg_argp_ float]: http://c-faq-chn.sourceforge.net/ccfaq/node266.html
[16.10_va_arg]: http://c-faq-chn.sourceforge.net/ccfaq/node267.html
[16.11_]: http://c-faq-chn.sourceforge.net/ccfaq/node268.html
[16.12]: http://c-faq-chn.sourceforge.net/ccfaq/node269.html
[17.]: http://c-faq-chn.sourceforge.net/ccfaq/node270.html
[17.1_]: http://c-faq-chn.sourceforge.net/ccfaq/node271.html
[17.2]: http://c-faq-chn.sourceforge.net/ccfaq/node272.html
[17.3_ _ _main_]: http://c-faq-chn.sourceforge.net/ccfaq/node273.html
[17.4_ _main_]: http://c-faq-chn.sourceforge.net/ccfaq/node274.html
[17.5_ _ _]: http://c-faq-chn.sourceforge.net/ccfaq/node275.html
[17.6_ char _p _hello_ worl_ p_0_ _H_]: http://c-faq-chn.sourceforge.net/ccfaq/node276.html
[17.7_Segmentation violation_ _Bus error_ _General protection fault_]: http://c-faq-chn.sourceforge.net/ccfaq/node277.html
[18.]: http://c-faq-chn.sourceforge.net/ccfaq/node278.html
[18.1_C]: http://c-faq-chn.sourceforge.net/ccfaq/node279.html
[18.2_if_strcmp_s1_ s2]: http://c-faq-chn.sourceforge.net/ccfaq/node280.html
[18.3_if _0 _ x_if _x _ 0]: http://c-faq-chn.sourceforge.net/ccfaq/node281.html
[18.4_extern int func _int_ int_]: http://c-faq-chn.sourceforge.net/ccfaq/node282.html
[18.5_printf_ _void]: http://c-faq-chn.sourceforge.net/ccfaq/node283.html
[18.6_ _Hungarian Notation]: http://c-faq-chn.sourceforge.net/ccfaq/node284.html
[18.7_ _Indian Hill Style Guide_]: http://c-faq-chn.sourceforge.net/ccfaq/node285.html
[18.8_goto_]: http://c-faq-chn.sourceforge.net/ccfaq/node286.html
[19.]: http://c-faq-chn.sourceforge.net/ccfaq/node287.html
[19.1]: http://c-faq-chn.sourceforge.net/ccfaq/node288.html
[19.2_malloc]: http://c-faq-chn.sourceforge.net/ccfaq/node289.html
[19.3]: http://c-faq-chn.sourceforge.net/ccfaq/node290.html
[19.4_]: http://c-faq-chn.sourceforge.net/ccfaq/node291.html
[19.5_ANSI_lint]: http://c-faq-chn.sourceforge.net/ccfaq/node292.html
[19.6_ANSI_lint]: http://c-faq-chn.sourceforge.net/ccfaq/node293.html
[19.7_C]: http://c-faq-chn.sourceforge.net/ccfaq/node294.html
[19.8_]: http://c-faq-chn.sourceforge.net/ccfaq/node295.html
[19.9_C]: http://c-faq-chn.sourceforge.net/ccfaq/node296.html
[19.10_C]: http://c-faq-chn.sourceforge.net/ccfaq/node297.html
[19.11_C]: http://c-faq-chn.sourceforge.net/ccfaq/node298.html
[19.12_ANSI_ISO C]: http://c-faq-chn.sourceforge.net/ccfaq/node299.html
[19.13]: http://c-faq-chn.sourceforge.net/ccfaq/node300.html
[19.14_C_BNF_YACC]: http://c-faq-chn.sourceforge.net/ccfaq/node301.html
[19.15_C]: http://c-faq-chn.sourceforge.net/ccfaq/node302.html
[19.16]: http://c-faq-chn.sourceforge.net/ccfaq/node303.html
[19.17]: http://c-faq-chn.sourceforge.net/ccfaq/node304.html
[19.18]: http://c-faq-chn.sourceforge.net/ccfaq/node305.html
[20.]: http://c-faq-chn.sourceforge.net/ccfaq/node306.html
[20.1_RETURN_]: http://c-faq-chn.sourceforge.net/ccfaq/node307.html
[20.2_ _ _]: http://c-faq-chn.sourceforge.net/ccfaq/node308.html
[20.3]: http://c-faq-chn.sourceforge.net/ccfaq/node309.html
[20.4]: http://c-faq-chn.sourceforge.net/ccfaq/node310.html
[20.5_]: http://c-faq-chn.sourceforge.net/ccfaq/node311.html
[20.6]: http://c-faq-chn.sourceforge.net/ccfaq/node312.html
[20.7_comm]: http://c-faq-chn.sourceforge.net/ccfaq/node313.html
[20.8]: http://c-faq-chn.sourceforge.net/ccfaq/node314.html
[20.9]: http://c-faq-chn.sourceforge.net/ccfaq/node315.html
[20.10]: http://c-faq-chn.sourceforge.net/ccfaq/node316.html
[20.11]: http://c-faq-chn.sourceforge.net/ccfaq/node317.html
[20.12_GIF_JPEG]: http://c-faq-chn.sourceforge.net/ccfaq/node318.html
[20.13]: http://c-faq-chn.sourceforge.net/ccfaq/node319.html
[20.14_]: http://c-faq-chn.sourceforge.net/ccfaq/node320.html
[20.15]: http://c-faq-chn.sourceforge.net/ccfaq/node321.html
[20.16]: http://c-faq-chn.sourceforge.net/ccfaq/node322.html
[20.17]: http://c-faq-chn.sourceforge.net/ccfaq/node323.html
[20.18]: http://c-faq-chn.sourceforge.net/ccfaq/node324.html
[20.19]: http://c-faq-chn.sourceforge.net/ccfaq/node325.html
[20.20]: http://c-faq-chn.sourceforge.net/ccfaq/node326.html
[20.21_ _fopen_c_newdir_file.dat_r_]: http://c-faq-chn.sourceforge.net/ccfaq/node327.html
[20.22_fopen_HOME_.profile_ _.myrcfile]: http://c-faq-chn.sourceforge.net/ccfaq/node328.html
[20.23_MS-DOS_Abort_ Retry_ Ignore]: http://c-faq-chn.sourceforge.net/ccfaq/node329.html
[20.24_Too many open files _]: http://c-faq-chn.sourceforge.net/ccfaq/node330.html
[20.25_C]: http://c-faq-chn.sourceforge.net/ccfaq/node331.html
[20.26]: http://c-faq-chn.sourceforge.net/ccfaq/node332.html
[20.27_64K]: http://c-faq-chn.sourceforge.net/ccfaq/node333.html
[20.28_DGROUP data allocation exceeds 64K _DGROUP _64K_ _ _64K]: http://c-faq-chn.sourceforge.net/ccfaq/node334.html
[20.29]: http://c-faq-chn.sourceforge.net/ccfaq/node335.html
[20.30_C_]: http://c-faq-chn.sourceforge.net/ccfaq/node336.html
[20.31_]: http://c-faq-chn.sourceforge.net/ccfaq/node337.html
[20.32]: http://c-faq-chn.sourceforge.net/ccfaq/node338.html
[20.33]: http://c-faq-chn.sourceforge.net/ccfaq/node339.html
[20.34]: http://c-faq-chn.sourceforge.net/ccfaq/node340.html
[20.35]: http://c-faq-chn.sourceforge.net/ccfaq/node341.html
[20.36]: http://c-faq-chn.sourceforge.net/ccfaq/node342.html
[20.37_control-C]: http://c-faq-chn.sourceforge.net/ccfaq/node343.html
[20.38]: http://c-faq-chn.sourceforge.net/ccfaq/node344.html
[20.39_socket_ _]: http://c-faq-chn.sourceforge.net/ccfaq/node345.html
[20.40_BIOS_ISR_TSR]: http://c-faq-chn.sourceforge.net/ccfaq/node346.html
[20.41_ _union REGS_ _int86]: http://c-faq-chn.sourceforge.net/ccfaq/node347.html
[20.42_near_far]: http://c-faq-chn.sourceforge.net/ccfaq/node348.html
[20.43_ _ANSI]: http://c-faq-chn.sourceforge.net/ccfaq/node349.html
[21.]: http://c-faq-chn.sourceforge.net/ccfaq/node350.html
[21.1]: http://c-faq-chn.sourceforge.net/ccfaq/node351.html
[21.2]: http://c-faq-chn.sourceforge.net/ccfaq/node352.html
[21.3_ _]: http://c-faq-chn.sourceforge.net/ccfaq/node353.html
[21.4_char]: http://c-faq-chn.sourceforge.net/ccfaq/node354.html
[21.5]: http://c-faq-chn.sourceforge.net/ccfaq/node355.html
[21.6]: http://c-faq-chn.sourceforge.net/ccfaq/node356.html
[21.7]: http://c-faq-chn.sourceforge.net/ccfaq/node357.html
[21.8]: http://c-faq-chn.sourceforge.net/ccfaq/node358.html
[21.9_printf_]: http://c-faq-chn.sourceforge.net/ccfaq/node359.html
[21.10_1]: http://c-faq-chn.sourceforge.net/ccfaq/node360.html
[21.11]: http://c-faq-chn.sourceforge.net/ccfaq/node361.html
[21.12_ _i_i _ i _1]: http://c-faq-chn.sourceforge.net/ccfaq/node362.html
[21.13_ _ _ _ _i_2]: http://c-faq-chn.sourceforge.net/ccfaq/node363.html
[21.14]: http://c-faq-chn.sourceforge.net/ccfaq/node364.html
[21.15]: http://c-faq-chn.sourceforge.net/ccfaq/node365.html
[21.16_case_]: http://c-faq-chn.sourceforge.net/ccfaq/node366.html
[21.17_return]: http://c-faq-chn.sourceforge.net/ccfaq/node367.html
[21.18_C_]: http://c-faq-chn.sourceforge.net/ccfaq/node368.html
[21.19_C_ _a_b]: http://c-faq-chn.sourceforge.net/ccfaq/node369.html
[21.20_C]: http://c-faq-chn.sourceforge.net/ccfaq/node370.html
[21.21_assert]: http://c-faq-chn.sourceforge.net/ccfaq/node371.html
[21.22_C_FORTRAN _C_ BASIC_ Pascal_ Ada_ LISP_]: http://c-faq-chn.sourceforge.net/ccfaq/node372.html
[21.23_Pascal_Fortran_LISP_ Ada_ awk_ _ C_C]: http://c-faq-chn.sourceforge.net/ccfaq/node373.html
[21.24_C_C_C_C]: http://c-faq-chn.sourceforge.net/ccfaq/node374.html
[21.25_strcmp_ _]: http://c-faq-chn.sourceforge.net/ccfaq/node375.html
[21.26]: http://c-faq-chn.sourceforge.net/ccfaq/node376.html
[21.27_]: http://c-faq-chn.sourceforge.net/ccfaq/node377.html
[21.28_year_4 _ 0_2000]: http://c-faq-chn.sourceforge.net/ccfaq/node378.html
[21.29_]: http://c-faq-chn.sourceforge.net/ccfaq/node379.html
[21.30_ _Duff_s Device]: http://c-faq-chn.sourceforge.net/ccfaq/node380.html
[21.31_C_IOCCC_]: http://c-faq-chn.sourceforge.net/ccfaq/node381.html
[21.32_K_R1_ _entry]: http://c-faq-chn.sourceforge.net/ccfaq/node382.html
[21.33_C]: http://c-faq-chn.sourceforge.net/ccfaq/node383.html
[21.34_char]: http://c-faq-chn.sourceforge.net/ccfaq/node384.html
[21.35_lvalue_rvalue]: http://c-faq-chn.sourceforge.net/ccfaq/node385.html
[21.36_FAQ]: http://c-faq-chn.sourceforge.net/ccfaq/node386.html
[22.]: http://c-faq-chn.sourceforge.net/ccfaq/node387.html
[Link 2]: http://c-faq-chn.sourceforge.net/ccfaq/node388.html