gcc/g++编译

GCC 有超过100个的编译选项可用. 这些选项中的许多你可能永远都不会用到, 但一些主要的选项将会频繁用到. 很多的 GCC 选项包括一个以上的字符. 因此你必须为每个选项指定各自的连字符, 并且就象大多数 Linux 命令一样你不能在一个单独的连字符后跟一组选项. 例如, 下面的两个命令是不同的:
gcc -p -g test.c

gcc -pg test.c
第一条命令告诉 GCC 编译 test.c 时为 prof 命令建立剖析(profile)信息并且把调试信息加入到可执行的文件里. 第二条命令只告诉 GCC 为 gprof 命令建立剖析信息.
  
    当你不用任何选项编译一个程序时, GCC 将会建立(假定编译成功)一个名为 a.out 的可执行文件. 例如, 下面的命令将在当前目录下产生一个叫 a.out 的文件:
gcc test.c
你能用 -o 编译选项来为将产生的可执行文件指定一个文件名来代替 a.out. 例如, 将一个叫 count.c 的 C 程序编译为名叫 count 的可执行文件, 你将输入下面的命令:
gcc -o count count.c

--------------------------------------------------------------------------------
注意: 当你使用 -o 选项时, -o 后面必须跟一个文件名.  
--------------------------------------------------------------------------------

GCC 同样有指定编译器处理多少的编译选项. -c 选项告诉 GCC 仅把源代码编译为目标代码而跳过汇编和连接的步骤. 这个选项使用的非常频繁因为它使得编译多个 C 程序时速度更快并且更易于管理. 缺省时 GCC 建立的目标代码文件有一个 .o 的扩展名.
    -S 编译选项告诉 GCC 在为 C 代码产生了汇编语言文件后停止编译. GCC 产生的汇编语言文件的缺省扩展名是 .s . -E 选项指示编译器仅对输入文件进行预处理. 当这个选项被使用时, 预处理器的输出被送到标准输出而不是储存在文件里.

优 化 选 项
当你用 GCC 编译 C 代码时, 它会试着用最少的时间完成编译并且使编译后的代码易于调试. 易于调试意味着编译后的代码与源代码有同样的执行次序, 编译后的代码没有经过优化. 有很多选项可用于告诉 GCC 在耗费更多编译时间和牺牲易调试性的基础上产生更小更快的可执行文件. 这些选项中最典型的是-O 和 -O2 选项.
    -O 选项告诉 GCC 对源代码进行基本优化. 这些优化在大多数情况下都会使程序执行的更快. -O2 选项告诉 GCC 产生尽可能小和尽可能快的代码. -O2 选项将使编译的速度比使用 -O 时慢. 但通常产生的代码执行速度会更快.

    除了 -O 和 -O2 优化选项外, 还有一些低级选项用于产生更快的代码. 这些选项非常的特殊, 而且最好只有当你完全理解这些选项将会对编译后的代码产生什么样的效果时再去使用. 这些选项的详细描述, 请参考 GCC 的指南页, 在命令行上键入 man gcc .

调试和剖析选项
GCC 支持数种调试和剖析选项. 在这些选项里你会最常用到的是 -g 和 -pg 选项.
    -g 选项告诉 GCC 产生能被 GNU 调试器使用的调试信息以便调试你的程序. GCC 提供了一个很多其他 C 编译器里没有的特性, 在 GCC 里你能使 -g 和 -O (产生优化代码)联用. 这一点非常有用因为你能在与最终产品尽可能相近的情况下调试你的代码. 在你同时使用这两个选项时你必须清楚你所写的某些代码已经在优化时被 GCC 作了改动. 关于调试 C 程序的更多信息请看下一节"用 gdb 调试 C 程序"  .
    -pg 选项告诉 GCC 在你的程序里加入额外的代码, 执行时, 产生 gprof 用的剖析信息以显示你的程序的耗时情况. 关于 gprof 的更多信息请参考 "gprof" 一节.
  
用 gdb 调试 GCC 程序
Linux 包含了一个叫 gdb 的 GNU 调试程序. gdb 是一个用来调试 C 和 C++ 程序的强力调试器. 它使你能在程序运行时观察程序的内部结构和内存的使用情况. 以下是 gdb 所提供的一些功能:
它使你能监视你程序中变量的值.
它使你能设置断点以使程序在指定的代码行上停止执行.
它使你能一行行的执行你的代码.
  
在命令行上键入 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.

GDB 4.14 (i486-slakware-linux), Copyright 1995 Free Software Foundation, Inc.

