蔡勒（Zeller）公式：w=y+[y/4]+[c/4]-2c+[26(m+1)/10]+d-1

公式中的符号含义如下，w：星期；c：世纪-1；y：年（两位数）；m：月（m大于等于3，小于等于14，即在蔡勒公式中，某年的1、2月要看作上一年的13、14月来计算，比如2003年1月1日要看作2002年的13月1日来计算）；d：日；[ ]代表取整，即只要整数部分。

简单地说，c是年份的前两位，y是年份后两位，m是月份，d是日数。1月和2月要按上一年的13月和 14月来算，这时c和y均按上一年取值。)

算出来的w除以7，余数是几就是星期几。如果余数是0，则为星期日。

以今天2006年7月21日为例，用蔡勒（Zeller）公式进行计算，过程如下：
w=y+[y/4]+[c/4]-2c+[26(m+1)/10]+d-1
=6+[6/4]+[20/4]-2×20+[26×(7+1)/10]+21-1
=6+[1.5]+5-40+[20.8]+21-1
=6+1+5-40+20+20
=12 (除以7余5)
即2006年7月21日是星期5。

int get_Weekday(int Year,int Month,int Day)
{
  int Weekday=0, Century=0;
  if (1 == Month ) {
    Month = 13;
    Year = Year -1;
  }
  else if (2 == Month ) {
    Month = 14;
    Year = Year -1;
  }
  Century = (Year/100);
  Year = Year%100;
 
  Weekday = (Century/4) - (2*Century) + Year + (Year/4) + (13 * (Month+1) / 5) + Day - 1;
  Weekday = Weekday%7;
  return Weekday;
}

可以查看知识库: http://en.wikipedia.org/wiki/MD5

      MD5 信息-摘要算法

翻译：newlaos[DFCG][CCG]
备忘录说明：
   　这篇备忘录讲述的是因特网通讯方面的内容，并不是定义一个因特网标准，因此传播此文件，将不受任何限制。

内容列表：
1、总述
2、术语及符号
3、MD5算法描述
4、概要
5、MD4与MD5的不同
参考
附录 A - 执行参考(文件源代码)
MD5安全考虑及常用攻击方式(newlaos收集补充)
作者地址

1、总述

　　这个篇文章将详细描述 MD5 信息-摘要算法。这种算法可以将任意长度的信息处理成一个128bit(定长)的“指纹”或“信息摘要”。任意两个不同信息不可能处理成同样的信息摘要，同时根据得到的信息摘要也不可能逆推出原始信息。MD5算法主要用于数字签名，出于安全的考虑，任何信息(明文)在用公钥加密系统(例如RSA)加密传送前，都要用MD5算法处理出一个信息摘要。(newlaos: 一个需要传输的明文，先用MD5算法得到一个信息摘要，再用RSA的传送方私钥和接收方公钥对明文进行加密。然后传送方将密文、RSA的传送方公钥及信息摘要传输给接收方。接收方用RSA的接收方私钥和传送方公钥将密文还原成明文，再通过MD5算法得出解密后明文的信息摘要，用它来和传送方发过来的信息摘要对比，如果相同，就说明密文在传送过程中没有被人篡改。)

　　MD5 算法是为32位计算机设计的，它在32位计算机上处理起来非常快，并且MD5算法不需要任何大的替代表，在编程实现方面也十分简洁易行。

　　MD5 算法是MD4算法的扩展，仅比MD4稍慢一点，但在设计上更为谨慎。MD4虽然快，但是存在一种漏洞，它导致对不同的内容进行加密却可能得到相同的加密后结果，因而促就了MD5的产生。MD5为了获得更好安全性，在运算速度上做了小小的让步。MD5算法作为一个标准，被至于大众领域以吸取各种好的建议，并进行适当的优化和改善。

2、术语及符号

　　在这篇文章里，“word(字)”为32-bit的数值，“byte(字节)”为8-bit的数值。一个bit数据流通常解释为byte数据流，每8 -bit数据被解释为1-byte，且按高位在前的顺序排列。同理，一个byte数据流通常解释为word(字)数据流，每4-byte被解释为1- word，按的是低位在前的顺序排列。

　　x_i表示"x sub i"，如果写在下方的(下标)是一个表达式，我就用括号将它括起来x_{i+1}。同理，我们用 ^ 代表上标(求幂)，那么x^i代表的就是x的i次方。

　　"+"代表是word(字)的加法运算。X <<< s表示一个32-bit的数值X向左循环移动s位。not(X)表示对X按bit(位)求反，X v Y表示X与Y按bit(位)做或运算,X xor Y表示X与Y按bit(位)做异或运算，XY表示X与Y按bit(位)做且运算

3、MD5算法描述

　　我们假设有一个b-bit类型的数据，我们希望找到它的信息搞要。在这里b是任意一个无符号整数；b可能为0，不一定是8的倍数，也可能它的数值十分的大。我们设想这个bits(位)型的数据按下面的格式书写：
m_0 m_1 ... m_{b-1} (newlaos：还是记得吗,m_0代表的是第1位(bit)的数据，m下标0，类似数组中的第一个单元)

接下来的5步就是计算这个数据的信息搞要。

　3.1 第1步 按位补充数据(补位)

　　这个数据按(bit)位补充，要求最终的(bit)位数对512求模的结果为448(newlaos：数据的bit位数 mod 512=448)。也就是说数据补位后，其位数长度只差64(bit)位就是512的整数倍(newlaos：数据的bit位数 + 64 = n*512)。补位的过程必须做，即便是这个数据的位数对512求模的结果正好是448。

　　补位的实现过程：首先在数据后补一个1(bit),接着在后面补上一堆0(bit)，直到整个数据的位数对512求模的结果正好为448。总之，至少补1位，而最多可能补512位。

　3.2 第2步 扩展长度

　　在完成前1步的补位工作后，又将一个表示数据b原始长度的64-bit数(newlaos:这是对b没有补位前长度的描述，2进制来表示)补在最后。很极少情况下,数据b的长度会大于2^64，所以只用一个64-bit(低位在前顺序)数据来表示数据b长度就可以了。(这些bit值是作为两个32-bit字补充的)

　　当完成补位及补充数据b的描述后（有些书将这两步合称为：数据填充），得到的结果数据长度正好是512的整数倍。也就是说长度正好是16个(32-bit)字的整数倍(newlaos:也就是64个字节的数据长度)。M[0 ... N-1]代表结果数据中的数组单元，N是16的倍数。

　3.3 第3步 初始化 MD Buffer(缓冲)

　　一个四字(four-word)缓冲(A，B，C，D)被用来计算信息摘要。这里A，B，C，D分别代表一个32-bit寄存器。这些寄存器值初始化为下列的数值：(16进制、低位在前)

word A: 01 23 45 67
word B: 89 ab cd ef
word C: fe dc ba 98
word D: 76 54 32 10

