Linux下C语言编程

天云上人

  Linux的发行版中包含了很多软件开发工具。 它们中的很多是用于 C 和 C++应用程序开发的。 本文介绍了在 Linux 下能用于 C 应用程序开发和调试的工具。 本文的主旨是介绍如何在 Linux 下使用 C 编译器和其他 C 编程工具, 而非 C 语言编程的教程。 在本文中你将学到以下知识：

; g  l7 x2 k  ~8 g( E% b! j! y· 什么是 C
2 I7 }; O8 F, u0 D2 W· GNU C 编译器
3 b+ r9 C. {) D; b0 L- S# r  w3 p3 h. G· 用 gdb 来调试GCC应用程序
9 i- i% K7 `& C8 y( o& c" ~) V你也能看到随 Linux 发行的其他有用的 C 编程工具。 这些工具包括源程序美化程序(pretty print programs), 附加的调试工具, 函数原型自动生成工具(automatic function prototypers)。
% c1 I7 c/ a6 @
8 r" f' t% h" m2 H& m0 x: n6 l8 T: m注意： 源程序美化程序(pretty print programs)自动帮你格式化源代码产生始终如一的缩进格式。
# q2 S7 A' a& y5 }# a( k
什么是 C?
# X8 |1 e! y8 GC 是一种在 UNIX 操作系统的早期就被广泛使用的通用编程语言。 它最早是由贝尔实验室的 Dennis Ritchie 为了 UNIX 的辅助开发而写的, 开始时 UNIX 是用汇编语言和一种叫 B 的语言编写的。 从那时候起, C 就成为世界上使用最广泛计算机语言。

8 l* ]' j8 F% D- k0 X6 xC 能在编程领域里得到如此广泛支持的原因有以下一些：
* a: [! M6 J5 A7 p0 R3 X: e· 它是一种非常通用的语言。 几乎你所能想到的任何一种计算机上都有至少一种能用的 C 编译器。 并且它的语法和函数库在不同的平台上都是统一的, 这个特性对开发者来说很有吸引力。
( B+ N, D' J' h' ?7 I· 用 C 写的程序执行速度很快。
· C 是所有版本的UNIX上的系统语言。
C 在过去的二十年中有了很大的发展。 在80年代末期美国国家标准协会(American National Standards Institute)发布了一个被称为 ANSI C 的 C 语言标准。这更加保证了将来在不同平台上的 C 的一致性。 在80年代还出现了一种 C 的面向对象的扩展称为 C++。 C++ 将在另一篇文章 "C++ 编程"中描述。
6 `- f# m! I9 s: j- ~7 W- b# Z1 [Linux 上可用的 C 编译器是 GNU C 编译器, 它建立在自由软件基金会的编程许可证的基础上, 因此可以自由发布。 你能在 Linux 的发行光盘上找到它。
GNU C 编译器
随 Slackware Linux 发行的 GNU C 编译器(GCC)是一个全功能的 ANSI C 兼容编译器。 如果你熟悉其他操作系统或硬件平台上的一种 C 编译器, 你将能很快地掌握 GCC。 本节将介绍如何使用 GCC 和一些 GCC 编译器最常用的选项。

使用 GCC
通常后跟一些选项和文件名来使用 GCC 编译器。 gcc 命令的基本用法如下：
/ }+ r, Z7 m$ a7 }+ @gcc [options] [filenames]
2 }* \  c) F8 L* w% E& d命令行选项指定的操作将在命令行上每个给出的文件上执行。 下一小节将叙述一些你会最常用到的选项。