(gdb)
当你启动 gdb 后, 你能在命令行上指定很多的选项. 你也可以以下面的方式来运行 gdb :
gdb <fname>;
当你用这种方式运行 gdb , 你能直接指定想要调试的程序. 这将告诉gdb 装入名为 fname 的可执行文件. 你也可以用 gdb 去检查一个因程序异常终止而产生的 core 文件, 或者与一个正在运行的程序相连. 你可以参考 gdb 指南页或在命令行上键入 gdb -h 得到一个有关这些选项的说明的简单列表.
  
为调试编译代码(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 会列出所有匹配的命令. 你也能用光标键上下翻动历史命令.

gdb 应用举例
本节用一个实例教你一步步的用 gdb 调试程序. 被调试的程序相当的简单, 但它展示了 gdb 的典型应用.
  
    下面列出了将被调试的程序. 这个程序被称为 greeting , 它显示一个简单的问候, 再用反序将它列出.
#include  <stdio.h>;



main ()

{

  char my_string[] = "hello there";



  my_print (my_string);

  my_print2 (my_string);

}



void my_print (char *string)

{

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

}



void my_print2 (char *string)

{

  char *string2;

  int size, i;



  size = strlen (string);

  string2 = (char *) malloc (size + 1);

  for (i = 0; i < size; i++)

    string2[size - i] = string;

  string2[size+1] = `\0';

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

}
用下面的命令编译它:
  
gcc -o test test.c
这个程序执行时显示如下结果:
The string is hello there

The string printed backward is
输出的第一行是正确的, 但第二行打印出的东西并不是我们所期望的. 我们所设想的输出应该是:
The string printed backward is ereht olleh
由于某些原因, my_print2 函数没有正常工作. 让我们用  gdb 看看问题究竟出在哪儿, 先键入如下命令:
  
gdb greeting

--------------------------------------------------------------------------------
注意: 记得在编译 greeting 程序时把调试选项打开.  
--------------------------------------------------------------------------------

如果你在输入命令时忘了把要调试的程序作为参数传给 gdb , 你可以在 gdb 提示符下用 file 命令来载入它:
  
(gdb) file greeting
这个命令将载入 greeting 可执行文件就象你在 gdb 命令行里装入它一样.
    这时你能用 gdb 的 run 命令来运行 greeting 了. 当它在 gdb 里被运行后结果大约会象这样:

(gdb) run

Starting program: /root/greeting

The string is hello there

The string printed backward is

Program exited with code 041
这个输出和在 gdb 外面运行的结果一样. 问题是, 为什么反序打印没有工作? 为了找出症结所在, 我们可以在 my_print2 函数的 for 语句后设一个断点, 具体的做法是在 gdb 提示符下键入 list 命令三次, 列出源代码:
(gdb) list

(gdb) list

(gdb) list

--------------------------------------------------------------------------------
技巧:  在 gdb 提示符下按回车健将重复上一个命令.  
--------------------------------------------------------------------------------

第一次键入 list 命令的输出如下:
  
1       #include  <stdio.h>;

2

3       main ()

4       {

5         char my_string[] = "hello there";

6

7         my_print (my_string);

8         my_print2 (my_string);

9       }

10
如果按下回车, gdb 将再执行一次 list 命令, 给出下列输出:
  
11      my_print (char *string)

12      {

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

14      }

15

16      my_print2 (char *string)

17      {

18        char *string2;

19        int size, i;

20
再按一次回车将列出 greeting 程序的剩余部分:
21        size = strlen (string);

22        string2 = (char *) malloc (size + 1);

23        for (i = 0; i < size; i++)

24          string2[size - i] = string;

25        string2[size+1] = `\0';

26        printf ("The string printed backward is %s\n", string2);

27      }
根据列出的源程序, 你能看到要设断点的地方在第24行, 在 gdb 命令行提示符下键入如下命令设置断点:
(gdb) break 24
    gdb 将作出如下的响应:
Breakpoint 1 at 0x139: file greeting.c, line 24

(gdb)

    现在再键入 run 命令, 将产生如下的输出:
  
Starting program: /root/greeting

The string is hello there



Breakpoint 1, my_print2 (string = 0xbfffdc4 "hello there" at greeting.c :24

24  string2[size-i]=string
你能通过设置一个观察 string2[size - i] 变量的值的观察点来看出错误是怎样产生的, 做法是键入:
  
(gdb) watch string2[size - i]
    gdb 将作出如下回应:
Watchpoint 2: string2[size - i]
现在可以用 next 命令来一步步的执行 for 循环了:
  
(gdb) next
经过第一次循环后,  gdb 告诉我们 string2[size - i] 的值是 `h`. gdb 用如下的显示来告诉你这个信息:
  
Watchpoint 2, string2[size - i]

Old value = 0 `\000'

New value = 104 `h'

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

23 for (i=0; i<size; i++)
这个值正是期望的. 后来的数次循环的结果都是正确的. 当 i=10 时, 表达式 string2[size - i] 的值等于 `e`,  size - i 的值等于 1, 最后一个字符已经拷到新串里了.
    如果你再把循环执行下去, 你会看到已经没有值分配给 string2[0] 了,  而它是新串的第一个字符, 因为 malloc 函数在分配内存时把它们初始化为空(null)字符. 所以 string2 的第一个字符是空字符. 这解释了为什么在打印 string2 时没有任何输出了.

    现在找出了问题出在哪里, 修正这个错误是很容易的. 你得把代码里写入 string2 的第一个字符的的偏移量改为 size - 1 而不是 size. 这是因为 string2 的大小为 12, 但起始偏移量是 0, 串内的字符从偏移量 0 到 偏移量 10, 偏移量 11 为空字符保留.

    为了使代码正常工作有很多种修改办法. 一种是另设一个比串的实际大小小 1 的变量. 这是这种解决办法的代码:

#include  <stdio.h>;



main ()


{

  char my_string[] = "hello there";



  my_print (my_string);

  my_print2 (my_string);

}



my_print (char *string)

{

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

}



my_print2 (char *string)

{

  char *string2;

  int size, size2, i;



  size = strlen (string);

  size2 = size -1;

  string2 = (char *) malloc (size + 1);

  for (i = 0; i < size; i++)

    string2[size2 - i] = string;

  string2[size] = `\0';

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

}
另外的 C 编程工具
Slackware Linux 的发行版中还包括一些我们尚未提到的 C 开发工具. 本节将介绍这些工具和它们的典型用法.
xxgdb
    xxgdb 是 gdb 的一个基于 X Window 系统的图形界面.  xxgdb 包括了命令行版的 gdb 上的所有特性.  xxgdb 使你能通过按按钮来执行常用的命令. 设置了断点的地方也用图形来显示.
  
    你能在一个 Xterm 窗口里键入下面的命令来运行它:
xxgdb
你能用 gdb 里任何有效的命令行选项来初始化 xxgdb . 此外 xxgdb 也有一些特有的命令行选项, 表 27.2 列出了这些选项.
  
表 27.2.  xxgdb 命令行选项.
  
  
选  项 描  述
db_name 指定所用调试器的名字, 缺省是 gdb.
db_prompt 指定调试器提示符, 缺省为 gdb.
gdbinit 指定初始化 gdb 的命令文件的文件名, 缺省为 .gdbinit.   
nx 告诉 xxgdb 不执行 .gdbinit 文件.
bigicon 使用大图标.


  
  
calls
     你可以在 sunsite.unc.edu FTP 站点用下面的路径:
/pub/Linux/devel/lang/c/calls.tar.Z

    来取得 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 程序和它的指南页安装载你的系统上.  
--------------------------------------------------------------------------------

当 calls 打印出调用跟踪结果时, 它在函数后面用中括号给出了函数所在文件的文件名:
main [test.c]
如果函数并不是向 calls 给出的文件里的,  calls 不知道所调用的函数来自哪里, 则只显示函数的名字:
printf
    calls 不对递归和静态函数输出. 递归函数显示成下面的样子:
fact <<< recursive in factorial.c >;>;>;
静态函数象这样显示:
total [static in calculate.c]
作为一个例子, 假设用 calls 处理下面的程序:
  
#include <stdio.h>;



main ()

{

char my_string[] = "hello there";

my_print (my_string);

my_print2(my_string);

}



my_print (char *string)

{

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

}



my_print2 (char *string)

{

  char *string2;

  int size, size2, i;



  size = strlen (string);

  size2 = size -1;

  string2 = (char *) malloc (size + 1);

  for (i = 0; i < size; i++)

    string2[size2 - i] = string;

  string2[size] = `\0';

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

}
将产生如下的输出:
    1 main [test.c]

    2       my_print [test.c]

    3             printf

    4       my_print2 [test.c]

    5             strlen

    6             malloc

    7             printf
calls 有很多命令行选项来设置不同的输出格式, 有关这些选项的更多信息请参考 calls 的指南页. 方法是在命令行上键入 calls -h .
  
  
cproto
    cproto 读入 C 源程序文件并自动为每个函数产生原型申明. 用 cproto 可以在写程序时为你节省大量用来定义函数原型的时间.
    如果你让 cproto 处理下面的代码:
#include  <stdio.h>;



main ()

{

  char my_string[] = "hello there";

  my_print (my_string);

  my_print2(my_string);

}



my_print (char *string)

{

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

}



my_print2 (char *string)

{

  char *string2;

  int size, size2, i;



  size = strlen (string);

  size2 = size -1;

  string2 = (char *) malloc (size + 1);

  for (i = 0; i < size; i++)

    string2[size2 - i] = string;

  string2[size] = `\0';

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

}
你将得到下面的输出:
/* test.c */

int main(void);

int my_print(char *string);

int my_print2(char *string);
这个输出可以重定向到一个定义函数原型的包含文件里.
indent
    indent 实用程序是 Linux 里包含的另一个编程实用工具. 这个工具简单的说就为你的代码产生美观的缩进的格式. indent 也有很多选项来指定如何格式化你的源代码.这些选项的更多信息请看indent 的指南页, 在命令行上键入 indent -h .
  
    下面的例子是 indent 的缺省输出:

    运行 indent 以前的 C 代码:

#include  <stdio.h>;



main () {

      char my_string[] = "hello there";

  my_print (my_string);

     my_print2(my_string); }



my_print (char *string)

{

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

}



my_print2           (char *string) {

    char *string2;

      int size, size2, i;



      size = strlen (string);

      size2 = size -1;

      string2 = (char *) malloc (size + 1);

  for (i = 0; i < size; i++)

            string2[size2 - i] = string;

      string2[size] = `\0';


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

}
运行 indent 后的 C 代码:
#include  <stdio.h>;



main ()

{

  char my_string[] = "hello there";

  my_print (my_string);

  my_print2 (my_string);

}



my_print (char *string)

{

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

}



my_print2 (char *string)

{

  char *string2;

  int size, size2, i;



  size = strlen (string);

  size2 = size -1;

  string2 = (char *) malloc (size + 1);

  for (i = 0; i < size; i++)

    string2[size2 - i] = string;

  string2[size] = `\0';

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

}
     indent 并不改变代码的实质内容, 而只是改变代码的外观. 使它变得更可读, 这永远是一件好事.
gprof
    gprof 是安装在你的 Linux 系统的 /usr/bin 目录下的一个程序. 它使你能剖析你的程序从而知道程序的哪一个部分在执行时最费时间.
    gprof 将告诉你程序里每个函数被调用的次数和每个函数执行时所占时间的百分比. 你如果想提高你的程序性能的话这些信息非常有用.

    为了在你的程序上使用 gprof, 你必须在编译程序时加上 -pg 选项. 这将使程序在每次执行时产生一个叫 gmon.out 的文件. gprof 用这个文件产生剖析信息.

    在你运行了你的程序并产生了 gmon.out 文件后你能用下面的命令获得剖析信息:

gprof <program_name>;
参数 program_name 是产生 gmon.out 文件的程序的名字.

--------------------------------------------------------------------------------
技巧: gprof 产生的剖析数据很大, 如果你想检查这些数据的话最好把输出重定向到一个文件里.  
--------------------------------------------------------------------------------

f2c 和 p2c
    f2c 和 p2c 是两个源代码转换程序. f2c 把 FORTRAN 代码转换为 C 代码, p2c 把 Pascal 代码转换为 C 代码. 当你安装 GCC 时这两个程序都会被安装上去.
    如果你有一些用 FORTRAN 或 Pascal 写的代码要用 C 重写的话, f2c 和 p2c 对你非常有用. 这两个程序产生的 C 代码一般不用修改就直接能被 GCC 编译.

    如果要转换的 FORTRAN 或 Pascal 程序比较小的话可以直接使用 f2c 或 p2c 不用加任何选项. 如果要转换的程序比较庞大, 包含很多文件的话你可能要用到一些命令行选项.

    在一个 FORTRAN 程序上使用 f2c , 输入下面的命令:

f2c my_fortranprog.f

--------------------------------------------------------------------------------
注意: f2c 要求被转换的程序的扩展名为 .f 或 a .F .  
--------------------------------------------------------------------------------

要把一个Pascal 程序装换为 C 程序, 输入下面的命令:
p2c my_pascalprogram.pas
这两个程序产生的 C 源代码的文件名都和原来的文件名相同, 但扩展名由 .f 或 .pas 变为 .c.

22.

1. gcc/g++在执行编译工作的时候，总共需要4步

(1).预处理,生成.i的文件[预处理器cpp] 
(2).将预处理后的文件不转换成汇编语言,生成文件.s[编译器egcs] 
(3).有汇编变为目标代码(机器代码)生成.o的文件[汇编器as] 
(4).连接目标代码,生成可执行程序[链接器ld]

[参数详解]
-x language filename
　   设定文件所使用的语言,使后缀名无效,对以后的多个有效.也就是根据约定C语言的后缀名称是.c的，而C++的后缀名是.C或者.cpp,如果你很个性，决定你的C代码文件的后缀名是.pig 哈哈，那你就要用这参数,这个参数对他后面的文件名都起作用，除非到了下一个参数的使用。可以使用的参数吗有下面的这些 :
　　　　 `c', `objective-c', `c-header', `c++', `cpp-output',
　　　　 `assembler', and `assembler-with-cpp'.
　　 看到英文，应该可以理解的。例子用法: gcc -x c hello.pig 
-x none filename 
　　关掉上一个选项，也就是让gcc根据文件名后缀，自动识别文件类型. 例子用法: gcc -x c hello.pig -x none hello2.c 
-c 
　　只激活预处理,编译,和汇编,也就是他只把程序做成obj文件.例子用法: gcc -c hello.c (他将生成.o的obj文件)

-S
　　只激活预处理和编译，就是指把文件编译成为汇编代码。例子用法: gcc -S hello.c (他将生成.s的汇编代码，你可以用文本编辑器察看 )

-E
　　只激活预处理,这个不生成文件,你需要把它重定向到一个输出文件里面.例子用法: gcc -E hello.c > pianoapan.txt 
　　gcc -E hello.c | more (慢慢看吧,一个hello word 也要与处理成800行的代码 )

-o
　　制定目标名称,缺省的时候,gcc 编译出来的文件是a.out,很难听,如果你和我有同感，改掉它,哈哈 .例子用法 :
　　gcc -o hello.exe hello.c (哦,windows用习惯了)
　　gcc -o hello.asm -S hello.c

-pipe
　　使用管道代替编译中临时文件,在使用非gnu汇编工具的时候,可能有些问题.　例子用法 :gcc -pipe -o hello.exe hello.c

-ansi
　　关闭gnu c中与ansi c不兼容的特性,激活ansi c的专有特性(包括禁止一些asm inline typeof关键字,以及UNIX,vax等预处理宏.)

-fno-asm
　　此选项实现ansi选项的功能的一部分，它禁止将asm,inline和typeof用作关键字。　　　　 
-fno-strict-prototype
　　只对g++起作用,使用这个选项,g++将对不带参数的函数,都认为是没有显式的对参数的个数和类型说明,而不是没有参数. 
　　而gcc无论是否使用这个参数,都将对没有带参数的函数,认为城没有显式说明的类型 
-fthis-is-varialble 
　　就是向传统c++看齐,可以使用this当一般变量使用.
-fcond-mismatch 
　　允许条件表达式的第二和第三参数类型不匹配,表达式的值将为void类型
-funsigned-char 
-fno-signed-char
-fsigned-char
-fno-unsigned-char
   　这四个参数是对char类型进行设置,决定将char类型设置成unsigned char(前两个参数)或者 signed char(后两个参数) 
-include file 
　　包含某个代码,简单来说,就是便以某个文件,需要另一个文件的时候,就可以用它设定,功能就相当于在代码中使用#include<filename> 
　　例子用法: gcc hello.c -include /root/pianopan.h 
-imacros file 
　　将file文件的宏,扩展到gcc/g++的输入文件,宏定义本身并不出现在输入文件中-Dmacro .相当于C语言中的#define macro 
-Dmacro=defn 
　　相当于C语言中的#define macro=defn
-Umacro 
　　相当于C语言中的#undef macro

-undef
　　取消对任何非标准宏的定义
-Idir 
　　在你是用#include"file"的时候,gcc/g++会先在当前目录查找你所制定的头文件,如果没有找到,他回到缺省的头文件目录找,如果使用-I制定了目录,他回先在你所制定的目录查找,然后再按常规的顺序去找. 对于#include<file>,gcc/g++会到-I制定的目录查找,查找不到,然后将到系统的缺省的头文件目录查找 .
-I- 
　　就是取消前一个参数的功能,所以一般在-Idir之后使用  
-idirafter dir
　　在-I的目录里面查找失败,讲到这个目录里面查找.　 
-iprefix prefix
-iwithprefix dir
　　一般一起使用,当-I的目录查找失败,会到prefix+dir下查找　　 
-nostdinc
　　使编译器不再系统缺省的头文件目录里面找头文件,一般和-I联合使用,明确限定头文件的位置　 
-nostdin C++
　　规定不在g++指定的标准路经中搜索,但仍在其他路径中搜索,.此选项在创建libg++库使用　　 
-C
　　在预处理的时候,不删除注释信息,一般和-E使用,有时候分析程序，用这个很方便的.
-M
　　生成文件关联的信息。包含目标文件所依赖的所有源代码.你可以用gcc -M hello.c来测试一下，很简单。 　 
-MM
　　和上面的那个一样，但是它将忽略由#include<file>造成的依赖关系。  
-MD
　　和-M相同，但是输出将导入到.d的文件里面  
-MMD
　　和-MM相同，但是输出将导入到.d的文件里面  
-Wa,option
　　此选项传递option给汇编程序;如果option中间有逗号,就将option分成多个选项,然后传递给会汇编程序  
-Wl.option
　　此选项传递option给连接程序;如果option中间有逗号,就将option分成多个选项,然后传递给会连接程序.

-llibrary
　　制定编译的时候使用的库.例子用法 : gcc -lcurses hello.c (使用ncurses库编译程序 )
-Ldir
　　制定编译的时候，搜索库的路径。比如你自己的库，可以用它制定目录，不然编译器将只在标准库的目录找。这个dir就是目录的名称。  
-O0
-O1
-O2
-O3
　　编译器的优化选项的4个级别，-O0表示没有优化,-O1为缺省值，-O3优化级别最高　　  
-g
　　只是编译器，在编译的时候，产生条是信息。  
-gstabs
　　此选项以stabs格式声称调试信息,但是不包括gdb调试信息.  
-gstabs+
　　此选项以stabs格式声称调试信息,并且包含仅供gdb使用的额外调试信息.  
-ggdb
　　此选项将尽可能的生成gdb的可以使用的调试信息.
-static
　　此选项将禁止使用动态库，所以，编译出来的东西，一般都很大，也不需要什么动态连接库，就可以运行. 
-share
　　此选项将尽量使用动态库，所以生成文件比较小，但是需要系统由动态库.
-traditional
　　试图让编译器支持传统的C语言特性

2. 源文件为main.c, x.c, y.c, z.c,头文件为x.h,y.h,z.h, 如何编译成.so动态库？

# 声称动代连接库，假设名称为libtest.so
gcc x.c y.c z.c -fPIC -shared -o libtest.so

# 将main.c和动态连接库进行连接生成可执行文件
gcc main.c -L. -ltest -o main

# 输出LD_LIBRARY_PATH环境变量，一边动态库装载器能够找到需要的动态库
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:.

# 测试是否动态连接，如果列出libtest.so，那么应该是连接正常了
ldd main

说明：

(1) -fPIC：表示编译为位置独立的代码，不用此选项的话编译后的代码是位置相关的所以动态载入时是通过代码拷贝的方式来满足不同进程的需要，而不能达到真正代码段共享的目的。

(2) -L.：表示要连接的库在当前目录中

(3) -ltest：编译器查找动态连接库时有隐含的命名规则，即在给出的名字前面加上lib，后面加上.so来确定库的名称

(4) LD_LIBRARY_PATH：这个环境变量指示动态连接器可以装载动态库的路径。
    当然如果有root权限的话，可以修改/etc/ld.so.conf文件，然后调用/sbin/ldconfig来达到同样的目的，不过如果没有root权限，那么只能采用输出LD_LIBRARY_PATH的方法了。

3. Linux下如何用GCC编译动态库

本文主要解决以下几个问题

1) 为什么要使用库？

2) 库的分类

3) 创建自己的库

    或许大家对自己初学 Linux时的情形仍记忆尤新吧。如果没有一个能较好的解决依赖关系的包管理器，在Linux下安装软件将是一件及其痛苦的工作。你装a包时，可能会提示你要先装b包，当你费尽心力找到b包时，可能又会提示你要先安装c包。我就曾被这样的事搞的焦头烂额，至今一提起rpm仍心有余悸，头皮发麻。说是一朝被蛇咬，十年怕井绳怕也不为过。

    Linux下之所以有这许多的依赖关系，其中一个开发原则真是功不可没。这个原则就是：尽量不重复做别人已经做过的事。换句话说就是尽量充分利用别人的劳动成果。

