重学c语言（一、c语言的编译链接）

c言语学习的路程也是比较坎坷的，想起当年大学的时分，上c言语课，是大一榜首学期，那时分比较懵懂，也完全不知道学习c言语是干啥，并且最初c言语课，不知道为啥老是安排在榜首第二节课，常常起不来，哎，惆怅，然后想起榜首次c言语上机，我已然连scanf和printf函数都不知道，捂脸。。。

后来大一下学期改变了，开端学习51单片机，51单片机用的也是c言语，不过用的都是比较根底的c，后来直到大四出来实习，才被冲击的遍体鳞伤，当年连结构体都不会用，跟不必说文件操作了，哎，再次惆怅。

经过这次，再次发奋图强，再次学习c言语，经过这次的发育，c言语的水平直线上升，指针，文件操作，更不在话下，可惜当年没有留下笔记。

直到最近，又想再次把之前的知识一致整理一下，才想起写一下c言语的专题，这个专题，不计划介绍c言语的语法，那些东西现在好多视频都有，并且我觉得自己也写的无聊，所以这次专门挑那些当年遗漏的，并且尽量深入去了解c，操作体系，这种层面，希望能坚持下来，加油。

1.1 久别的hello world

要说起c言语的榜首节，肯定会想起大名鼎鼎的hello world，这儿咱们榜首个c言语程序也是hello world，这时分让我想起一个笑话，说一个程序员退休之后，开端练习书法，然后写的榜首个书法便是hello world。当然调侃的意思比较多吧。

#include <stdio.h>
int main(int argc, char **argv)
{
    printf("hello world\n");
    return 0;
}

便是这么简短，这时分咱们写完了一个程序，那怎样在运转呢？

咱们知道计算机只能机器码，也便是二进制，咱们上面写的代码，跟二进制差别很大，所以咱们需求凭借编译器，c言语的话，就有c言语的编译器，咱们经过c言语的编译器，就能把上面的代码转化成机器码的，然后给cpu去执行。

这儿我挑选用ubuntu体系，由于linux体系能够玩的许多，一些体系操作，肯定比windows好的多。

1.2 一步编译

1.2.1 gcc

想到当年在大学的时分，用vc++6.0，不知道现在还有没有人记住这个软件了，现在根本都是用vs2019了，直接在vc++6.0上，写完，就能够直接编译，然后执行，windows上的软件的确好用，但也隐藏了好多细节，所以挑选在linux上操作，完全是自己手动操作。

挑选的编译器是gcc，比较出名的gcc，怎样装置ubuntu虚拟机，怎样装置gcc，这儿就不讲了，这个是讲c言语的。

咱们能够直接来到代码目录，检查gcc是否装置成功，检查指令，仍是老方法gcc -v

看到这么一大推就说明是有了，最后一行，还说明了我的gcc版本是5.4.0，ubuntu版本是16.04。

1.2.2 编译

东西已到位，还等什么呢？直接开端编译，也是咱们平常写代码常常用的：

在linux体系中，没有输出就说明是成功的，就直接gcc 源文件，-o是gcc的参数，意思便是生成的输出文件名为hello_world，假如没有指定输出文件名也是能够的，gcc就默许把输出文件名界说成a.out。

1.2.3 运转

上面都编译成功了，咱们就接着运转吧。

这篇文章就到这儿结束了么？并没有，后边才是好戏，大家集中注意力，重要要上场了。

1.3 分步编译

1.3.1 gcc常用参数

咱们先来看看gcc常用的参数

参数	意义
-o file	指定输出文件名字
-E	只进行预处理
-S	只进行预处理和编译
-c	只进行预处理、编译和汇编

咱们在编译的时分用的这几个参数，当然gcc的参数许多，这儿就不写完了。

1.3.2 编译进程

上面咱们说了一下gcc编译的参数，接下来咱们简略看一看分步编译的流程。

1. 预处理：处理头文件，把头文件包括进来，宏的展开，还有常常用的条件编译；同时把代码注释删除，这儿不会检查代码的语法是否过错。（这儿对应的是gcc -E）
2. 编译：检查代码的语法是否过错，并把预处理的文件编译成汇编文件。（这儿对应是gcc -S）
3. 汇编：把汇编文件生成方针文件，也便是二进制文件（这儿对应-c,能够不必）
4. 链接：c言语写的代码也是引用其他库，所以需求把调用其他库的函数链接进来，这样执行的时分才能够执行。