* U8 g. g# E# [: y  T8 V. @4 r* H- q* XGCC 选项
GCC 有超过100个的编译选项可用。 这些选项中的许多你可能永远都不会用到, 但一些主要的选项将会频繁用到。 很多的 GCC 选项包括一个以上的字符。 因此你必须为每个选项指定各自的连字符, 并且就象大多数 Linux 命令一样你不能在一个单独的连字符后跟一组选项。 例如, 下面的两个命令是不同的：
* n' A8 i; a4 ggcc -p -g test.c
# s5 H$ c; R2 R
gcc -pg test.c
第一条命令告诉 GCC 编译 test.c 时为 prof 命令建立剖析(profile)信息并且把调试信息加入到可执行的文件里。 第二条命令只告诉 GCC 为 gprof 命令建立剖析信息。
& l! J" l- p4 F
: ]4 ]1 ]! n9 C6 e7 m0 X9 k当你不用任何选项编译一个程序时, GCC 将会建立(假定编译成功)一个名为 a.out 的可执行文件。 例如, 下面的命令将在当前目录下产生一个叫 a.out 的文件：
gcc test.c
你能用 -o 编译选项来为将产生的可执行文件指定一个文件名来代替 a.out。 例如, 将一个叫 count.c 的 C 程序编译为名叫 count 的可执行文件, 你将输入下面的命令：
6 C. o: |% C7 igcc -o count count.c
$ K+ g" C# G/ }8 }! B1 l
4 y/ ~+ [" l$ j. H) g( j2 v注意： 当你使用 -o 选项时, -o 后面必须跟一个文件名。
) `1 j" a% d& j0 {. y/ a" I6 A5 V
GCC 同样有指定编译器处理多少的编译选项。 -c 选项告诉 GCC 仅把源代码编译为目标代码而跳过汇编和连接的步骤。 这个选项使用的非常频繁因为它使得编译多个 C 程序时速度更快并且更易于管理。 缺省时 GCC 建立的目标代码文件有一个 .o 的扩展名。
-S 编译选项告诉 GCC 在为 C 代码产生了汇编语言文件后停止编译。 GCC 产生的汇编语言文件的缺省扩展名是 .s 。 -E 选项指示编译器仅对输入文件进行预处理。 当这个选项被使用时, 预处理器的输出被送到标准输出而不是储存在文件里。
2 F6 Q+ N5 t- l: C; Q. U优化选项
当你用 GCC 编译 C 代码时, 它会试着用最少的时间完成编译并且使编译后的代码易于调试。 易于调试意味着编译后的代码与源代码有同样的执行次序, 编译后的代码没有经过优化。 有很多选项可用于告诉 GCC 在耗费更多编译时间和牺牲易调试性的基础上产生更小更快的可执行文件。 这些选项中最典型的是-O 和 -O2 选项。
-O 选项告诉 GCC 对源代码进行基本优化。 这些优化在大多数情况下都会使程序执行的更快。 -O2 选项告诉 GCC 产生尽可能小和尽可能快的代码。 -O2 选项将使编译的速度比使用 -O 时慢。 但通常产生的代码执行速度会更快。
除了 -O 和 -O2 优化选项外, 还有一些低级选项用于产生更快的代码。 这些选项非常的特殊, 而且最好只有当你完全理解这些选项将会对编译后的代码产生什么样的效果时再去使用。 这些选项的详细描述, 请参考 GCC 的指南页, 在命令行上键入 man gcc 。
调试和剖析选项
GCC 支持数种调试和剖析选项。 在这些选项里你会最常用到的是 -g 和 -pg 选项。
5 M) L7 R" N/ [. L0 W-g 选项告诉 GCC 产生能被 GNU 调试器使用的调试信息以便调试你的程序。 GCC 提供了一个很多其他 C 编译器里没有的特性, 在 GCC 里你能使 -g 和 -O (产生优化代码)联用。 这一点非常有用因为你能在与最终产品尽可能相近的情况下调试你的代码。 在你同时使用这两个选项时你必须清楚你所写的某些代码已经在优化时被 GCC 作了改动。 关于调试 C 程序的更多信息请看下一节"用 gdb 调试 C 程序" 。
* L- R% {! f  m# O. N-pg 选项告诉 GCC 在你的程序里加入额外的代码, 执行时, 产生 gprof 用的剖析信息以显示你的程序的耗时情况。 关于 gprof 的更多信息请参考 "gprof" 一节。
* t/ l: u) @( M' [
用 gdb 调试 GCC 程序
Linux 包含了一个叫 gdb 的 GNU 调试程序。 gdb 是一个用来调试 C 和 C++ 程序的强力调试器。 它使你能在程序运行时观察程序的内部结构和内存的使用情况。 以下是 gdb 所提供的一些功能：
· 它使你能监视你程序中变量的值。
· 它使你能设置断点以使程序在指定的代码行上停止执行。
, E2 G. O$ s; _3 x" L· 它使你能一行行的执行你的代码。

" S5 y/ w. c0 u/ {+ `5 C在命令行上键入 gdb 并按回车键就可以运行 gdb 了, 如果一切正常的话, gdb 将被启动并且你将在屏幕上看到类似的内容：
GDB is free software and you are welcome to distribute copies of it

under certain conditions; type "show copying" to see the conditions．

