相关文章推荐
爱跑步的花生  ·  VNG Careers·  5 月前    · 
狂野的荒野  ·  Client Challenge·  6 月前    · 
学习
实践
活动
专区
工具
TVP
写文章

如何使用gcc编译运行C程序?

  • 回答 ( 6 )
  • 关注 ( 0 )
  • 查看 ( 12762 )

对于初学c语言编程的来说,学会如何使用gcc编译器工具,对理解c语言的执行过程,加深对c语言的理解很重要,那么如何使用gcc编译运行C程序?

麻酱huo白糖 麻酱huo白糖 提问于
f1不如蜗牛 回答于

首先编写c代码,并输入以下如图代码,生成c文件hello.c

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

1、预编译(Preprocessing)命令:

会对各种预处理指令( #include、#define、#ifdef 等#开始的代码行 )进行处理,删除注释和多余的空白字符,生成一份新的代码。

gcc -o hello.i hello.c -E 或者 gcc -o hello.i -E hello.c 或者 gcc -E hello.c -o hello.i (注意:-o 作用是指定输出文件的名字,如果不加-o的话,则生成的文件名字总叫a.out。)

(即-o 参数:是对命令输出结果进行导入操作,这里是把 gcc -E hello.c 操作结果输出到文件hello.i(命名可以自定义)中进行保存。)

预编译hello.c,预编译之后得到的文件的名字叫hello.i。

(注意:编译后的名字可以随意起,但是呢我们知道预编译后的文件还是文本的.c文件,所以为了好区分起名字为 xxx.c,这里我们为了显示整个过程,预编译后的文件名我们起为xxx.i。)

在c语言中#开头的语句又叫预编译指令。例如:#include <stdio.h>

预编译的功能之一: 会把include包含的头文件内容做一个简单的替换,即替换到.c文件里面去。 ...... //此处省略1万行 ...... 预编译的功能之二: 会把代码中的注释去掉。

----------------------------------------------------------------------------- 2、编译(Compilation)的命令:

对代码进行语法、语义分析和错误判断,生成汇编代码文件。

gcc -o hello.s hello.i -S 或者 gcc -o hello.s -S hello.i 或者 gcc -S hello.i -o hello.s

(-S 参数:是gcc对目标文件进行编译,这里针对的是文件hello.i文件。)

通过这一步我们知道 C语言跟汇编的 关系,至于他们之前是如何进行转换的,大家可以进行更深入的学习与探讨。

此时目录下多了一个hello.s文件,内容如下图所示:

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

3、汇编(Assembly)的命令:

把汇编代码转换成计算机可认识的二进制文件,即把文本的c语言编译为二进制指令。要知道计算机只认识0和1呢!

gcc -o hello.o hello.s -c 或者 gcc -o hello.o -c hello.s 或者 gcc -c hello.s -o hello.o

(-c 参数:是gcc对目标文件执行指令转换的操作。)

此步骤我们得到文件hello.o文件。

大家也同样打开文件(cat hello.o)查看一下,这个文件里面几乎没几个字符大家能看懂,这就对了,但大家可以通过这种方法将其转化为我们可读的形式:

root@iZ2zeeailqvwws5dcuivdbZ:~/2/01# readelf -a hello.o

----------------------------------------------------------------------------- 4、链接(Linking/Build)的命令:

通俗的讲就是把多个*.o文件合并成一个可执行文件,即二进制指令文件。

gcc -o hello hello.o  或者 gcc hello.o -o hello(注意:gcc没有单独的链接参数)

将系统库函数与hello.o进行链接(简言之合并),得到可执行的程序,该程序的名字叫hello。

root@iZ2zeeailqvwws5dcuivdbZ:~/2/01# gcc -o hello hello.o

这里我们就得到了一个可以直接在系统下执行的文件 hello。

我们也可以对这个文件进行readelf操作,也可以进行 二进制指令转汇编 的操作,如下图所示:

root@iZ2zeeailqvwws5dcuivdbZ:~/2/01# objdump -d hello

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

5、程序运行

我们想知道在linux系统下到底链接来了什么库来呢?(即可执行程序需要用到什么库呢?) 使用命令 ldd hello 查看。

小川 医学生 回答于
  1. 预编译:

gcc -E -o a.e a.c

预编译a.c文件,生成的目标文件名为a.e

预编译就是将include包含的头文件内容替换到C文件中,同时删除代码中没用的注释

示例:

//main.c

#include <stdio.h>

#include "sum.h"

int main(){

int m = 6;

int n = 5;

int result = sum(m,n); printf("hello\n%\n",result);

//sum.h

int sum(int x,int y);

运行之后结果为:

第一步就是这样的啦!

2 . 编译

gcc -S -o a.s a.e

将a.e翻译成一个ASCII汇编语言文件a.s.

3 .链接

gcc -o a a.s

这行命令告诉gcc对源程序a.o进行链接,生成可执行程序a

gcc 没有任何参数,表示就是链接

GCC编译器的基本选项如下表:

类型

说明

-E

预处理后即停止,不进行编译、汇编及连接

-S

编译后即停止,不进行汇编及连接

-c

编译或汇编源文件,但不进行连接

-o file

指定输出文件file

C语言的include头文件

  1. include是要告诉编译器,包含头文件
  2. 在C语言中,任何的库函数调用都需要包含头文件
  3. 头文件也相当于一个文档声明
  4. 如果把main函数放在第一个文件中,而把自定义函数放在第二个文件中,那么就需要在第一个文件中声明函数原型
  5. 如果把函数原型包含在一个头文件中,那么就不用每次使用函数的时候都声明其原型了,把函数声明放进头文件中是个好习惯!
  6. 头文件可以不需要编译
  7. 可以查看具体的声明
  8. 头文件加上实现文件的o文件提交给使用者即可,不需要知道源代码
  9. o文件预先编译,所以整个项目编译时,会大大提高编译的时间 。
  10. 当一个文件(A.c文件)依赖于头文件(b.h)时,如果b.c编译之后形成的b.o文件重新编译后,a.o的文件不需要重新编译
  11. 可以极大降低手工复制,粘贴的错误几率

头文件的注意事项:

  1. <头文件>,表示让C语言编译器在系统目录(即gcc编译器的include目录下)下寻找相关的头文件
  2. “头文件”,表示让C语言编译器在用户当前目录下寻找相关的头文件
  3. 如果是使用了C语言库函数的需要的头文件,那么一定是#include<>
  4. 如果是使用了用户自定义的头文件,那么一定是#include“”
Mr_zhang Learning without limit 回答于

Hello World!

#include <stdio.h>
int main()
     printf("Hello World!\n");
     return 0;
}

基本编译命令

$ gcc a.c
# 生成 a.out
$ ./a.out

多个文件分而治之

//声明
# include “max.c”
# 不声明,会发生警告信息
$ gcc max.c hello.c -o main.out
$ gcc hello.c

头文件与函数定义分离

不经常变动的函数 生成 静态库

$ gcc -c max.c -o max.o
# hello.c 声明去掉
$ gcc max.o hello.c
# 可以将文件写为 头文件
$ gcc max.o min.o hello.c

Makefile

# 注释
hello.out:max.o min.o hello.c
        gcc max.o min.o hello.c -o hello.out
max.o:max.c
        gcc -c max.c
min.o:min.c
        gcc -c min.c

指针与内存

gdb 工具

$ gcc -g main.c -o main.out
$ gdb ./main.out
墨莫末沫陌魔 回答于

示例代码

  • a.c
#include <stdio.h>
#include "head.h"
annotation one
annotation two
extern int N;
int main(){
    printf("build test N=%d\n",N);
    printStr("abc");
    getchar();
}
  • head.h
#ifndef HEAD_H
#define HEAD_H
int N=100;
void printStr(char *);
#endif
  • head.c
#include<stdio.h>
void printStr(char *str){
    printf("%s\n",str);
}

预处理

处理关于 “#” 的指令

  • 删除#define,展开所有宏定义。
  • 处理条件预编译 #if, #ifdef, #if, #elif,#endif
  • 处理“#include”预编译指令,将包含的“.h”文件插入对应位置。这可是递归进行的,文件内可能包含其他“.h”文件。
  • 删除所有注释。/**/,//。
  • 添加行号和文件标识符。用于显示调试信息:错误或警告的位置。
  • 保留#pragma编译器指令。(1)设定编译器状态,(2)指示编译器完成一些特定的动作。
  • 预处理命令 $ gcc -E a.c -o a.i
...省略部分代码
# 2 "a.c" 2
# 1 "head.h" 1
# 3 "head.h"
int N=100;
void printStr(char *);
# 3 "a.c" 2
 printStr("abc");
 getchar();
}