这就涉及到如何有效的进行代码复用。

(1) 为什么要使用库？

    关于代码复用的途径，一般有两种。这是最没有技术含量的一种方案。如果代码小，则工作量还可以忍受，如果代码很庞大，则此法不可取。即便有人原意这样做，但谁又能保证所有的代码都可得到呢？而库的出现很好的解决了这个问题。库，是一种封装机制，简单说把所有的源代码编译成目标代码后打成的包。那么用户怎么能知道这个库提供什么样的接口呢？难道要用nm等工具逐个扫描？不用担心，库的开发者早以把一切都做好了。除了包含目标代码的库外，www.Linuxidc.com一般还会提供一系列的头文件，头文件中就包含了库的接口。为了让方便用户，再加上一个使用说明就差不多完美了。

(2) 库的分类

(2.1) 库的分类

    根据链接时期的不同，库又有静态库和动态库之分。静态库是在链接阶段被链接的（好像是废话，但事实就是这样），所以生成的可执行文件就不受库的影响了，即使库被删除了，程序依然可以成功运行。有别于静态库，动态库的链接是在程序执行的时候被链接的。所以，即使程序编译完，库仍须保留在系统上，以供程序运行时调用。（TODO：链接动态库时链接阶段到底做了什么）

(2.2) 静态库和动态库的比较

    链接静态库其实从某种意义上来说也是一种粘贴复制，只不过它操作的对象是目标代码而不是源码而已。因为静态库被链接后库就直接嵌入可执行文件中了，这样就带来了两个问题。首先就是系统空间被浪费了。这是显而易见的，想象一下，如果多个程序链接了同一个库，则每一个生成的可执行文件就都会有一个库的副本，必然会浪费系统空间。再者，人非圣贤，即使是精心调试的库，也难免会有错。一旦发现了库中有bug，挽救起来就比较麻烦了。必须一一把链接该库的程序找出来，然后重新编译。而动态库的出现正弥补了静态库的以上弊端。因为动态库是在程序运行时被链接的，所以磁盘上只须保留一份副本，因此节约了磁盘空间。如果发现了bug或要升级也很简单，只要用新的库把原来的替换掉就行了。那么，是不是静态库就一无是处了呢？答曰：非也非也。不是有句话么：存在即是合理。静态库既然没有湮没在滔滔的历史长河中，就必然有它的用武之地。想象一下这样的情况：如果你用libpcap库编了一个程序，要给被人运行，而他的系统上没有装pcap库，该怎么解决呢？最简单的办法就是编译该程序时把所有要链接的库都链接它们的静态库，这样，就可以在别人的系统上直接运行该程序了。

    所谓有得必有失，正因为动态库在程序运行时被链接，故程序的运行速度和链接静态库的版本相比必然会打折扣。然而瑕不掩瑜，动态库的不足相对于它带来的好处在现今硬件下简直是微不足道的，所以链接程序在链接时一般是优先链接动态库的，除非用-static参数指定链接静态库。

