Linux下C语言编程基础知识

这篇文章介绍在LINUX下进行C语言编程所需要的基础知识。在这篇文章当中，我们将会学到以下内容：  
3 Y) W( }* [" V9 r, r% t源程序编译  
0 F& ^3 o# T, B* nMakefile的编写  
) R0 V# W" G6 ^0 Q程序库的链接  7 j2 P+ B" R' c' A5 f6 p& L+ ~* x
程序的调试  , J+ q1 a& r/ N/ j+ X( M: K( A5 b
头文件和系统求助  , U7 f5 d) \: L& d
1.源程序的编译  
+ p0 A" x0 [, K在Linux下面，如果要编译一个C语言源程序，我们要使用GNU的gcc编译器。 下面我们以一个实例来说明如何使用gcc编译器。  
' U& k9 M& i. E/ C; U! J3 r假设我们有下面一个非常简单的源程序(hello.c)：  0 _4 R5 _  ~6 O' k8 M' ?9 L' L/ M
int main(int argc，char **argv)  + f9 a4 J1 ?; L
{  ' L) L/ H( U0 F3 G0 ]
printf("Hello Linux\n")；  ( E3 b2 a2 Z9 l6 Q5 _
}  
; ~9 m' {9 R9 m3 P  D" I3 s+ i要编译这个程序，我们只要在命令行下执行：    K2 O# K; H( p
gcc -o hello hello.c  * [/ l$ J1 j6 v: q  P
gcc 编译器就会为我们生成一个hello的可执行文件。执行./hello就可以看到程序的输出结果了。命令行中 gcc表示我们是用gcc来编译我们的源程序，-o 选项表示我们要求编译器给我们输出的可执行文件名为hello 而hello.c是我们的源程序文件。  # z1 u. z2 y6 f# Z  P8 p  a4 N
gcc编译器有许多选项，一般来说我们只要知道其中的几个就够了。 -o选项我们已经知道了，表示我们要求输出的可执行文件名。 -c选项表示我们只要求编译器输出目标代码，而不必要输出可执行文件。 -g选项表示我们要求编译器在编译的时候提供我们以后对程序进行调试的信息。  
0 t. d7 R2 T, n5 Y* N) S  K知道了这三个选项，我们就可以编译我们自己所写的简单的源程序了，如果你想要知道更多的选项，可以查看gcc的帮助文档，那里有着许多对其它选项的详细说明。  : u  t6 ^  n) p$ {4 k: C  v
2.Makefile的编写  
$ {% m$ s# j3 l假设我们有下面这样的一个程序，源代码如下：  3 S! n9 H" }. O( i. l
/* main.c */  
# K+ t7 q, f4 Y, \#include "mytool1.h"  
0 h5 V9 A! v/ P4 W4 I8 t" |#include "mytool2.h"  
, G9 s, ^  P* _" {: w# ^7 Pint main(int argc，char **argv)  ' i/ r* l# e; H; U" ^6 X/ v, L" [' {
{  
* r7 I0 G! V! f4 Umytool1_print("hello")；  
/ j3 J3 j, a) x. B6 N9 U: jmytool2_print("hello")；  
, e) x8 @) L: y8 D" u3 O}  - X6 }( w0 z. U9 T" W. q) }
/* mytool1.h */  
, _2 t; a9 d8 {+ k5 _$ _#ifndef _MYTOOL_1_H  . C8 e9 I9 g9 P3 i
#define _MYTOOL_1_H  
. W( A; ~" i' `' @7 Z, Avoid mytool1_print(char *print_str)；  
+ n  ?( H( @; `6 f% M- u1 \; M* Q9 f#endif  3 Z0 Y; o2 X/ N$ A5 Z0 g3 i
/* mytool1.c */  " v8 z2 ^9 M+ t  C* @) s/ S3 @6 b
#include "mytool1.h"  
; {( U( F+ y7 e+ E. x6 f' Fvoid mytool1_print(char *print_str)  . \2 f+ _# s4 }: N& i
{  
5 ]) u" T3 x4 d' Z. J! o1 K2 S# Zprintf("This is mytool1 print %s\n"，print_str)；  
9 O4 B3 X4 H; h1 u+ M% u}  * l3 M# O" T; [3 [
/* mytool2.h */  
, U/ I9 j- r* v3 B6 i#ifndef _MYTOOL_2_H  
- T$ X! G  ~) f8 d/ r& U3 `( y, x) k3 J8 y#define _MYTOOL_2_H  
5 V5 x3 N$ q/ U5 n! W7 ivoid mytool2_print(char *print_str)；  
3 J$ G! S, u/ ~#endif  # F3 z7 P/ q0 z% c. q
/* mytool2.c */  
2 Q) K9 M3 V' O#include "mytool2.h"  
# u$ y/ c+ g+ U7 Y3 m- @/ |  C% u! v2 lvoid mytool2_print(char *print_str)  5 e6 m0 \  b9 U. [) F: z6 l) G$ X# W
{  1 ^  m7 ]3 u0 _* a: E
printf("This is mytool2 print %s\n"，print_str)；  
, x* c) w: T4 D6 a) I9 q# t* c}  ) i* t, ?+ K- Z1 t
当然由于这个程序是很短的我们可以这样来编译  
; P" ^- w$ J* b7 V' a& sgcc -c main.c  1 b5 Q5 v0 l- y/ l& e% j) _2 g
gcc -c mytool1.c  
0 m9 `- N; l1 |3 g; [+ g. g* W* ugcc -c mytool2.c  
( z) b1 H6 |1 Z( W. Dgcc -o main main.o mytool1.o mytool2.o  1 o& a" I; b5 |+ R
这样的话我们也可以产生main程序，而且也不时很麻烦。但是如果我们考虑一下如果有一天我们修改了其中的一个文件(比如说mytool1.c)那么我们 难道还要重新输入上面的命令?也许你会说，这个很容易解决啊，我写一个SHELL脚本，让她帮我去完成不就可以了。是的对于这个程序来说，是可以起到作用 的。但是当我们把事情想的更复杂一点，如果我们的程序有几百个源程序的时候，难道也要编译器重新一个一个的去编译?  - S# |7 @% g; c! g& S/ a! t
为此，聪明的程序员们想出了一个很好的工具来做这件事情，这就是make。我们只要执行以下make，就可以把上面的问题解决掉。在我们执行make之 前，我们要先编写一个非常重要的文件。--Makefile。对于上面的那个程序来说，可能的一个Makefile的文件是：  9 a2 U, W& v2 ]3 p- g
# 这是上面那个程序的Makefile文件  1 O+ i( _6 w% e7 f
main：main.o mytool1.o mytool2.o  ; R' v  c: e" q' Y/ y" ]: Q) C' ]& `
gcc -o main main.o mytool1.o mytool2.o  
- {# T# {3 ?! m/ H  X3 D' nmain.o：main.c mytool1.h mytool2.h  ! }! L$ S9 J( s+ Q6 _
gcc -c main.c    h; a1 p$ I0 \* H
mytool1.o：mytool1.c mytool1.h  
' x: U4 C! W7 D& ]( Dgcc -c mytool1.c  6 N- G. k% O  ^
mytool2.o：mytool2.c mytool2.h  
; K' p) D8 c/ y* z  ?  zgcc -c mytool2.c  
1 C3 ^. p0 ]. ?8 i0 |有了这个Makefile文件，不过我们什么时候修改了源程序当中的什么文件，我们只要执行make命令，我们的编译器都只会去编译和我们修改的文件有关的文件，其它的文件她连理都不想去理的。  - c! j8 O4 L( R
下面我们学习Makefile是如何编写的。  ) I  I, v0 s) d( F, n
在Makefile中也#开始的行都是注释行.Makefile中最重要的是描述文件的依赖关系的说明。一般的格式是：  
$ [: j( N; R5 D! G* m4 Mtarget：components    `$ d: K( G2 |- S' K5 H
TAB rule  . j8 ^. y/ [' }& A
第一行表示的是依赖关系。第二行是规则。  
& |1 T- j1 p; v) ?' e比如说我们上面的那个Makefile文件的第二行  
( w# Q* a/ c3 \8 q6 [+ k/ V/ A. H$ vmain：main.o mytool1.o mytool2.o  
3 K2 s3 y+ ?* ~* f2 D7 B7 N表示我们的目标 (target)main的依赖对象(components)是main.o mytool1.o mytool2.o 当倚赖的对象在目标修改后修改的话，就要去执行规则一行所指定的命令。就象我们的上面那个Makefile第三行所说的一样要执行 gcc -o main main.o mytool1.o mytool2.o 注意规则一行中的TAB表示那里是一个TAB键  ) L* A2 p6 r/ j+ u3 R
Makefile有三个非常有用的变量。分别是$@，$^，$~/sin 命令，然后看~/sin文件，到那里面去找了。在sin文件当中，我会找到这样的一行libm-2.1.2.so：00009fa0 W sin 这样我就知道了sin在 libm-2.1.2.so库里面，我用 -lm选项就可以了(去掉前面的lib和后面的版本标志，就剩下m了所以是 -lm)。 如果你知道怎么找，请赶快告诉我，我回非常感激的。谢谢!  
' ]1 c7 E. ?, v2 r. a6 [! M4.程序的调试  2 L) q( [% M3 \3 X1 ]4 l
我们编写的程序不太可能一次性就会成功的，在我们的程序当中，会出现许许多多我们想不到的错误，这个时候我们就要对我们的程序进行调试了。  
3 w2 t$ n) j: q0 Y最常用的调试软件是gdb.如果你想在 图形界面下调试程序，那么你现在可以选择xxgdb.记得要在编译的时候加入 -g选项.关于gdb的使用可以看gdb的帮助文件。由于我没有用过这个软件，所以我也不能够说出如何使用。不过我不喜欢用gdb.跟踪一个程序是很烦的 事情，我一般用在程序当中输出中间变量的值来调试程序的。当然你可以选择自己的办法，没有必要去学别人的。现在有了许多IDE环境，里面已经自己带了调试 器了。你可以选择几个试一试找出自己喜欢的一个用。  
; z& M" |/ C7 K7 i2 i5.头文件和系统求助  , e; y' M1 c- I/ D0 P) b
有时候我们只知道一个函数的大概形式，不记得确切的表达式，或者是不记得着函数在那个头文件进行了说明。这个时候我们可以求助系统。  
% X& [+ B! r9 h5 A. j比如说我们想知道 fread这个函数的确切形式，我们只要执行 man fread 系统就会输出着函数的详细解释的。和这个函数所在的头文件说明了。 如果我们要write这个函数的说明，当我们执行man write时，输出的结果却不是我们所需要的。 因为我们要的是write这个函数的说明，可是出来的却是write这个命令的说明。为了得到write的函数说明我们要用 man 2 write. 2表示我们用的write这个函数是系统调用函数，还有一个我们常用的是3表示函数是C的库函数。  
  t  [- M( R- u0 V6 L记住不管什么时候，man都是我们的最好助手。  1 z) Q4 w7 ^' d5 y+ F0 l
好了，这一章就讲这么多了，有了这些知识我们就可以进入激动人心的Linux下的C程序探险活动。