预编译结果解释 # linenum filename flags 分别对应行号、文件、标识。 flag对应的含义

  1. 文件的开始
  2. 文件的返回(在include另一个文件后)
  3. 代表接下来的文本来自系统头文件,所以某些警告应该禁止。
  4. 代表接下来的文本应该被当做包含一个隐式的 extern "C

编译

1.高级语言->汇编代码
  • 命令 gcc -S a.i -o a.s
    .file   "a.c"
    .globl  _N
    .data
    .align 4
    .long   100
    .def    ___main;    .scl    2;  .type   32; .endef
    .section .rdata,"dr"
    .ascii "build test N=%d\12\0"
    .ascii "abc\0"
    .text
    .globl  _main
    .def    _main;  .scl    2;  .type   32; .endef
_main:
LFB10:
    .cfi_startproc
    pushl   %ebp
    .cfi_def_cfa_offset 8
    .cfi_offset 5, -8
    movl    %esp, %ebp
    .cfi_def_cfa_register 5
    andl    $-16, %esp
    subl    $16, %esp
    call    ___main
    movl    _N, %eax
    movl    %eax, 4(%esp)
    movl    $LC0, (%esp)
    call    _printf
    movl    $LC1, (%esp)
    call    _printStr
    call    _getchar
    movl    $0, %eax
    leave
    .cfi_restore 5
    .cfi_def_cfa 4, 4
    .cfi_endproc