(2.3) 如何判断一个程序有没有链接动态库? 答案是用file实用程序。

    file程序是用来判断文件类型的，在file命令下，所有文件都会原形毕露的。顺便说一个技巧。有时在 windows下用浏览器下载tar.gz或tar.bz2文件，后缀名会变成奇怪的tar.tar，到Linux有些新手就不知怎么解压了。但 Linux下的文件类型并不受文件后缀名的影响，所以我们可以先用命令file xxx.tar.tar看一下文件类型，然后用tar加适当的参数解压。

     另外，还可以借助程序ldd实用程序来判断。ldd是用来打印目标程序（由命令行参数指定）所链接的所有动态库的信息的，如果目标程序没有链接动态库，则打印“not a dynamic executable”，ldd的用法请参考manpage。

(3) 创建自己的库

(3.1) 创建动态库

    创建文件hello.c，内容如下：

#include

void hello(void)

{

printf("Hello World\n");

}

    用命令gcc -shared hello.c -o libhello.so编译为动态库。可以看到，当前目录下多了一个文件libhello.so。

[leo@leo test]$ file libhello.so

libhello.so: ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV), not stripped

    看到了吧，文件类型是shared object了。再编辑一个测试文件test.c，内容如下：

int main()

{

hello();

return 0;

}

    这下可以编译了：）