There is absolutely no warranty for GDB; type "show warranty" for details.
3 l5 [4 S& A- N: h* G* P1 [3 f
GDB 4.14 (i486-slakware-linux), Copyright 1995 Free Software Foundation, Inc.

, k8 T- F& k- N! T. Y7 G" \(gdb)
当你启动 gdb 后, 你能在命令行上指定很多的选项。 你也可以以下面的方式来运行 gdb ：
6 p4 a# P# M8 g; K8 a' s6 M' Sgdb
2 |; y7 Y+ Q" Q7 W% U当你用这种方式运行 gdb , 你能直接指定想要调试的程序。 这将告诉gdb 装入名为 fname 的可执行文件。 你也可以用 gdb 去检查一个因程序异常终止而产生的 core 文件, 或者与一个正在运行的程序相连。 你可以参考 gdb 指南页或在命令行上键入 gdb -h 得到一个有关这些选项的说明的简单列表。

4 T) z2 |( g5 \# {8 M/ u为调试编译代码(Compiling Code for Debugging)
为了使 gdb 正常工作, 你必须使你的程序在编译时包含调试信息。 调试信息包含你程序里的每个变量的类型和在可执行文件里的地址映射以及源代码的行号。 gdb 利用这些信息使源代码和机器码相关联。
在编译时用 -g 选项打开调试选项。

9 v: g, H% l* Ggdb 基本命令
gdb 支持很多的命令使你能实现不同的功能。 这些命令从简单的文件装入到允许你检查所调用的堆栈内容的复杂命令, 表27.1列出了你在用 gdb 调试时会用到的一些命令。 想了解 gdb 的详细使用请参考 gdb 的指南页。
" D9 e2 ]2 F( |  X8 G% X1 [表 27.1. 基本 gdb 命令.
命令描述
file 装入想要调试的可执行文件。
kill 终止正在调试的程序。
8 H9 a# t) k, c, \6 d& ulist 执行一行源代码但不进入函数内部。
1 D# O0 Y$ B" Y/ e4 u: knext 执行一行源代码但不进入函数内部。
step 执行一行源代码而且进入函数内部。
4 }+ Y: c4 w) [: ^; O/ Rrun 执行当前被调试的程序
quit 终止 gdb
- x* `4 v# z3 A( D6 Fwatch 使你能监视一个变量的值而不管它何时被改变。
break 在代码里设置断点, 这将使程序执行到这里时被挂起。
make 使你能不退出 gdb 就可以重新产生可执行文件。
shell 使你能不离开 gdb 就执行 UNIX shell 命令。
" Q# ?( r. T4 R7 p$ Kgdb 支持很多与 UNIX shell 程序一样的命令编辑特征。 你能象在 bash 或 tcsh里那样按 Tab 键让 gdb 帮你补齐一个唯一的命令, 如果不唯一的话 gdb 会列出所有匹配的命令。 你也能用光标键上下翻动历史命令。
gdb 应用举例
本节用一个实例教你一步步的用 gdb 调试程序。 被调试的程序相当的简单, 但它展示了 gdb 的典型应用。
' D' ?# T' H, |* s
下面列出了将被调试的程序。 这个程序被称为 greeting , 它显示一个简单的问候, 再用反序将它列出。
#include
main ()
4 P' L, z$ c  w8 T# ?, k4 @{
5 {" n9 p3 ?$ z# K8 l1 rchar my_string[] = "hello there";
6 W+ a9 h# p( Z7 ^my_print (my_string);
my_print2 (my_string);
}
1 G4 U4 A) r5 U) w* a' Q, @# zvoid my_print (char *string)
{
printf ("The string is %s\n", string);
4 @/ j) X( `; {6 M}
$ j9 [8 N' H. M1 C  ?void my_print2 (char *string)
( O7 V3 g* W- D" r' F) ]0 `{
char *string2;
/ O" ^2 H; t* p9 E6 pint size, i;
size = strlen (string);
) x: X9 `3 T$ E, Ustring2 = (char *) malloc (size + 1);
for (i = 0; i < size; i++)
7 e1 O4 y0 S/ Z' O9 T! Kstring2[size - i] = string;
9 ]$ V. r7 I% t. ustring2[size+1] = `\0;
printf ("The string printed backward is %s\n", string2);
  N5 F) J9 N7 j- L) G5 v& G0 n}
) K- i! L0 `9 g% X+ A0 V- E用下面的命令编译它：
gcc -o test test.c
这个程序执行时显示如下结果：
The string is hello there
The string printed backward is
输出的第一行是正确的, 但第二行打印出的东西并不是我们所期望的。 我们所设想的输出应该是：
9 d6 l" k# J: _8 @" H$ S& ZThe string printed backward is ereht olleh
8 q: k* h/ n1 Y1 ^/ L+ T由于某些原因, my_print2 函数没有正常工作。 让我们用 gdb 看看问题究竟出在哪儿, 先键入如下命令：
! e5 f. Y! N1 z# p6 rgdb greeting
1 N9 |( Q/ g8 {, b注意： 记得在编译 greeting 程序时把调试选项打开。
0 k3 K; V& a! L: G: G% U
如果你在输入命令时忘了把要调试的程序作为参数传给 gdb , 你可以在 gdb 提示符下用 file 命令来载入它：
4 h* h' T- ^6 W! Q; w: g
(gdb) file greeting
这个命令将载入 greeting 可执行文件就象你在 gdb 命令行里装入它一样。
这时你能用 gdb 的 run 命令来运行 greeting 了。 当它在 gdb 里被运行后结果大约会象这样：
, D/ z( l4 ~1 y" b6 z7 U(gdb) run

Starting program： /root/greeting

, w2 x+ D9 F8 O3 A1 B* {The string is hello there
+ k1 g4 u$ v! r( k
" ^: J( _( ^; y4 Y  l( fThe string printed backward is

Program exited with code 041
& X6 i% J  q, G( E1 M3 X1 e: g这个输出和在 gdb 外面运行的结果一样。 问题是, 为什么反序打印没有工作? 为了找出症结所在, 我们可以在 my_print2 函数的 for 语句后设一个断点, 具体的做法是在 gdb 提示符下键入 list 命令三次, 列出源代码：
9 {( x+ y$ w) C  u(gdb) list
/ X% Q1 i1 c, b
(gdb) list
7 N: z$ u5 a# A) w0 Q
(gdb) list

" ~' P+ n& g& Q- r技巧： 在 gdb 提示符下按回车健将重复上一个命令。
! a: i. n$ k9 M  H; M  a
3 r. ^' L, b4 S: m第一次键入 list 命令的输出如下：

1 #include
7 f# o* I/ y% J
2

3 main ()

$ W8 J7 @7 H+ I4 {
3 q9 t  }) Y) u
# t2 l# e; i) X) c! _5 char my_string[] = "hello there";

: w: k6 O( |7 H9 d5 w( \6

$ a# U( b' }1 l7 my_print (my_string);

8 my_print2 (my_string);
' P* M) W' d& W6 j* y/ A; ~4 [
9 }
! A- C2 `: m" Y$ ^  i
" j& r( W7 o  R6 A  a) e  R10
如果按下回车, gdb 将再执行一次 list 命令, 给出下列输出：
# K5 ~, \) `+ p- U1 G! M9 f9 M2 D
11 my_print (char *string)