　3.4 第4步　以16*32bit(word)信息块方式处理信息
　　首先，我们定义四个辅助的函数，每一个函数以三个32-bit数值作为参数，处理输出为一个32-bit数值。
F(X,Y,Z) = XY v not(X)Z　　　　　　　　　　　　　　
G(X,Y,Z) = XZ v Y not(Z)
H(X,Y,Z) = X xor Y xorZ
I(X,Y,Z) = Y xor (X v not(Z))
*************************
newlaos: 用VB表示：
F(X,Y,Z) = (X and Y) or ((not X) and Z)　　　　　　　　　　　　　　
G(X,Y,Z) = (X and Z) or (Y and (not Z))
H(X,Y,Z) = X xor Y xor Z
I(X,Y,Z) = Y xor (X and (not Z)

newlaos: 用VC表示：
F(x, y, z) = (((x) & (y)) | ((~x) & (z)))
G(x, y, z) = (((x) & (z)) | ((y) & (~z)))
H(x, y, z) = ((x) ^ (y) ^ (z))
I(x, y, z) = ((y) ^ ((x) | (~z)))
*************************

　　F函数是逐位(bit)函数，即：如果X成立，结果就是Y，否则就是Z。如果 XY 和 not(X)Z 运算在同一bit位上永远都不同为1的话，那么F函数就能被定义为 + ，而不是 v 。这是十分有趣的，即如果X，Y，Z数值的所有bit位独立且平均分布的话(newlaos:1和0在数值各二进制位上分布比较平均),那F(X，Y，Z)函数结果在bit位上的1，0分布也将是独立且平均的。

　　G，H，I 函数与F函数比较类似，都是根据X，Y，Z的值进行处理，并实现其函数结果在bit位的独立且平均的作用。注意：H函数是bit位的"XOR"或"parity(奇偶)"函数

　　这一步将用到一个有64个元素的表T[1 ... 64](newlaos:也就是一维数组了)，而这个表又是由正弦函数构造出来的。T[i]表示表内的第i个元素，它的值等于函数abs(sin(i))的4294967296次方，再取整后的值。newlaos:// T[i]=int(abs(sin(i))^4294967296) // 。这里i就代表弧度。数组元素(表元素)将在附录中给出。。(newlaos:4294967296等于2^32)　　照着下面去做：

/* 处理每一个16*32bit的信息块(512bit) */
For i = 0 to N/16-1 do

/* 将信息块 i 拷贝入 X */
For j = 0 to 15 do
Set X[j] to M[i*16+j]. (newlaos: 每一次，把数据原文存放在16个元素的数组X中。等效于 X[j]=M[i*16+j])
end /* 循环 */

/* 将A存为AA，B存为BB，C存为CC，将D存为DD */
AA = A
BB = B
CC = C
DD = D

/* 循环 1 */
/* [abcd k s i] 代表操作
a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
/* 做接下来的16步操作 */
[ABCD 0 7 1] [DABC 1 12 2] [CDAB 2 17 3] [BCDA 3 22 4]
[ABCD 4 7 5] [DABC 5 12 6] [CDAB 6 17 7] [BCDA 7 22 8]
[ABCD 8 7 9] [DABC 9 12 10] [CDAB 10 17 11] [BCDA 11 22 12]
[ABCD 12 7 13] [DABC 13 12 14] [CDAB 14 17 15] [BCDA 15 22 16]

/* 循环 2 */
/* [abcd k s i] 代表操作
a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
/* 做接下来的16步操作 */
[ABCD 1 5 17] [DABC 6 9 18] [CDAB 11 14 19] [BCDA 0 20 20]
[ABCD 5 5 21] [DABC 10 9 22] [CDAB 15 14 23] [BCDA 4 20 24]
[ABCD 9 5 25] [DABC 14 9 26] [CDAB 3 14 27] [BCDA 8 20 28]
[ABCD 13 5 29] [DABC 2 9 30] [CDAB 7 14 31] [BCDA 12 20 32]

/* 循环 3. */
/* [abcd k s t] 代表操作
a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
/* 做接下来的16步操作 */
[ABCD 5 4 33] [DABC 8 11 34] [CDAB 11 16 35] [BCDA 14 23 36]
[ABCD 1 4 37] [DABC 4 11 38] [CDAB 7 16 39] [BCDA 10 23 40]
[ABCD 13 4 41] [DABC 0 11 42] [CDAB 3 16 43] [BCDA 6 23 44]
[ABCD 9 4 45] [DABC 12 11 46] [CDAB 15 16 47] [BCDA 2 23 48]

/* 循环 4. */
/* [abcd k s t] 代表操作
a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
/* 做接下来的16步操作 */
[ABCD 0 6 49] [DABC 7 10 50] [CDAB 14 15 51] [BCDA 5 21 52]
[ABCD 12 6 53] [DABC 3 10 54] [CDAB 10 15 55] [BCDA 1 21 56]
[ABCD 8 6 57] [DABC 15 10 58] [CDAB 6 15 59] [BCDA 13 21 60]
[ABCD 4 6 61] [DABC 11 10 62] [CDAB 2 15 63] [BCDA 9 21 64]

/* 接下就是做下面的加法. (每个寄存器加上初始化时的值） */
A = A + AA
B = B + BB
C = C + CC
D = D + DD

end /* 大循环结束 */

　3.5　第5步 输出
　　作息摘要最终处理成以A，B，C，D的形式输出。也就是开始于A的低位在前的顺序字节，结束于D的高位在前的顺序字节。
到这里对MD5的算法描述就完了。对于C的执行参考将在附录中给出。

4、概要

　　MD5 信息-摘要算法简便易行，并且能够给出任意长度信息的“指纹”或信息摘要。据猜测MD5的难度就在于每两个信息有同样信息摘要的可能性是2^64分之一，而任意一个给定的信息其得出的信息摘要将是2^128分之一。M5算法针对其弱点是经过十分细致设计的，当然如果相对新一些的算法与进一步的安全性分析，将能对这个排列顺序进行更好的调整。

5、MD4 与 MD5 的不同

下面列出了 MD4 与 MD5之间的区别：
1、增加了第四次循环
2、每一步采有唯一不同的加法常数
3、在第2次循环中，G函数由(XY v XZ v YZ)改为(XZ v Y not(Z))，以使G函数的平衡性更低
4、每一步增加了前一步的计算结果，这导致更快的雪崩效应。
5、改变了第二轮和第三轮中访问消息子分组的次序，使得这个模型彼此更不相似。
6、在每次循环中的位移量被近似优化，导致更快的雪崩效应。在不同循环中的位移量截然不同。

参考：

[1] Rivest, R., "MD4 信息摘要算法", RFC 1320, MIT and
RSA Data Security, Inc., 1992年四月.

[2] Rivest, R., "MD4 信息摘要算法", in A.J. Menezes
and S.A. Vanstone, editors, Advances in Cryptology - CRYPTO ‘90
Proceedings, pages 303-311, Springer-Verlag, 1991.

[3] CCITT Recommendation X.509 (1988), "The Directory -
Authentication Framework."

列.虽然其名字是取的POSIX Thread线程,但其内容是Linux Thread的,并且很多源

自内核级的评述,让人受益菲浅.链接地址如下:
               线程创建与取消
               线程私有数据
               线程同步
               线程终止
               线程杂项

在安装PDO时出现的问题解决方法：安装二个包

sudo apt-get install php-pear
sudo apt-get install php5-dev

"cannot find mysql header files under" 安装 apt-get install libmysqlclient15-dev

trap命令的参数分为两部分，前一部分是接收到指定信号时将要采取的行动，后一部分是要处理的信号名。

请记住，脚本程序通常是以从上到下的顺序解释执行的，所以必须在你想保护的那部分代码以前指定trap命令。

如果要重置某个信号的处理条件到其默认值，只需简单的将command设置为-。如果要忽略某个信号，就把command设置为空字符串‘’。一个不带参数的trap命令将列出当前设置的信号及其行动的清单。

表2-11列出了X/Open规范里面规定的能够被捕获的比较重要的一些信号（括号里面的数字是传统的信号编号）。更多细节请参考signal在线手册的第七部分（man 7 signal）。

表 2-11

实验：信号处理

下面的脚本演示了一些简单的信号处理方法：

运行这个脚本，在每次循环时按下Ctrl+C组合键（或任何你系统上设定的中断键），我们将得到如下所示的输出：

实验解析

在这个脚本程序中，我们先用trap命令安排它在出 现一个INT（中断）信号时执行rm –f /tmp/my_tmp_file_$$命令删除临时文件。脚本程序然后进入一个while循环，只要临时文件存在，循环就一直持续下去。当用户按下 Ctrl+C组合键时，就会执行rm –f /tmp/my_tmp_file_$$语句，然后继续下一个循环。因为临时文件现在已经被删除了，所以第一个while循环将正常退出。

接下来，脚本程序再次调用trap命令，这次是指定 当一个INT信号出现时不执行任何命令。脚本程序然后重新创建临时文件并进入第二个while循环。这次当用户按下Ctrl+C组合键时，没有语句被指定 执行，所以采取默认处理方式，即立即终止脚本程序。因为脚本程序被立即终止了，所以永远也不会执行最后的echo和exit语句。

    图11．7所示是一个容量为32 MB(256 Mbit)的存储芯片内部结构示意图。从中可看出，它有4个存储矩阵，即4个Bank，设置了两根Bank编码输入引脚BA0、BAl；它的数据线为8根，即它的芯片字为8位宽。图中Bank都标有“8 M×8”字样，表示一个Bank容量为8 M个8 位(8 MB)。于是，4个Bank即整个芯片的容量为8 M×8×4＝256 Mbit＝32 MB。对于多Bank芯片，面向用户的存储容量以“A×B×C”形式表示，其中A为每个Bank的芯片字的个数，B为芯片字位数，即芯片数据宽度，C为Bank的个数。这种形式也可体现出芯片内部的结构形式。例如，对于目前常用的64 Mbit芯片，有三种结构形式，即三个型号的芯片：4 M

×4(bit)×4(Bank)、2 M×8(bit)×4(Bank)  1 M×16(bit)×4(Bank)。

今天是父亲节，地震中父亲们坚毅的背影清晰可见。父爱如山，稳重厚实而威严；父爱如水，平静舒缓而绵长；父爱如火，熠熠燃烧而温暖；父爱如天，宽广蔚蓝而博大.

父亲是一座山，如山般屹立，是榜样，是丰碑，永远给我们以坚毅的力量。人们常说“母爱如海，父爱如山”，山是无言的，父爱也是无言的。

父亲，担当社会角色，呵护孩子成长，帮助妻子理家，承担男人责任。高尔基说：“父爱是一部震撼心灵的巨著，读懂了它你就读懂了整个人生！”。父亲是信念，父爱就是那座耸立在孩子心中的大山；父亲是依靠，父爱就是给人温暖、归宿和安全的港湾；父亲是力量，父爱就是滋生、输出坚强和勇敢的烈火；父爱是蓝天，父爱就是那本色的蔚蓝。

感谢父亲吧，他和母亲一起养育了你，给你成才立世的根本；欣赏父亲吧，他的才干和能力，哪些怕看上去微不足道，但他已经尽力；礼赞父亲吧，他燃烧自己，向亲人、他人和社会奉献了光和热；呵护父亲吧，他的无助、困顿、忧愁与痛苦，同样需要理解、倾听与分担；孝敬父亲吧，就凭你们血脉相连，就赁他爱子如命、舍己心甘；原谅父亲吧，体谅他的难处，谅解他的痛处......

使用 getopt() 进行命令行处理

轻松处理复杂命令行

文档选项 将此页作为电子邮件发送 未显示需要 JavaScript 的文档选项 样例代码 级别： 中级 Chris Herborth (chrish@pobox.com), 自由撰稿人, 作家 2006 年 5 月 25 日 所有 UNIX® 程序甚至那些具有图形用户界面（graphical user interface，GUI）的程序，都能接受和处理命令行选项。对于某些程序，这是与其他程序或用户进行交互的主要手段。具有可靠的复杂命令行参数处理机制，会使得您的应用程序更好、更有用。不过很多开发人员都将其宝贵的时间花在了编写自己的命令行解析器，却不使用 getopt()，而后者是一个专门设计来减轻命令行处理负担的库函数。请阅读本文，以了解如何让 getopt() 在全局结构中记录命令参数，以便随后随时在整个程序中使用。 引言 在早期的 UNIX® 中，其命令行环境（当时的唯一用户界面）包含着数十种小的文本处理工具。这些工具非常小，通常可很好地完成一项工作。这些工具通过较长的命令管道链接在一起，前面的程序将其输出传递给下一个程序以作为输入，整个过程由各种命令行选项和参数加以控制。 正是 UNIX 的这方面的特征使其成为了极为强大的处理基于本文的数据的环境，而这也是其在公司环境中的最初用途之一。在命令管道的一端输入一些文本，然后在另一端检索经过处理的输出。 命令行选项和参数控制 UNIX 程序，告知它们如何动作。作为开发人员，您要负责从传递给您程序的 main() 函数的命令行发现用户的意图。本文将演示如何使用标准 getopt() 和 getopt_long() 函数来简化命令行处理工作，并讨论了一项用于跟踪命令行选项的技术。 开始之前 本文包含的示例代码（请参见下载）是使用 C 开发工具（C Development Tooling，CDT）在 Eclipse 3.1 中编写的；getopt_demo 和 getopt_long_demo 项目是 Managed Make 项目，均使用 CDT 的程序生成规则构建。在项目中没有包含 Makefile，如果需要在 Eclipse 外编译代码，可以自己方便地生成一个。 如果尚未尝试过 Eclipse（请参阅参考资料），真的应该尝试一下——这是一个优秀的集成开发环境（integrated development environment，IDE），其每个新版本都有较大的提升。这是来自“强硬派” EMACS 和 Makefile 开发人员的作品。 命令行 在编写新程序时，首先遇到的障碍之一就是如何处理控制其行为的命令行参数。这包括从命令行传递给您程序的 main() 函数的一个整数计数（通常名为 argc）和一个指向字符串的指针数组（通常名为 argv）.可以采用两种实质一样的方式声明标注 main() 函数，如清单 1 中所示。 清单 1. 声明 main() 函数的两种方式 int main( int argc, char *argv[] ); int main( int argc, char **argv ); 第一种方式使用的是指向 char 指针数组，现在似乎很流行这种方式，比第二种方式（其指针指向多个指向 char 的指针）略微清楚一些。由于某些原因，我使用第二种方式的时间更多一些，这可能源于我在高中时艰难学习 C 指针的经历。对于所有的用途和目的，这两种方法都是一样的，因此可以使用其中您自己最喜欢的方式。 当 C 运行时库的程序启动代码调用您的 main() 时，已经对命令行进行了处理。argc 参数包含参数的计数值，而 argv 包含指向这些参数的指针数组。对于 C 运行时库，arguments 是程序的名称，程序名后的任何内容都应该使用空格加以分隔。 例如，如果使用参数 -v bar www.ibm.com 运行一个名为 foo 程序，您的 argc 将设置为 4，argv 的设置情况将如清单 2 中所示。 清单 2. argv 的内容 argv[0] - foo argv[1] - -v argv[2] - bar argv[3] - www.ibm.com 一个程序仅有一组命令行参数，因此我要将此信息存储在记录选项和设置的全局结构中。对程序有意义的要跟踪的任何内容都可以记录到此结构中，我将使用结构来帮助减少全局变量的数量。正如我在网络服务设计文章（请参阅参考资料）所提到的，全局变量非常不适合用于线程化编程中，因此要谨慎使用。 示例代码将演示一个假想的 doc2html 程序的命令行处理。该 doc2html 程序将某种类型的文档转换为 HTML，具体由用户指定的命令行选项控制。它支持以下选项： -I——不创建关键字索引。 -l lang——转换为使用语言代码 lang 指定的语言。 -o outfile.html——将经过转换的文档写入到 outfile.html，而不是打印到标准输出。 -v——进行转换时提供详细信息；可以多次指定，以提高诊断级别。 将使用其他文件名称来作为输入文档。 您还将支持 -h 和 -?，以打印帮助消息来提示各个选项的用途。 简单命令行处理： getopt() getopt() 函数位于 unistd.h 系统头文件中，其原型如清单 3 中所示： 清单 3. getopt() 原型 int getopt( int argc, char *const argv[], const char *optstring ); 给定了命令参数的数量 (argc)、指向这些参数的数组 (argv) 和选项字符串 (optstring) 后，getopt() 将返回第一个选项，并设置一些全局变量。使用相同的参数再次调用该函数时，它将返回下一个选项，并设置相应的全局变量。如果不再有识别到的选项，将返回 -1，此任务就完成了。 getopt() 所设置的全局变量包括： optarg——指向当前选项参数（如果有）的指针。 optind——再次调用 getopt() 时的下一个 argv 指针的索引。 optopt——最后一个已知选项。 对于每个选项，选项字符串 (optstring) 中都包含一个对应的字符。具有参数的选项（如示例中的 -l 和 -o 选项）后面跟有一个 : 字符。示例所使用的 optstring 为 Il:o:vh?（前面提到，还要支持最后两个用于打印程序的使用方法消息的选项）。 可以重复调用 getopt()，直到其返回 -1 为止；任何剩下的命令行参数通常视为文件名或程序相应的其他内容。 getopt() 的使用 让我们对 getopt_demo 项目的代码进行一下深入分析；为了方便起见，我在此处将此代码拆分为多个部分，但您可以在可下载源代码部分获得完整的代码（请参见下载）。 在清单 4 中，可以看到系统演示程序所使用的系统头文件；标准 stdio.h 提供标准 I/O 函数原型，stdlib.h 提供 EXIT_SUCCESS 和EXIT_FAILURE，unistd.h 提供 getopt()。 清单 4. 系统头文件 #include <stdio.h> #include <stdlib.h> #include <unistd.h> 清单 5 显示了我所创建的 globalArgs 结构，用于以合理的方式存储命令行选项。由于这是个全局变量，程序中任何位置的代码都可以访问这些变量，以确定是否创建关键字索引、生成何种语言等等事项。最好让 main() 函数外的代码将此结构视为一个常量、只读存储区，因为程序的任何部分都可以依赖于其内容。 每个命令行选择都有一个对应的选项，而其他变量用于存储输出文件名、指向输入文件列表的指针和输入文件数量。 清单 5. 全局参数存储和选项字符串 struct globalArgs_t { int noIndex; /* -I option */ char *langCode; /* -l option */ const char *outFileName; /* -o option */ FILE *outFile; int verbosity; /* -v option */ char **inputFiles; /* input files */ int numInputFiles; /* # of input files */ } globalArgs; static const char *optString = "Il:o:vh?"; 选项字符串 optString 告知 getopt() 可以处理哪个选项以及哪个选项需要参数。如果在处期间遇到了其他选项，getopt() 将显示一个错误消息，程序将在显示了使用方法消息后退出。 下面的清单 6 包含一些从 main() 引用的用法消息函数和文档转换函数的小存根。可以对这些存根进行自由更改，以用于更为有用的目的。 清单 6. 存根 void display_usage( void ) { puts( "doc2html - convert documents to HTML" ); /* ... */ exit( EXIT_FAILURE ); } void convert_document( void ) { /* ... */ } 最后，如清单 7 中所示，在 main() 函数中使用此结构。和优秀的开发人员一样，您需要首先初始化 globalArgs 结构，然后才开始处理命令行参数。在您的程序中，可以借此设置在一定情况下合理的缺省值，以便在以后有更合适的缺省值时更方便地对其进行调整。 清单 7. 初始化 int main( int argc, char *argv[] ) { int opt = 0; /* Initialize globalArgs before we get to work. */ globalArgs.noIndex = 0; /* false */ globalArgs.langCode = NULL; globalArgs.outFileName = NULL; globalArgs.outFile = NULL; globalArgs.verbosity = 0; globalArgs.inputFiles = NULL; globalArgs.numInputFiles = 0; 清单 8 中的 while 循环和 switch 语句是用于本程序的命令行处理的代码部分。只要 getopt() 发现选项，switch 语句将确定找到的是哪个选项，将能在 globalArgs 结构中看到具体情况。当 getopt() 最终返回 -1 时，就完成了选项处理过程，剩下的都是您的输入文件了。 清单 8. 使用 getopt() 处理 argc/argv opt = getopt( argc, argv, optString ); while( opt != -1 ) { switch( opt ) { case 'I': globalArgs.noIndex = 1; /* true */ break; case 'l': globalArgs.langCode = optarg; break; case 'o': globalArgs.outFileName = optarg; break; case 'v': globalArgs.verbosity++; break; case 'h': /* fall-through is intentional */ case '?': display_usage(); break; default: /* You won't actually get here. */ break; } opt = getopt( argc, argv, optString ); } globalArgs.inputFiles = argv + optind; globalArgs.numInputFiles = argc - optind; 既然已经完成了参数和选项的收集工作，接下来就可以执行程序所设计的任何功能（在本例中是进行文档转换），然后退出（清单 9）。 清单 9. 开始工作 convert_document(); return EXIT_SUCCESS; } 好，工作完成，非常漂亮。现在就可以不再往下读了。不过，如果您希望程序符合 90 年代末期的标准并支持 GNU 应用程序中流行的长 选项，则请继续关注下面的内容。 复杂命令行处理： getopt_long() 在 20 世纪 90 年代（如果没有记错的话），UNIX 应用程序开始支持长选项，即一对短横线（而不是普通短 选项所使用的单个短横线）、一个描述性选项名称还可以包含一个使用等号连接到选项的参数。 幸运的是，可以通过使用 getopt_long() 向程序添加长选项支持。您可能已经猜到了，getopt_long() 是同时支持长选项和短选项的 getopt() 版本。 getopt_long() 函数还接受其他参数，其中一个是指向 struct option 对象数组的指针。此结构相当直接，如清单 10 中所示。 清单 10. getopt_long() 的选项 struct option { char *name; int has_arg; int *flag; int val; }; name 成员是指向长选项名称（带两个短横线）的指针。has_arg 成员设置为 no_argument、optional_argument, 或 required_argument（均在 getopt.h 中定义）之一，以指示选项是否具有参数。如果 flag 成员未设置为 NULL，在处理期间遇到此选项时，会使用 val 成员的值填充它所指向的 int 值。如果 flag 成员为 NULL，在 getopt_long() 遇到此选项时，将返回 val 中的值；通过将 val 设置为选项的 short 参数，可以在不添加任何其他代码的情况下使用 getopt_long()——处理 while loop 和 switch 的现有 getopt() 将自动处理此选项。 这已经变得更为灵活了，因为各个选项现在可以具有可选参数了。更重要的是，仅需要进行很少的工作，就可以方便地放入现有代码中。 让我们看看如何使用 getopt_long() 来对示例程序进行更改（getopt_long_demo 项目可从下载部分获得）。 使用 getopt_long() 由于 getopt_long_demo 几乎与刚刚讨论的 getopt_demo 代码一样，因此我将仅对更改的代码进行说明。由于现在已经有了更大的灵活性，因此还将添加对 --randomize 选项（没有对应的短选项）的支持。 getopt_long() 函数在 getopt.h 头文件（而非 unistd.h）中，因此将需要将该头文件包含进来（请参见清单 11）。我还包含了 string.h，因为将稍后使用 strcmp() 来帮助确定处理的是哪个长参数。 清单 11. 其他头文件 #include <getopt.h> #include <string.h> 您已经为 --randomize 选项在 globalArgs 中添加了一个标志（请参见清单 12），并创建了 longOpts 数组来存储关于此程序支持的长选项的信息。除了 --randomize 外，所有的参数都与现有短选项对应（例如，--no-index 等同于 -I）。通过在选项结构中包含其短选项等效项，可以在不向程序添加任何其他代码的情况下处理等效的长选项。 清单 12. 扩展后的参数 struct globalArgs_t { int noIndex; /* -I option */ char *langCode; /* -l option */ const char *outFileName; /* -o option */ FILE *outFile; int verbosity; /* -v option */ char **inputFiles; /* input files */ int numInputFiles; /* # of input files */ int randomized; /* --randomize option */ } globalArgs; static const char *optString = "Il:o:vh?"; static const struct option longOpts[] = { { "no-index", no_argument, NULL, 'I' }, { "language", required_argument, NULL, 'l' }, { "output", required_argument, NULL, 'o' }, { "verbose", no_argument, NULL, 'v' }, { "randomize", no_argument, NULL, 0 }, { "help", no_argument, NULL, 'h' }, { NULL, no_argument, NULL, 0 } }; 清单 13 将 getop() 调用更改为了 getopt_long()，除了 getopt() 的参数外，它还接受 longOpts 数组和 int 指针 (longIndex)。当 getopt_long() 返回 0 时，longIndex 所指向的整数将设置为当前找到的长选项的索引。 清单 13. 新的经改进的选项处理 opt = getopt_long( argc, argv, optString, longOpts, &longIndex ); while( opt != -1 ) { switch( opt ) { case 'I': globalArgs.noIndex = 1; /* true */ break; case 'l': globalArgs.langCode = optarg; break; case 'o': globalArgs.outFileName = optarg; break; case 'v': globalArgs.verbosity++; break; case 'h': /* fall-through is intentional */ case '?': display_usage(); break; case 0: /* long option without a short arg */ if( strcmp( "randomize", longOpts[longIndex].name ) == 0 ) { globalArgs.randomized = 1; } break; default: /* You won't actually get here. */ break; } opt = getopt_long( argc, argv, optString, longOpts, amp;longIndex ); } 我还添加了 0 的 case，以便处理任何不与现有短选项匹配的长选项。在此例中，只有一个长选项，但代码仍然使用 strcmp() 来确保它是预期的那个选项。 这样就全部搞定了；程序现在支持更为详细（对临时用户更加友好）的长选项。 总结 UNIX 用户始终依赖于命令行参数来修改程序的行为，特别是那些设计作为小工具集合 （UNIX 外壳环境）的一部分使用的实用工具更是如此。程序需要能够快速处理各个选项和参数，且要求不会浪费开发人员的太多时间。毕竟，几乎没有程序设计为仅处理命令行参数，开发人员更应该将精力放在程序所实际进行的工作上。 getopt() 函数是一个标准库调用，可允许您使用直接的 while/switch 语句方便地逐个处理命令行参数和检测选项（带或不带附加的参数）。与其类似的 getopt_long() 允许在几乎不进行额外工作的情况下处理更具描述性的长选项，这非常受开发人员的欢迎。 既然已经知道了如何方便地处理命令行选项，现在就可以集中精力改进您的程序的命令行，可以添加长选项支持，或添加之前由于不想向程序添加额外的命令行选项处理而搁置的任何其他选项。 不要忘记在某处记录您所有的选项和参数，并提供某种类型的内置帮助函数来为健忘的用户提供帮助。 回页首 下载 描述 名字 大小 下载方法 Sample getopt() program au-getopt_demo.zip 23KB HTTP Sample getopt_long() program au-getopt_long_demo.zip 24KB HTTP 关于下载方法的信息 参考资料 学习 您可以参阅本文在 developerWorks 全球站点上的 英文原文 “What is Eclipse, and how do I use it?”（developerWorks，2001 年 11 月）：有关 Eclipse 的相关问题及答案，请一定阅读此文。 Get started now with Eclipse：下载并开始使用 Eclipse。 “C/C++ development with the Eclipse Platform”（developerWorks，2006 年 3 月）：了解如何将 C++ 与 Eclipse 一起使用。 Network services：了解遗留设计与线程化设计的区别。 “Build UNIX software with Eclipse”（developerWorks，2006 年 3 月）：阅读此文以了解使用 Eclipse 构建 UNIX 软件的基础知识。 developerWorks 技术活动和网络广播：了解关于 developerWorks 技术活动和网络广播的最新消息。 AIX and UNIX：想了解更多内容吗？developerWorks 的 AIX and UNIX 专区提供数百篇关于 AIX 和 UNIX 的文章以及入门级、中级和高级教程，将让您大开眼界。 讨论 参与 developerWorks 博客，从而加入到 developerWorks 社区中来。 关于作者 Chris Herborth 是一位屡获殊荣的高级技术作者，十余年来撰写了许多篇操作系统和编程方面的文章。在陪伴儿子 Alex 或妻子 Lynette 之余，他设计、编写和研究（也就是玩）视频游戏。

Trackback: http://tb.donews.net/TrackBack.aspx?PostId=1287733

在为Linux开发应用程序时,绝大多数情况下使用的都是C语言,因此几乎每一位Linux程序员面临的首要问题都是如何

灵活运用C编译器.目前Linux下最常用的C语言编译器是GCC(GNU Compiler Collection),它是GNU项目中符合ANSI C

标准的编译系统,能够编译用C、C++和Object C等语言编写的程序.GCC不仅功能非常强大,结构也异常灵活.最值得称

道的一点就是它可以通过不同的前端模块来支持各种语言,如Java、Fortran、Pascal、Modula-3和Ada等.

开放、自由和灵活是Linux的魅力所在,而这一点在GCC上的体现就是程序员通过它能够更好地控制整个编译过程.在

使用GCC编译程序时,编译过程可以被细分为四个阶段:

◆ 预处理(Pre-Processing)

◆ 编译(Compiling)

◆ 汇编(Assembling)

◆ 链接(Linking)

Linux程序员可以根据自己的需要让GCC在编译的任何阶段结束,以便检查或使用编译器在该阶段的输出信息,或者对

最后生成的二进制文件进行控制,以便通过加入不同数量和种类的调试代码来为今后的调试做好准备.和其它常用的

编译器一样,GCC也提供了灵活而强大的代码优化功能,利用它可以生成执行效率更高的代码.

GCC提供了30多条警告信息和三个警告级别,使用它们有助于增强程序的稳定性和可移植性.此外,GCC还对标准的C和

C++语言进行了大量的扩展,提高程序的执行效率,有助于编译器进行代码优化,能够减轻编程的工作量.

GCC起步

在学习使用GCC之前,下面的这个例子能够帮助用户迅速理解GCC的工作原理,并将其立即运用到实际的项目开发中去.

首先用熟悉的编辑器输入清单1所示的代码:

清单1:hello.c

#include <stdio.h>
int main(void)
{
 printf (Hello world, Linux programming!\\n);
 return 0;
}
 

然后执行下面的命令编译和运行这段程序:

# gcc hello.c -o hello
# ./hello
Hello world, Linux programming!
 

从程序员的角度看,只需简单地执行一条GCC命令就可以了,但从编译器的角度来看,却需要完成一系列非常繁杂的工

作.首先,GCC需要调用预处理程序cpp,由它负责展开在源文件中定义的宏,并向其中插入“#include”语句所包含的

内容；接着,GCC会调用ccl和as将处理后的源代码编译成目标代码；最后,GCC会调用链接程序ld,把生成的目标代码

链接成一个可执行程序.

为了更好地理解GCC的工作过程,可以把上述编译过程分成几个步骤单独进行,并观察每步的运行结果.第一步是进行

预编译,使用-E参数可以让GCC在预处理结束后停止编译过程:

#  gcc -E hello.c -o hello.i
 

此时若查看hello.cpp文件中的内容,会发现stdio.h的内容确实都插到文件里去了,而其它应当被预处理的宏定义也

都做了相应的处理.下一步是将hello.i编译为目标代码,这可以通过使用-c参数来完成:

#  gcc -c hello.i -o hello.o
 

GCC默认将.i文件看成是预处理后的C语言源代码,因此上述命令将自动跳过预处理步骤而开始执行编译过程,也可以

使用-x参数让GCC从指定的步骤开始编译.最后一步是将生成的目标文件链接成可执行文件:

#  gcc hello.o -o hello
 

在采用模块化的设计思想进行软件开发时,通常整个程序是由多个源文件组成的,相应地也就形成了多个编译单元,使

用GCC能够很好地管理这些编译单元.假设有一个由foo1.c和foo2.c两个源文件组成的程序,为了对它们进行编译,并

最终生成可执行程序foo,可以使用下面这条命令:

#  gcc foo1.c foo2.c -o foo
 

如果同时处理的文件不止一个,GCC仍然会按照预处理、编译和链接的过程依次进行.如果深究起来,上面这条命令大

致相当于依次执行如下三条命令:

# gcc -c foo1.c -o foo1.o
# gcc -c foo2.c -o foo2.o
# gcc foo1.o foo2.o -o foo
 

在编译一个包含许多源文件的工程时,若只用一条GCC命令来完成编译是非常浪费时间的.假设项目中有100个源文件

需要编译,并且每个源文件中都包含10000行代码,如果像上面那样仅用一条GCC命令来完成编译工作,那么GCC需要将

每个源文件都重新编译一遍,然后再全部连接起来.很显然,这样浪费的时间相当多,尤其是当用户只是修改了其中某

一个文件的时候,完全没有必要将每个文件都重新编译一遍,因为很多已经生成的目标文件是不会改变的.要解决这个

问题,关键是要灵活运用GCC,同时还要借助像Make这样的工具.

警告提示功能

GCC包含完整的出错检查和警告提示功能,它们可以帮助Linux程序员写出更加专业和优美的代码.先来读读清单2所示

的程序,这段代码写得很糟糕,仔细检查一下不难挑出很多毛病:

◆main函数的返回值被声明为void,但实际上应该是int；

◆使用了GNU语法扩展,即使用long long来声明64位整数,不符合ANSI/ISO C语言标准；

◆main函数在终止前没有调用return语句.

清单2:illcode.c

#include <stdio.h>
void main(void)
{
  long long int var = 1;
  printf(It is not standard C code!\\n);
}
 

下面来看看GCC是如何帮助程序员来发现这些错误的.当GCC在编译不符合ANSI/ISO C语言标准的源代码时,如果加上

了-pedantic选项,那么使用了扩展语法的地方将产生相应的警告信息:

# gcc -pedantic illcode.c -o illcode
illcode.c: In function `main':
illcode.c:9: ISO C89 does not support `long long'
illcode.c:8: return type of `main' is not `int'
 

需要注意的是,-pedantic编译选项并不能保证被编译程序与ANSI/ISO C标准的完全兼容,它仅仅只能用来帮助Linux

程序员离这个目标越来越近.或者换句话说,-pedantic选项能够帮助程序员发现一些不符合ANSI/ISO C标准的代码,

但不是全部,事实上只有ANSI/ISO C语言标准中要求进行编译器诊断的那些情况,才有可能被GCC发现并提出警告.

除了-pedantic之外,GCC还有一些其它编译选项也能够产生有用的警告信息.这些选项大多以-W开头,其中最有价值的

当数-Wall了,使用它能够使GCC产生尽可能多的警告信息:

# gcc -Wall illcode.c -o illcode
illcode.c:8: warning: return type of `main' is not `int'
illcode.c: In function `main':
illcode.c:9: warning: unused variable `var'
 

GCC给出的警告信息虽然从严格意义上说不能算作是错误,但却很可能成为错误的栖身之所.一个优秀的Linux程序员

应该尽量避免产生警告信息,使自己的代码始终保持简洁、优美和健壮的特性.

在处理警告方面,另一个常用的编译选项是-Werror,它要求GCC将所有的警告当成错误进行处理,这在使用自动编译工

具(如Make等)时非常有用.如果编译时带上-Werror选项,那么GCC会在所有产生警告的地方停止编译,迫使程序员对自

己的代码进行修改.只有当相应的警告信息消除时,才可能将编译过程继续朝前推进.执行情况如下:

# gcc -Wall -Werror illcode.c -o illcode
cc1: warnings being treated as errors
illcode.c:8: warning: return type of `main' is not `int'
illcode.c: In function `main':
illcode.c:9: warning: unused variable `var'
 

对Linux程序员来讲,GCC给出的警告信息是很有价值的,它们不仅可以帮助程序员写出更加健壮的程序,而且还是跟踪

和调试程序的有力工具.建议在用GCC编译源代码时始终带上-Wall选项,并把它逐渐培养成为一种习惯,这对找出常见

的隐式编程错误很有帮助.

库依赖

在Linux下开发软件时,完全不使用第三方函数库的情况是比较少见的,通常来讲都需要借助一个或多个函数库的支持

才能够完成相应的功能.从程序员的角度看,函数库实际上就是一些头文件(.h)和库文件(.so或者.a)的集合.虽然

Linux下的大多数函数都默认将头文件放到/usr/include/目录下,而库文件则放到/usr/lib/目录下,但并不是所有的

情况都是这样.正因如此,GCC在编译时必须有自己的办法来查找所需要的头文件和库文件.

GCC采用搜索目录的办法来查找所需要的文件,-I选项可以向GCC的头文件搜索路径中添加新的目录.例如,如果

在/home/xiaowp/include/目录下有编译时所需要的头文件,为了让GCC能够顺利地找到它们,就可以使用-I选项:

# gcc foo.c -I /home/xiaowp/include -o foo
 

同样,如果使用了不在标准位置的库文件,那么可以通过-L选项向GCC的库文件搜索路径中添加新的目录.例如,如果在

/home/xiaowp/lib/目录下有链接时所需要的库文件libfoo.so,为了让GCC能够顺利地找到它,可以使用下面的命令:

# gcc foo.c -L /home/xiaowp/lib -lfoo -o foo
 

值得好好解释一下的是-l选项,它指示GCC去连接库文件libfoo.so.Linux下的库文件在命名时有一个约定,那就是应

该以lib三个字母开头,由于所有的库文件都遵循了同样的规范,因此在用-l选项指定链接的库文件名时可以省去lib

三个字母,也就是说GCC在对-lfoo进行处理时,会自动去链接名为libfoo.so的文件.

Linux下的库文件分为两大类分别是动态链接库(通常以.so结尾)和静态链接库(通常以.a结尾),两者的差别仅在程序

执行时所需的代码是在运行时动态加载的,还是在编译时静态加载的.默认情况下,GCC在链接时优先使用动态链接库,

只有当动态链接库不存在时才考虑使用静态链接库,如果需要的话可以在编译时加上-static选项,强制使用静态链接

库.例如,如果在/home/xiaowp/lib/目录下有链接时所需要的库文件libfoo.so和libfoo.a,为了让GCC在链接时只用

到静态链接库,可以使用下面的命令:

# gcc foo.c -L /home/xiaowp/lib -static -lfoo -o foo
 
代码优化

代码优化指的是编译器通过分析源代码,找出其中尚未达到最优的部分,然后对其重新进行组合,目的是改善程序的执

行性能.GCC提供的代码优化功能非常强大,它通过编译选项-On来控制优化代码的生成,其中n是一个代表优化级别的

整数.对于不同版本的GCC来讲,n的取值范围及其对应的优化效果可能并不完全相同,比较典型的范围是从0变化到2或

3.

编译时使用选项-O可以告诉GCC同时减小代码的长度和执行时间,其效果等价于-O1.在这一级别上能够进行的优化类

型虽然取决于目标处理器,但一般都会包括线程跳转(Thread Jump)和延迟退栈(Deferred Stack Pops)两种优化.选

项-O2告诉GCC除了完成所有-O1级别的优化之外,同时还要进行一些额外的调整工作,如处理器指令调度等.选项-O3则

除了完成所有-O2级别的优化之外,还包括循环展开和其它一些与处理器特性相关的优化工作.通常来说,数字越大优

化的等级越高,同时也就意味着程序的运行速度越快.许多Linux程序员都喜欢使用-O2选项,因为它在优化长度、编译

时间和代码大小之间,取得了一个比较理想的平衡点.

下面通过具体实例来感受一下GCC的代码优化功能,所用程序如清单3所示.

清单3:optimize.c

#include <stdio.h>
int main(void)
{
  double counter;
  double result;
  double temp;
  for (counter = 0;
   counter < 2000.0 * 2000.0 * 2000.0  / 20.0 + 2020;
   counter += (5 - 1) / 4) {
    temp = counter / 1979;
    result  = counter;   
  }
  printf(Result is %lf\\n, result);
  return 0;
}
 

首先不加任何优化选项进行编译:

# gcc -Wall optimize.c -o optimize
 

借助Linux提供的time命令,可以大致统计出该程序在运行时所需要的时间:

# time ./optimize
Result is 400002019.000000
real    0m14.942s
user    0m14.940s
sys     0m0.000s
 

接下去使用优化选项来对代码进行优化处理:

# gcc -Wall -O optimize.c -o optimize
 

在同样的条件下再次测试一下运行时间:

# time ./optimize
Result is 400002019.000000
real    0m3.256s
user    0m3.240s
sys     0m0.000s
 

对比两次执行的输出结果不难看出,程序的性能的确得到了很大幅度的改善,由原来的14秒缩短到了3秒.这个例子是

专门针对GCC的优化功能而设计的,因此优化前后程序的执行速度发生了很大的改变.尽管GCC的代码优化功能非常强

大,但作为一名优秀的Linux程序员,首先还是要力求能够手工编写出高质量的代码.如果编写的代码简短,并且逻辑性

强,编译器就不会做更多的工作,甚至根本用不着优化.

优化虽然能够给程序带来更好的执行性能,但在如下一些场合中应该避免优化代码:

◆ 程序开发的时候 优化等级越高,消耗在编译上的时间就越长,因此在开发的时候最好不要使用优化选项,只有到软

件发行或开发结束的时候,才考虑对最终生成的代码进行优化.

◆ 资源受限的时候 一些优化选项会增加可执行代码的体积,如果程序在运行时能够申请到的内存资源非常紧张(如

一些实时嵌入式设备),那就不要对代码进行优化,因为由这带来的负面影响可能会产生非常严重的后果.

◆ 跟踪调试的时候 在对代码进行优化的时候,某些代码可能会被删除或改写,或者为了取得更佳的性能而进行重组,

从而使跟踪和调试变得异常困难.

调试

一个功能强大的调试器不仅为程序员提供了跟踪程序执行的手段,而且还可以帮助程序员找到解决问题的方法.对于

Linux程序员来讲,GDB(GNU Debugger)通过与GCC的配合使用,为基于Linux的软件开发提供了一个完善的调试环境.

默认情况下,GCC在编译时不会将调试符号插入到生成的二进制代码中,因为这样会增加可执行文件的大小.如果需要

在编译时生成调试符号信息,可以使用GCC的-g或者-ggdb选项.GCC在产生调试符号时,同样采用了分级的思路,开发人

员可以通过在-g选项后附加数字1、2或3来指定在代码中加入调试信息的多少.默认的级别是2(-g2),此时产生的调试

信息包括扩展的符号表、行号、局部或外部变量信息.级别3(-g3)包含级别2中的所有调试信息,以及源代码中定义的

宏.级别1(-g1)不包含局部变量和与行号有关的调试信息,因此只能够用于回溯跟踪和堆栈转储之用.回溯跟踪指的是

监视程序在运行过程中的函数调用历史,堆栈转储则是一种以原始的十六进制格式保存程序执行环境的方法,两者都

是经常用到的调试手段.

GCC产生的调试符号具有普遍的适应性,可以被许多调试器加以利用,但如果使用的是GDB,那么还可以通过-ggdb选项

在生成的二进制代码中包含GDB专用的调试信息.这种做法的优点是可以方便GDB的调试工作,但缺点是可能导致其它

调试器(如DBX)无法进行正常的调试.选项-ggdb能够接受的调试级别和-g是完全一样的,它们对输出的调试符号有着

相同的影响.

需要注意的是,使用任何一个调试选项都会使最终生成的二进制文件的大小急剧增加,同时增加程序在执行时的开销,

因此调试选项通常仅在软件的开发和调试阶段使用.调试选项对生成代码大小的影响从下面的对比过程中可以看出来

:

# gcc optimize.c -o optimize
# ls optimize -l
-rwxrwxr-x  1 xiaowp   xiaowp  11649 Nov 20 08:53 optimize  (未加调试选项)
# gcc -g optimize.c -o optimize
# ls optimize -l
-rwxrwxr-x  1 xiaowp   xiaowp  15889 Nov 20 08:54 optimize  (加入调试选项)
 

虽然调试选项会增加文件的大小,但事实上Linux中的许多软件在测试版本甚至最终发行版本中仍然使用了调试选项

来进行编译,这样做的目的是鼓励用户在发现问题时自己动手解决,是Linux的一个显著特色.

为调试编译代码(Compiling Code for Debugging)
为了使 gdb 正常工作, 你必须使你的程序在编译时包含调试信息. 调试信息包含你程序里的每个变量的类型和在可

执行文件里的地址映射以及源代码的行号. gdb 利用这些信息使源代码和机器码相关联.
◆在编译时用 -g 选项打开调试选项.
 

gdb 基本命令
     gdb 支持很多的命令使你能实现不同的功能. 这些命令从简单的文件装入到允许你检查所调用的堆栈内容的复

杂命令, 表27.1列出了你在用 gdb 调试时会用到的一些命令. 想了解 gdb 的详细使用请参考 gdb 的指南页.
  表 27.1. 基本 gdb 命令.
命   令 描  述
file 装入想要调试的可执行文件.
kill 终止正在调试的程序.
list 列出产生执行文件的源代码的一部分.
next 执行一行源代码但不进入函数内部.
step 执行一行源代码而且进入函数内部.
run 执行当前被调试的程序
quit 终止 gdb
watch 使你能监视一个变量的值而不管它何时被改变.
break 在代码里设置断点, 这将使程序执行到这里时被挂起.
make 使你能不退出 gdb 就可以重新产生可执行文件.
shell 使你能不离开 gdb 就执行 UNIX shell 命令. 

gdb 支持很多与 UNIX shell 程序一样的命令编辑特征. 你能象在 bash 或 tcsh里那样按 Tab 键让gdb 帮你补齐

一个唯一的命令, 如果不唯一的话 gdb 会列出所有匹配的命令. 你也能用光标键上下翻动历史命令.

下面还是通过一个具体的实例说明如何利用调试符号来分析错误,所用程序见清单4所示.

清单4:crash.c

#include <stdio.h>
int main(void)
{
  int input =0;
  printf(Input an integer:);
  scanf(%d, input);
  printf(The integer you input is %d\\n, input);
  return 0;
}
 

编译并运行上述代码,会产生一个严重的段错误(Segmentation fault)如下:

# gcc -g crash.c -o crash
# ./crash
Input an integer:10
Segmentation fault
 

为了更快速地发现错误所在,可以使用GDB进行跟踪调试,方法如下:

# gdb crash
GNU gdb Red Hat Linux (5.3post-0.20021129.18rh)
……
(gdb)
 

当GDB提示符出现的时候,表明GDB已经做好准备进行调试了,现在可以通过run命令让程序开始在GDB的监控下运行:

(gdb) run
Starting program: /home/xiaowp/thesis/gcc/code/crash
Input an integer:10

Program received signal SIGSEGV, Segmentation fault.
0x4008576b in _IO_vfscanf_internal () from /lib/libc.so.6
 

仔细分析一下GDB给出的输出结果不难看出,程序是由于段错误而导致异常中止的,说明内存操作出了问题,具体发生

问题的地方是在调用_IO_vfscanf_internal ( )的时候.为了得到更加有价值的信息,可以使用GDB提供的回溯跟踪命

令backtrace,执行结果如下:

(gdb) backtrace
#0  0x4008576b in _IO_vfscanf_internal () from /lib/libc.so.6
#1  0xbffff0c0 in ?? ()
#2  0x4008e0ba in scanf () from /lib/libc.so.6
#3  0x08048393 in main () at crash.c:11
#4  0x40042917 in __libc_start_main () from /lib/libc.so.6
 

跳过输出结果中的前面三行,从输出结果的第四行中不难看出,GDB已经将错误定位到crash.c中的第11行了.现在仔细

检查一下:

(gdb) frame 3
#3  0x08048393 in main () at crash.c:11
11       scanf(%d, input);
 

使用GDB提供的frame命令可以定位到发生错误的代码段,该命令后面跟着的数值可以在backtrace命令输出结果中的

行首找到.现在已经发现错误所在了,应该将

scanf(%d, input);
改为
scanf(%d, &input);
 

完成后就可以退出GDB了,命令如下:

(gdb) quit
 

GDB的功能远远不止如此,它还可以单步跟踪程序、检查内存变量和设置断点等.

调试时可能会需要用到编译器产生的中间结果,这时可以使用-save-temps选项,让GCC将预处理代码、汇编代码和目

标代码都作为文件保存起来.如果想检查生成的代码是否能够通过手工调整的办法来提高执行性能,在编译过程中生

成的中间文件将会很有帮助,具体情况如下:

# gcc -save-temps foo.c -o foo
# ls foo*
foo  foo.c  foo.i  foo.s
 

GCC支持的其它调试选项还包括-p和-pg,它们会将剖析(Profiling)信息加入到最终生成的二进制代码中.剖析信息对

于找出程序的性能瓶颈很有帮助,是协助Linux程序员开发出高性能程序的有力工具.在编译时加入-p选项会在生成的

代码中加入通用剖析工具(Prof)能够识别的统计信息,而-pg选项则生成只有GNU剖析工具(Gprof)才能识别的统计信

息.

最后提醒一点,虽然GCC允许在优化的同时加入调试符号信息,但优化后的代码对于调试本身而言将是一个很大的挑战

.代码在经过优化之后,在源程序中声明和使用的变量很可能不再使用,控制流也可能会突然跳转到意外的地方,循环

语句有可能因为循环展开而变得到处都有,所有这些对调试来讲都将是一场噩梦.建议在调试的时候最好不使用任何

优化选项,只有当程序在最终发行的时候才考虑对其进行优化.

上次的培训园地中介绍了GCC的编译过程、警告提示功能、库依赖、代码优化和程序调试六个方面的内容.这期是最

后的一部分内容.

加速

在将源代码变成可执行文件的过程中,需要经过许多中间步骤,包含预处理、编译、汇编和连接.这些过程实际上是由

不同的程序负责完成的.大多数情况下GCC可以为Linux程序员完成所有的后台工作,自动调用相应程序进行处理.

这样做有一个很明显的缺点,就是GCC在处理每一个源文件时,最终都需要生成好几个临时文件才能完成相应的工作,

从而无形中导致处理速度变慢.例如,GCC在处理一个源文件时,可能需要一个临时文件来保存预处理的输出、一个临

时文件来保存编译器的输出、一个临时文件来保存汇编器的输出,而读写这些临时文件显然需要耗费一定的时间.当

软件项目变得非常庞大的时候,花费在这上面的代价可能会变得很沉重.

解决的办法是,使用Linux提供的一种更加高效的通信方式—管道.它可以用来同时连接两个程序,其中一个程序的输

出将被直接作为另一个程序的输入,这样就可以避免使用临时文件,但编译时却需要消耗更多的内存.

在编译过程中使用管道是由GCC的-pipe选项决定的.下面的这条命令就是借助GCC的管道功能来提高编译速度的:

# gcc -pipe foo.c -o foo
 

在编译小型工程时使用管道,编译时间上的差异可能还不是很明显,但在源代码非常多的大型工程中,差异将变得非常

明显.

文件扩展名

在使用GCC的过程中,用户对一些常用的扩展名一定要熟悉,并知道其含义.为了方便大家学习使用GCC,在此将这些扩

展名罗列如下:

.c C原始程序；

.C C++原始程序；

.cc C++原始程序；

.cxx C++原始程序；

.m Objective-C原始程序；

.i 已经过预处理的C原始程序；

.ii 已经过预处理之C++原始程序；

.s 组合语言原始程序；

.S 组合语言原始程序；

.h 预处理文件(标头文件)；

.o 目标文件；

.a 存档文件.

GCC常用选项

GCC作为Linux下C/C++重要的编译环境,功能强大,编译选项繁多.为了方便大家日后编译方便,在此将常用的选项及说

明罗列出来如下:

-c 通知GCC取消链接步骤,即编译源码并在最后生成目标文件；

-Dmacro 定义指定的宏,使它能够通过源码中的#ifdef进行检验；

-E 不经过编译预处理程序的输出而输送至标准输出；

-g3 获得有关调试程序的详细信息,它不能与-o选项联合使用；

-Idirectory 在包含文件搜索路径的起点处添加指定目录；

-llibrary 提示链接程序在创建最终可执行文件时包含指定的库；

-O、-O2、-O3 将优化状态打开,该选项不能与-g选项联合使用；

-S 要求编译程序生成来自源代码的汇编程序输出；

-v 启动所有警报；

-Wall 在发生警报时取消编译操作,即将警报看作是错误；

-Werror 在发生警报时取消编译操作,即把报警当作是错误；

-w 禁止所有的报警.

小结

GCC是在Linux下开发程序时必须掌握的工具之一.本文对GCC做了一个简要的介绍,主要讲述了如何使用GCC编译程序

、产生警告信息、调试程序和加快GCC的编译速度.对所有希望早日跨入Linux开发者行列的人来说,GCC就是成为一名

优秀的Linux程序员的起跑线.