[leo@leo test]$ gcc test.c

/tmp/ccm7w6Mn.o: In function `main':

test.c:(.text+0x1d): undefined reference to `hello'

collect2: ld returned 1 exit status

    链接时gcc找不到hello函数，编译失败:(。原因是hello在我们自己创建的库中，如果gcc能找到那才教见鬼呢！ok，再接再厉。

[leo@leo test]$ gcc test.c -lhello

/usr/lib/gcc/i686-pc-Linux-gnu/4.0.0/http://www.cnblogs.com/http://www.cnblogs.com/i686-pc-Linux-gnu/bin/ld: cannot find -lhello

collect2: ld returned 1 exit status

[leo@leo test]$ gcc test.c -lhello -L.

[leo@leo test]$

    第一次编译直接编译，gcc默认会链接标准c库，但符号名hello解析不出来，故连接阶段通不过了。现在用gcc test.c -lhello -L.已经编译成功了，默认输出为a.out。现在来试着运行一下：

[leo@leo test]$ ./a.out

./a.out: error while loading shared libraries: libhello.so: cannot open shared object file: No such file or directory

咦，怎么回事？原来虽然链接时链接器（dynamic linker）找到了动态库libhello.so，但动态加载器(dynamic loader， 一般是/lib/ld-Linux.so.2)却没找到。再来看看ldd的输出：

[leo@leo test]$ ldd a.out

Linux-gate.so.1 => (0xffffe000)

libhello.so => not found

libc.so.6 => /lib/libc.so.6 (0x40034000)

/lib/ld-Linux.so.2 (0x40000000)

    果然如此，看到没有，libhello.so => not found。Linux为我们提供了两种解决方法：

1).可以把当前路径加入 /etc/ld.so.conf中然后运行ldconfig，或者以当前路径为参数运行ldconfig（要有root权限才行）。