12 {
* q  W5 e9 j: Y
" u4 T  O2 T$ N: c  {13 printf ("The string is %s\n", string);

1 J1 z* c3 b8 A14 }

15
8 S6 A+ H" M5 ^$ S" X! n- H' `" a! K
16 my_print2 (char *string)

2 B! I4 j& P+ o) `# ?17 {
' z' _1 G3 a: ?9 @, f0 e0 \
18 char *string2;
5 t" N) _# Y9 k' q" B
19 int size, i;

20
" U/ N; \  p# a) ~/ B2 p- b再按一次回车将列出 greeting 程序的剩余部分：
21 size = strlen (string);
! i. c. y1 N2 a' z) z
+ M! L4 e, I9 e22 string2 = (char *) malloc (size + 1);

* h/ n: W( S' a7 u, O6 ?2 x, s23 for (i = 0; i < size; i++)

& j) W: q. W  ~9 T* [3 L24 string2[size - i] = string;
+ ^& B( c0 ?/ m& u1 p
25 string2[size+1] = `\0;
! s1 f  x6 w1 E$ B) R' u
2 E" {+ }0 Y4 O9 h26 printf ("The string printed backward is %s\n", string2);
/ F2 L% q9 H+ Q6 @# g7 H& o! r9 x
$ u$ x. _, D% _  {) i27 }
根据列出的源程序, 你能看到要设断点的地方在第24行, 在 gdb 命令行提示符下键入如下命令设置断点：
( E& K+ C) K6 z( N- ~+ o) B0 `3 P(gdb) break 24
+ d, Q1 @3 a) a0 F4 M+ O. jgdb 将作出如下的响应：
Breakpoint 1 at 0x139： file greeting.c, line 24

2 I) o( x  Y5 C- w(gdb)

现在再键入 run 命令, 将产生如下的输出：

Starting program： /root/greeting
/ X( B" w; X0 i. m: ]6 L
" C  `, T) A; q" @; v" CThe string is hello there
Breakpoint 1, my_print2 (string = 0xbfffdc4 "hello there") at greeting.c ：24
# g) ]* M$ J" \( p! p
24 string2[size-i]=string
% E" r* g8 O: l. u你能通过设置一个观察 string2[size - i] 变量的值的观察点来看出错误是怎样产生的, 做法是键入：
% t1 b/ P! Z& K. ^
$ A/ M  i: z/ E: m& I8 r% b(gdb) watch string2[size - i]
5 f4 G& Y2 h2 O% z3 Kgdb 将作出如下回应：
Watchpoint 2： string2[size - i]
现在可以用 next 命令来一步步的执行 for 循环了：

