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常用的参数

我们在编译的时候用的这几个参数，当然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 总结

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