2).把当前路径加入环境变量LD_LIBRARY_PATH中

    当然，如果你觉得不会引起混乱的话，可以直接把该库拷入/lib,/usr/lib/等位置（无可避免，这样做也要有权限），这样链接器和加载器就都可以准确的找到该库了。我们采用第二种方法：

[leo@leo test]$ export LD_LIBRARY_PATH=.:$LD_LIBRARY_PATH

 [leo@leo test]$ ldd a.out

Linux-gate.so.1 => (0xffffe000)

libhello.so => ./libhello.so (0x4001f000)

libc.so.6 => /lib/libc.so.6 (0x40036000)

/lib/ld-Linux.so.2 (0x40000000)

    哈哈，这下ld-Linux.so.2就可以找到libhello.so这个库了。现在可以直接运行了：

[leo@leo test]$ ./a.out

Hello World

(3.2) 创建静态库

    仍使用刚才的hello.c和test.c。第一步，生成目标文件。

[leo@leo test]$ gcc -c hello.c

[leo@leo test]$ ls hello.o -l

-rw-r--r-- 1 leo users 840 5月 6 12:48 hello.o

    第二步,把目标文件归档。

[leo@leo test]$ ar r libhello.a hello.o

ar: creating libhello.a

OK,libhello.a就是我们所创建的静态库了，简单吧:)