LFE10:
    .ident  "GCC: (GNU) 5.3.0"
    .def    _printf;    .scl    2;  .type   32; .endef
    .def    _printStr;  .scl    2;  .type   32; .endef
    .def    _getchar;   .scl    2;  .type   32; .endef
2.汇编代码->机器代码
  • 命令 gcc -c a.s -o a.o
  • 得到的结果是二进制文件。

链接

使用到了C标准库的东西“printf”,但是编译过程只是把源文件翻译成二进制而已,这个二进制还不能直接执行,这个时候就需要做一个动作,将翻译成的二进制与需要用到库绑定在一块。 函数库一般分为静态库和动态库两种

  1. 静态库是指编译链接时,把库文件的代码全部加入到可执行文件中,因此生成的文件比较大,但在运行时也就不再需要库文件了。其后缀名一般为”.a”。
  2. 动态库与之相反,在编译链接时并没有把库文件的代码加入到可执行文件中,而是在程序执行时由运行时链接文件加载库,这样可以节省系统的开销。动态库一般后缀名为”.so”,如前面所述的libc.so.6就是动态库。Gcc在编译时默认使用动态库。
  • 命令 gcc head.o a.o -o a.exe
  • 得到的a.exe可直接运行。
静态库链接时搜索路径顺序:
  1. ld会去找GCC命令中的参数-L
  2. 再找gcc的环境变量LIBRARY_PATH
  3. 再找内定目录 /lib /usr/lib /usr/local/lib 这是当初compile gcc时写在程序内的
动态链接时、执行时搜索路径顺序:
  1. 编译目标代码时指定的动态库搜索路径
  2. 环境变量LD_LIBRARY_PATH指定的动态库搜索路径
  3. 配置文件/etc/ld.so.conf中指定的动态库搜索路径
  4. 默认的动态库搜索路径/lib
  5. 默认的动态库搜索路径/usr/lib
有关环境变量:

LIBRARY_PATH环境变量:指定程序静态链接库文件搜索路径 LD_LIBRARY_PATH环境变量:指定程序动态链接库文件搜索路径

说下生成静态库的方法:  
    ar cr libxxx.a file1.o file2.o  
就是把file1.o和file2.o打包生成libxxx.a静态库  
使用的时候  
    gcc test.c -L/path -lxxx -o test  
动态库的话:  
    gcc -fPIC -shared file1.c -o libxxx.so  
也可以分成两部来写:  
    gcc -fPIC file1.c -c //这一步生成file1.o  
    gcc -shared file1.o -o libtest.so