(gdb) next
经过第一次循环后, gdb 告诉我们 string2[size - i] 的值是 `h`。 gdb 用如下的显示来告诉你这个信息：

- ~/ {& ?2 `$ I1 _: XWatchpoint 2, string2[size - i]

9 h" G: a! D: B5 C) K0 ]6 ?* A1 M& WOld value = 0 `\000
$ D* t. W- ?1 X/ [# S0 C4 \2 Z
8 R' K; w6 A- U+ SNew value = 104 `h

my_print2(string = 0xbfffdc4 "hello there") at greeting.c：23

. M5 \! m: M9 R8 k% Z23 for (i=0; i
这个值正是期望的。 后来的数次循环的结果都是正确的。 当 i=10 时, 表达式 string2[size - i] 的值等于 `e`, size - i 的值等于 1, 最后一个字符已经拷到新串里了。
如果你再把循环执行下去, 你会看到已经没有值分配给 string2[0] 了, 而它是新串的第一个字符, 因为 malloc 函数在分配内存时把它们初始化为空(null)字符。 所以 string2 的第一个字符是空字符。 这解释了为什么在打印 string2 时没有任何输出了。
7 T: J" J3 ~' b2 I现在找出了问题出在哪里, 修正这个错误是很容易的。 你得把代码里写入 string2 的第一个字符的的偏移量改为 size - 1 而不是 size。 这是因为 string2 的大小为 12, 但起始偏移量是 0, 串内的字符从偏移量 0 到 偏移量 10, 偏移量 11 为空字符保留。
  W3 q* K3 [' b为了使代码正常工作有很多种修改办法。 一种是另设一个比串的实际大小小 1 的变量。 这是这种解决办法的代码：
#include
6 V4 ?0 O  d" C  H, m: w( Q0 lmain ()
{
1 _$ y4 R' J7 ~
, P: m3 ?- B( Z$ k, `/ g; echar my_string[] = "hello there";
6 f6 f% i3 g9 [my_print (my_string);

my_print2 (my_string);
; z4 T; w( B, A/ G. x
2 B5 u4 Q' |1 K  T' L}
my_print (char *string)

{
# p+ ~# X% u/ C6 V2 w8 y
printf ("The string is %s\n", string);

& [: _4 G+ [6 A' P6 t* q; Y}
! a) _2 ~% a/ w* b- V8 }my_print2 (char *string)
0 B- v( b' A( q4 Y0 H
{

char *string2;
& L* K: {: U1 D7 g5 m9 O( j' z
int size, size2, i;
size = strlen (string);

size2 = size -1;

, J5 J0 z8 s# U& t3 O' Vstring2 = (char *) malloc (size + 1);
5 @1 x1 I, U' f3 l- X
for (i = 0; i < size; i++)

" @  ^' D) U3 d7 \, }string2[size2 - i] = string;
" U' _8 s6 T# Q6 Q1 u; m& r5 b8 L
string2[size] = `\0;
) g5 C: M) \' K8 }, W
( c/ }" E$ Z! t$ |8 s; ^printf ("The string printed backward is %s\n", string2);
- `6 h+ I9 h; A. G
# K6 [/ J6 B# A0 ?: \& a( A/ e}
另外的 C 编程工具
- M* J' z" x$ u9 K5 k- I8 Q6 Q8 USlackware Linux 的发行版中还包括一些我们尚未提到的 C 开发工具。 本节将介绍这些工具和它们的典型用法。
% @' Y. |) h" Y: [, [4 z9 Vxxgdb
xxgdb 是 gdb 的一个基于 X Window 系统的图形界面。 xxgdb 包括了命令行版的 gdb 上的所有特性。 xxgdb 使你能通过按按钮来执行常用的命令。 设置了断点的地方也用图形来显示。

你能在一个 Xterm 窗口里键入下面的命令来运行它：
9 f# j7 a0 }0 Zxxgdb
# Q4 ~3 _  ]8 k你能用 gdb 里任何有效的命令行选项来初始化 xxgdb 。 此外 xxgdb 也有一些特有的命令行选项, 表 27.2 列出了这些选项。

表 27.2. xxgdb 命令行选项.
选 项 描 述
: N0 s* C4 B& c8 t7 S% bdb_name 指定所用调试器的名字, 缺省是 gdb。
( v- e  K) e& o0 d! Adb_prompt 指定调试器提示符, 缺省为 gdb。
gdbinit 指定初始化 gdb 的命令文件的文件名, 缺省为 .gdbinit。
nx 告诉 xxgdb 不执行 .gdbinit 文件。
bigicon 使用大图标。
8 P8 B0 y6 H2 r5 {$ m, F( pcalls
  Z8 ?5 R% V: w4 J你可以在 sunsite.unc.edu FTP 站点用下面的路径：
6 m* K2 o0 H  ]" L$ F1 Q/pub/Linux/devel/lang/c/calls.tar.Z
  ~! ~5 ]- P7 l  X来取得 calls , 一些旧版本的 Linux CD-ROM 发行版里也附带有。 因为它是一个有用的工具, 我们在这里也介绍一下。 如果你觉得有用的话, 从 BBS, FTP, 或另一张CD-ROM 上弄一个拷贝。 calls 调用 GCC 的预处理器来处理给出的源程序文件, 然后输出这些文件的里的函数调用树图。
注意： 在你的系统上安装 calls , 以超级用户身份登录后执行下面的步骤： 1． 解压和 untar 文件。 2．cd 进入 calls untar 后建立的子目录。 3．把名叫 calls 的文件移动到 /usr/bin 目录。 4．把名叫 calls.1 的文件移动到目录 /usr/man/man1 。 5．删除 /tmp/calls 目录。 这些步骤将把 calls 程序和它的指南页安装载你的系统上。
  C% p* N/ J3 `* @! K7 K
当 calls 打印出调用跟踪结果时, 它在函数后面用中括号给出了函数所在文件的文件名：
  U; r4 K& W+ H5 S* kmain [test.c]
/ c' F% A( p$ c2 G  s1 K如果函数并不是向 calls 给出的文件里的, calls 不知道所调用的函数来自哪里, 则只显示函数的名字：
printf
calls 不对递归和静态函数输出。 递归函数显示成下面的样子：
fact <<< recursive in factorial.c >>>
$ R2 M1 P& y) R8 `, D静态函数象这样显示：
5 o6 u) k. H1 _# l: Mtotal [static in calculate.c]
& v9 j+ h8 p2 ]! p! p3 q作为一个例子, 假设用 calls 处理下面的程序：
& E( @$ A' Y7 Q' q, @0 G/ S
#include
main ()

- I# |) u' h( @. A3 d& B( O{
+ A) ?& E+ c) h
char my_string[] = "hello there";

5 d  u$ S+ ?4 Gmy_print (my_string);
2 B1 @3 E3 l# G( s2 x+ e  k
5 X) ^* w7 E0 N9 I. l1 pmy_print2(my_string);

}
my_print (char *string)

; I" L# ~+ g$ q9 C! `9 ^( l{

printf ("The string is %s\n", string);

9 k" n, G  F& I; A}
my_print2 (char *string)

{
, w: d- g0 @, z
- N. Z* o6 \8 ]/ _4 v$ Qchar *string2;

int size, size2, i;
& Y4 z/ C0 F  Y, N" S9 }  X  D9 Ssize = strlen (string);
+ I# Q1 T2 k& F: n
3 x4 R# S9 q. u9 X3 z- T1 y1 `: isize2 = size -1;

string2 = (char *) malloc (size + 1);
. g9 a3 N+ V% h2 J& M
for (i = 0; i < size; i++)

5 R2 v1 R7 c* {string2[size2 - i] = string;

2 j/ a% X; m8 s  K7 P- s  T  zstring2[size] = `\0;

printf ("The string printed backward is %s\n", string2);
& g1 f' o6 f+ W! J; x
}
将产生如下的输出：
! t" Z7 y5 Y2 X# _4 e9 s( I( l  I1 main [test.c]

2 my_print [test.c]
, x" k! C9 D5 J) S
3 printf
' {2 l/ Y4 X0 V- y. D
4 my_print2 [test.c]

# a  s8 w# p. L3 C5 strlen
7 q. V  d% D1 e+ x+ G
/ e, B4 C3 z" ]4 x6 r3 x6 malloc
* F) y: c- X( ], ?' Q
7 printf
calls 有很多命令行选项来设置不同的输出格式, 有关这些选项的更多信息请参考 calls 的指南页。 方法是在命令行上键入 calls -h 。
cproto
, ~( E4 i8 D* e4 Y, V0 Z4 _+ R9 @cproto 读入 C 源程序文件并自动为每个函数产生原型申明。 用 cproto 可以在写程序时为你节省大量用来定义函数原型的时间。
( s/ N6 [$ N: J$ D+ |1 m9 u- P如果你让 cproto 处理下面的代码：
- K* b3 m& w1 J* t$ A8 p#include
main ()

{

char my_string[] = "hello there";

1 D! n7 ]" Q' e1 a' V8 H) j  wmy_print (my_string);

- ^5 r1 h& G( Q3 Smy_print2(my_string);

7 j7 Y" r. _' l! `8 h- J' @, `8 e}
my_print (char *string)
; a  [6 x4 f2 B5 [5 F. g& R# Q  u
{

printf ("The string is %s\n", *string);

  R) k/ Q5 K' X, v$ L. ~8 q}
. W* M& d6 p4 Y: x2 Dmy_print2 (char *string)
  F+ V. F2 k, n2 @* v9 a
{
) B) o3 {3 J' L& I# ^2 Z! }
5 O6 f: S4 B+ i  x" D$ M/ |char *string2;

7 X* M1 r, ^$ o  x6 mint size, size2, i;
size = strlen (string);

. ?; L7 L5 [" Z# B# i) {4 R6 Lsize2 = size -1;
* D: S7 i3 l9 O0 r
; R1 b3 M1 ~# qstring2 = (char *) malloc (size + 1);

% c' G( r0 L0 p6 o) V, ~- ufor (i = 0; i < size; i++)
0 q* T4 }# e9 ^3 C
string2[size2 - i] = string;

9 Q  m1 {% q) gstring2[size] = `\0;

: Q2 [- }) c' eprintf ("The string printed backward is %s\n", string2);
0 E' U( O- Z. m( w( z
}
你将得到下面的输出：
  q- o8 e. h2 j$ b( @, H/* test.c */
& ~- y. Y# n+ H
int main(void);

8 y3 S- h$ g* T+ e" u& p; nint my_print(char *string);

9 Q$ B( S6 g2 t: D3 g0 Wint my_print2(char *string);
9 M! ]' S1 ~) n7 I9 d# @这个输出可以重定向到一个定义函数原型的包含文件里。
7 v( s% o, ^0 S  q$ |6 |# _indent
indent 实用程序是 Linux 里包含的另一个编程实用工具。 这个工具简单的说就为你的代码产生美观的缩进的格式。 indent 也有很多选项来指定如何格式化你的源代码。这些选项的更多信息请看indent 的指南页, 在命令行上键入 indent -h 。
5 s" F: \' U% |* \8 B/ g2 z
下面的例子是 indent 的缺省输出：
运行 indent 以前的 C 代码：
#include
main () {
( Q, [6 U9 ^% z# C
. y9 u- H1 n: [4 N. uchar my_string[] = "hello there";
6 \' M, {; N* i/ F5 t/ s& a6 m
my_print (my_string);

" l, \9 a8 u* S( n% [my_print2(my_string); }
my_print (char *string)
, v/ B0 C' b0 J- C  c{
! ]) ~+ O1 b6 h3 C: m2 \! P7 ?printf ("The string is %s\n", *string);
/ a2 {8 D( Y+ W+ q& M' z
1 u9 o; y4 [% l2 e& J) q}
my_print2 (char *string) {

- E' s7 g2 ?/ r3 x) _3 ]6 t2 T  Zchar *string2;

6 G+ L# r4 n9 }1 p  v0 t5 c% Iint size, size2, i;
7 ]% U9 u- \% A+ C5 Xsize = strlen (string);
$ Y* w' r& [* l* b3 Y. k
; K$ p1 U$ }- j" d8 M4 F8 }size2 = size -1;

0 b/ c' {5 h! Pstring2 = (char *) malloc (size + 1);

# ~6 m* N, L4 |5 r& Xfor (i = 0; i < size; i++)

" F) W5 j7 @, o& a/ z; F9 rstring2[size2 - i] = string;
* B8 y$ r6 W2 l' E8 [' N- W7 Z
$ @# [2 k- E0 M( h; Cstring2[size] = `\0;
4 p& i+ X! l3 Eprintf ("The string printed backward is %s\n", string2);
; ^5 Z6 A1 |! c, @$ o
7 M+ s% I) F! Z+ v}
: R8 Q# c5 J2 x# M8 f运行 indent 后的 C 代码：
+ S7 [, D, [  a% j' i#include
+ g  o! F% B8 A8 X, Cmain ()
{
char my_string[] = "hello there";
3 P7 f- j0 P" h1 E/ T& t! k& J7 t
/ s  o* e$ t; K8 w( gmy_print (my_string);
: {% n# m  I+ z9 ?) q1 n/ r
my_print2 (my_string);
- |' f- |- F) B0 C  U
! o  @7 G0 w  a4 r) i) d}
$ g1 Z- [% F$ L2 N2 wmy_print (char *string)
( R! H; I$ j( c" f. d* J$ B
+ ]. ~4 G* H+ r2 @% L5 a) O9 O{
printf ("The string is %s\n", *string);
my_print2 (char *string)
{
. h  m4 l. x) H) Y* P" Mchar *string2;

+ \" S- n6 B  w- D$ q3 H, Mint size, size2, i;
size = strlen (string);

( M- q  C  @, P5 ]size2 = size -1;

/ \  |1 {6 b# I# @string2 = (char *) malloc (size + 1);
: M2 A/ m# n; X1 J. s( q0 Q
' W7 u. N2 V' x' Y8 v/ X$ b7 Kfor (i = 0; i < size; i++)
' ~' R6 w% ^) I( O
1 v0 j. D9 r* ], v% Estring2[size2 - i] = string;
9 G6 p5 r+ Q( G8 M# [6 [5 c' d3 V
string2[size] = `\0;
6 X2 R7 Q: _* O% d
printf ("The string printed backward is %s\n", string2);

}
3 j+ C5 S: ~9 o3 R: ^1 yindent 并不改变代码的实质内容, 而只是改变代码的外观。 使它变得更可读, 这永远是一件好事。
1 e: k/ b. ~, K. U" Ngprof
. t* {& ]+ K$ m, G( B0 s0 Lgprof 是安装在你的 Linux 系统的 /usr/bin 目录下的一个程序。 它使你能剖析你的程序从而知道程序的哪一个部分在执行时最费时间。
gprof 将告诉你程序里每个函数被调用的次数和每个函数执行时所占时间的百分比。 你如果想提高你的程序性能的话这些信息非常有用。
8 s; q& i/ Y; h9 }, V' T为了在你的程序上使用 gprof, 你必须在编译程序时加上 -pg 选项。 这将使程序在每次执行时产生一个叫 gmon.out 的文件。 gprof 用这个文件产生剖析信息。
在你运行了你的程序并产生了 gmon.out 文件后你能用下面的命令获得剖析信息：
gprof
参数 program_name 是产生 gmon.out 文件的程序的名字。
. |1 s6 J4 D( A' w技巧： gprof 产生的剖析数据很大, 如果你想检查这些数据的话最好把输出重定向到一个文件里。
# ~7 T8 s/ {2 I# m. mf2c 和 p2c
f2c 和 p2c 是两个源代码转换程序。 f2c 把 FORTRAN 代码转换为 C 代码, p2c 把 Pascal 代码转换为 C 代码。 当你安装 GCC 时这两个程序都会被安装上去。
) ?( O4 j2 d( P, A0 K% ~如果你有一些用 FORTRAN 或 Pascal 写的代码要用 C 重写的话, f2c 和 p2c 对你非常有用。 这两个程序产生的 C 代码一般不用修改就直接能被 GCC 编译。
2 j% R. {7 D0 m* Q如果要转换的 FORTRAN 或 Pascal 程序比较小的话可以直接使用 f2c 或 p2c 不用加任何选项。 如果要转换的程序比较庞大, 包含很多文件的话你可能要用到一些命令行选项。
2 j, C: p, G% t! b在一个 FORTRAN 程序上使用 f2c , 输入下面的命令：
f2c my_fortranprog.f
$ ]- l) P: J1 e" @1 w& U5 c
7 T6 ~: t) e  {6 f- \1 H注意： f2c 要求被转换的程序的扩展名为 .f 或 a .F 。

% h! f2 ]! G0 R/ x7 t5 v, l, E要把一个Pascal 程序装换为 C 程序, 输入下面的命令：
p2c my_pascalprogram.pas
+ X# i  |2 b' }3 [! B: p这两个程序产生的 C 源代码的文件名都和原来的文件名相同, 但扩展名由 .f 或 .pas 变为 .c 。