[leo@leo test]$ file libhello.a

libhello.a: current ar archive

    下面一行命令就是教你如何在程序中链接静态库的：

[leo@leo test]$ gcc test.c -lhello -L. -static -o hello.static

    我们来用file命令比较一下用动态库和静态库链接的程序的区别：

[leo@leo test]$ gcc test.c -lhello -L. -o hello.dynamic

    正如前面所说，链接器默认会链接动态库（这里是libhello.so），所以只要把上个命令中的 -static参数去掉就可以了。用file实用程序验证一下是否按我们的要求生成了可执行文件：

[leo@leo test]$ file hello.static hello.dynamic

hello.static: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), for GNU/Linux 2.6.6, statically linked, not stripped

hello.dynamic: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), for GNU/Linux 2.6.6, dynamically linked (uses shared libs), not stripped

    不妨顺便练习一下ldd的用法：

[leo@leo test]$ ldd hello.static hello.dynamic

hello.static:

not a dynamic executable

hello.dynamic:

Linux-gate.so.1 => (0xffffe000)

libhello.so => ./libhello.so (0x4001f000)

libc.so.6 => /lib/libc.so.6 (0x40034000)

/lib/ld-Linux.so.2 (0x40000000)

    OK，看来没有问题，那就比较一下大小先：

[leo@leo test]$ ls -l hello.[ds]*

-rwxr-xr-x 1 leo users 5911 5月 6 12:54 hello.dynamic

-rwxr-xr-x 1 leo users 628182 5月 6 12:54 hello.static

    看到区别了吧，链接静态库的目标程序和链接动态库的程序比起来简直就是一个庞然大物！这么小的程序，很难看出执行时间的差别，不过为了完整起见，还是看一下time的输出吧：

[leo@leo test]$ time ./hello.static

Hello World

real 0m0.001s

user 0m0.000s

sys 0m0.001s

[leo@leo test]$ time ./hello.dynamic

Hello World

real 0m0.001s

user 0m0.000s

sys 0m0.001s

    如果程序比较大的话，应该效果会很明显的。