下面是图示：

1.3.3 预处理

接下来就分别对这几个文件进行剖析，看看是不是跟咱们上面说的相同。（其实不必剖析也知道上面说的是对的，哈哈哈）

这个hello_world.i文件比较长，这儿就挑一些片段出来：

# 1 "hello_world.c"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 1 "<command-line>" 2
# 1 "hello_world.c"
# 1 "/usr/include/stdio.h" 1 3 4
# 27 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 367 "/usr/include/features.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 1 3 4
# 410 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/bits/wordsize.h" 1 3 4
# 411 "/usr/include/x86_64-linux-gnu/sys/cdefs.h" 2 3 4
# 368 "/usr/include/features.h" 2 3 4
# 391 "/usr/include/features.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 1 3 4
# 10 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 3 4
# 1 "/usr/include/x86_64-linux-gnu/gnu/stubs-64.h" 1 3 4
# 11 "/usr/include/x86_64-linux-gnu/gnu/stubs.h" 2 3 4
# 392 "/usr/include/features.h" 2 3 4
# 28 "/usr/include/stdio.h" 2 3 4
// 前面的这些是便是定位那个文件的位置和flags
// # linenum filename [flags]
// 后边的参数的意思：
// 1  这表明新文件的开端。
// 2  这表明返回到一个文件(在包括另一个文件之后)。
// 3  这表明下面的文本来自体系头文件，因此某些警告应该被按捺。
// 4  这表明下面的文本应该被视为包装在隐式extern“C”块中。
// 在预处理文件中看到这一些就理解，是定位头文件的
....
typedef unsigned char __u_char;
typedef unsigned short int __u_short;
typedef unsigned int __u_int;
typedef unsigned long int __u_long;
typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;
typedef signed long int __int64_t;
typedef unsigned long int __uint64_t;
// 这一段便是c言语自己界说的一些类型
...
extern int fprintf (FILE *__restrict __stream,
      const char *__restrict __format, ...);
extern int printf (const char *__restrict __format, ...);
extern int sprintf (char *__restrict __s,
      const char *__restrict __format, ...) __attribute__ ((__nothrow__));
// 这一段便是printf函数了，咱们的main.c调用了printf函数，为啥能编译经过，便是经过这个头文件去检查到库的
...
# 3 "hello_world.c"
int main(int argc, char **argv)
{
    printf("hello world\n");
    return 0;
}
// 这一段就比较了解了，便是咱们的代码了

预处理过后，才发现 stdio.h 竟然包括了这么多东西，还真是强壮的c言语啊。

1.3.4 编译

接下来需求把预处理的文件编译成汇编文件：

	.file	"hello_world.c"
	.section	.rodata
.LC0:
	.string	"hello world"
	.text
	.globl	main
	.type	main, @function
main:
.LFB0:
	.cfi_startproc
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	subq	$16, %rsp
	movl	%edi, -4(%rbp)
	movq	%rsi, -16(%rbp)
	movl	$.LC0, %edi
	call	puts
	movl	$0, %eax
	leave
	.cfi_def_cfa 7, 8
	ret
	.cfi_endproc
.LFE0:
	.size	main, .-main
	.ident	"GCC: (Ubuntu 5.4.0-6ubuntu1~16.04.12) 5.4.0 20160609"
	.section	.note.GNU-stack,"",@progbits

汇编文件就看着了解了许多，不过这一节就不剖析汇编了，留在下一节剖析，预处理下节课就不讲了，所以才讲的那么具体。

1.3.5 汇编

这个就直接生成了二进制文件了：

linux的方针文件的格局是.elf，之后能够剖析一下这个elf是结构。

1.3.6 链接

链接只要是在多c文件之下，由于每一个c文件都是汇编成.o文件，也便是二进制文件，然后链接器会把多个.o文件链接起来，然后生成一个可执行文件。

粗略看了一下，这个文件的确比汇编的.o差不多，好像是大了不少，能够链接了一些库吧。

提到链接库，才想起，有一个ldd指令，能够检查程序链接了什么库，这样是不是很明显了，这儿是链接了动态库，到时分才剖析吧。

1.4 总结

没想到一个比较简略的编译链接已然也写了这么多字，问题是出了写这么多字后，还有许多东西，说是留着今后剖析，想想头头大，不过都写了，就尽量写好吧，且行且珍惜。