Linux C编程入门
0 e8 o8 e+ S1 M在Windows下我们可是使用各种各样的IDE进行编程，比如强大的Visual Studio。但是在Ubuntu下如何进行编程呢？Ubuntu下也有一些可以进行编程的工具，但是大多都只是编辑器，也就是只能进行代码编辑，如果要编译的话就需要用到GCC编译器，使用GCC编译器肯定就要接触到Makefile。本章就讲解如何在Ubuntu下进行C语言的编辑和编译、GCC和Makefile的使用和编写。通过本章的学习可以掌握Linux进行C编程的基本方法，为以后的Linux驱动学习做准备。

8 a  `9 r- @: l3.1 Hello World！
我们所说的编写代码包括两部分：代码编写和编译，在Windows下可以使用Visual Studio来完成这两部分，可以在Visual Studio下编写代码然后直接点击编译就可以了。但是在Linux下这两部分是分开的，比如我们用VIM进行代码编写，编写完成以后在使用GCC编译器进行编译，其中代码编写工具很多，比如VIM编辑器、Emacs编辑器、VScode编辑器等等，本章使用Ubuntu自带的VIM编辑器。先来编写一个最简单的“Hello World”程序，把Linux下的C编程完整的走一遍。
4 ^! u0 o$ a( Z* M' I; z' \3.1.1 编写代码
先在用户根目录下创建一个工作文件夹：C_Program，所有的C语言练习都保存到这个工作文件夹下，创建过程如图3.1.1.1所示：
5 t: y1 F4 g( @5 `
( q# Z' j7 Y* r! l

图3.1.1.1 创建工作目录
进入图3.1.1.1创建的C_Program工作文件夹，为了方便管理，我们后面每个例程都创建一个文件夹来保存所有与本例程有关的文件，创建一个名为“3.1”的文件夹来保存我们的“Hello World”程序相关的文件，操作如图3.1.1.2所示：
& v6 I- n5 ^  X$ n3 N

# n) t4 ^: [9 B5 F6 O2 A
图3.1.1.2 创建工程文件夹
前面说了我们使用VI编辑器，在使用VI编辑器之前我们先做如下设置：
0 {5 f) N4 P, V9 s1、设置TAB键为4字节
VI编辑器默认TAB键为8空格，我们改成4空格，用vi打开文件/etc/vim/vimrc，在此文件最后面输入如下代码：
set ts=4
2 @0 r" H1 O9 S& j- s7 L  {2 B: Y添加完成如图3.1.1.3所示：
+ P5 a7 N5 a7 [* U, O- w
  c* j  ]8 M+ e9 ~) ~/ _& M- K: Y

4 O1 X) U6 v+ G. ]图3.1.1.3 设置TAB为四个空格
# g1 Z/ D9 _$ z7 g/ b7 }修改完成以后保存并关闭文件。
2、VIM编辑器显示行号
" ~' m% J2 R& BVIM编辑器默认是不显示行号的，不显示行号不利于代码查看，我们设置VIM编辑器显示行号，同样是通过在文件/etc/vim/vimrc中添加代码来实现，在文件最后面加入下面一行代码即可：
set nu
添加完成以后的/etc/vim/vimrc文件如图3.1.1.4所示：
! R3 j2 W$ w. ~: ]# t


图3.1.1.4 设置VIM编辑器显示行号
, |$ Y5 ~0 P5 o1 |1 n+ G1 WVIM编辑器可以自行定制，网上有很多的博客讲解如何设置VIM，感兴趣的可以上网看一下。设置好VIM编辑器以后就可以正式开始编写代码了，进入前面创建的“3.1”这个工程文件夹里面，使用vi指令创建一个名为“main.c”的文件，然后在里面输入如下代码：
7 h1 P9 w5 w3 y4 f$ e7 s3 F8 V/ K示例代码 3.1.1.1 main.c文件代码
( |( H3 E5 s1 V; N9 J% d+ g
% T# k7 O# i+ W

1. 1 #include <stdio.h>
   ' b1 x6 t  \5 B) T& M6 J# E7 y+ r2 j
2. 2  
   ' [; J* y4 d3 a+ S, f$ U7 J0 X3 `
3. 3 int main(int argc, char *argv[])
   % \7 {- [9 G9 {* h
4. 4 {
   
5. 5   printf("Hello World!\n");
   
6. 6 }

复制代码

编写完成以后保存退出vi编辑器，可以使用“cat”命令查看代码是否编写成功，如图3.1.1.5所示：
- m# I- J4 B+ I; H( C$ E) ^1 P图3.1.1.5 查阅程序源码
, a* K8 G+ Z0 U/ u" }从图3.1.1.5可以看出main.c文件是编辑成功的，代码编辑成功以后我们需要对其进行编译。
+ J) j8 ]2 U4 u  n. D4 J3.1.2 编译代码
Ubuntu下的C语言编译器是GCC，Ubuntu18默认没有安装GCC工具，因此需要我们手动安装gcc、g++、make等工具，这里我们直接安装build-essential软件包即可，build-essential提供了编译程序所需的所有软件包，输入如下命令：
, p# Y/ M: z3 R7 u. N- l* a2 Ysudo apt-get install build-essential
+ F1 `3 m: f& g$ P* y7 w等待安装完成，然后输入如下命令查看GCC编译器的版本号：
3 x1 s$ Q7 Q8 m/ Z0 n4 J; X+ tgcc -v
  h% q+ v, {) p& R& o在终端中输入上述命令以后终端输出如图3.1.2.1所示：

, g. ~  Y: @3 z
4 T4 \; r: W6 G, P- z2 C) b
图3.1.2.1 gcc版本查询
- P+ E1 K3 R) |, a' w+ g; N( H如果输入命令“gcc -v”命令以后，你的终端输出类似图3.1.2.1中的信息，那么说明你的电脑已经有GCC编译器了。最后下面的“gcc version 7.5.0”说明本机的GCC编译器版本为7.5.0的。注意观察在图3.1.2.1中有“Target: x86_64-linux-gnu”一行，这说明这个GCC编译器是针对X86架构的，因此只能编译在X86架构CPU上运行的程序。如果想要编译在ARM上运行的程序就需要针对ARM的GCC编译器，也就是交叉编译器！我们是ARM开发，因此肯定要安装针对ARM架构的GCC交叉编译器，当然了，这是后面的事，现在我们不用管这些，只要知道不同的目标架构，其GCC编译器是不同的。
如何使用GCC编译器来编译main.c文件呢？GCC编译器是命令模式的，因此需要输入命令来使用gcc编译器来编译文件，输入如下命令：
0 V0 f$ X5 p: S; y( Sgcc main.c
6 i! z3 ]; b, l2 S: Z7 P1 q& u上述命令的功能就是使用gcc编译器来编译main.c这个c文件，过程如图3.1.2.2所示：


4 b3 w5 U' ?0 i5 C6 g  x3 g) M; E
) R; k: E& u0 f5 A% U8 q图3.1.2.2 编译main.c文件
- T4 t; h9 s. q/ \5 y在图3.1.2.2中可以看到，当编译完成以后会生成一个a.out文件，这个a.out就是编译生成发的可执行文件，执行此文件看看是否和我们代码的功能一样，执行的方法很简单使用命令：“./+可执行文件”，比如本例程就是命令：./a.out，操作如图3.1.2.3所示：
% q) s" p% W+ t% J9 ], A  K# e
; P, ]; k6 p3 o6 m0 I0 T  o3 ~
2 x, y+ ~+ R$ k
图3.1.2.3 执行编译得到的文件
在图3.1.2.3中执行a.out文件以后终端输出了“Hello World！”，这正是main.c要实现的功能，说明我们的程序没有错误。a.out这个文件的命名是GCC编译器自动命名的，那我们能不能决定编译完生成的可执行文件名字呢？肯定可以的，在使用gcc命令的时候加上-o来指定生成的可执行文件名字，比如编译main.c以后生成名为“main”的可执行文件，操作如图3.1.2.4所示：
' z1 T- A% b, h* P
) }2 c4 \! l4 t, M
9 D9 h! N: }" i; i
5 T9 O; v  V  p! W( P图3.1.2.4 指定可执行文件名字
! T' B& Q5 e1 M) w在图3.1.2.4中，我们使用“gcc main.c –o main”来编译main.c文件，使用参数“-o”来指定编译生成的可执行文件名字，至此我们就完成Linux下C编程和编译的一整套过程。
, j" \" G! S4 |4 h5 [3.2 GCC编译器
3.2.1 gcc命令
& `8 m: [5 T/ k, z  i: i/ ?在上一小节我们已经使用过GCC编译器来编译C文件了，我们使用到是gcc命令，gcc命令格式如下：
( R# t$ c( j3 t. Sgcc [选项] [文件名字]
主要选项如下：
8 b$ M7 A* O$ {% ]$ e5 _-c：只编译不链接为可执行文件，编译器将输入的.c文件编译为.o的目标文件。
! E$ R7 K! N9 T% l! |-o：<输出文件名> 用来指定编译结束以后的输出文件名，如果使用这个选项的话GCC默认编译出来的可执行文件名字为a.out。
9 G8 T9 E/ ?, w# V  G* N& c6 f# }% }& u-g：添加调试信息，如果要使用调试工具(如GDB)的话就必须加入此选项，此选项指示编译的时候生成调试所需的符号信息。
-O：对程序进行优化编译，如果使用此选项的话整个源代码在编译、链接的的时候都会进行优化，这样产生的可执行文件执行效率就高。
-O2：比-O更幅度更大的优化，生成的可执行效率更高，但是整个编译过程会很慢。
# m8 f' r) f" s  j3.2.2 编译错误警告
+ }' N- V+ i# k& N$ B+ N* X. q* a在Windows下不管我们用啥编译器，如果程序有语法错误的话编译的时候都会指示出来，比如开发STM32的时候所使用的MDK和IAR，我们可以根据错误信息方便的修改bug。那GCC编译器有没有错误提示呢？肯定是有的，我们可以测试以下，新名为“3.2”的文件夹，使用vi在文件夹“3.2”中创建一个main.c文件，在文件里面输入如下代码：
. k; d( Y: H. R: G9 T( J示例代码3.2.2.1 main.c文件代码
5 \+ D2 C7 t* I4 c7 U4 m

1. 1  #include <stdio.h>
   * _& ]% A! F; n& q
2. 2     
   % B' T9 S" {! x- ^; G4 j
3. 3  int main(int argc, char *argv[])
   # P7 Z. ]6 D4 h* V% F9 m
4. 4  {
   
5. 5      int a, b;
   # j4 r  m# Q3 J9 a- ]& y( ~
6. 6      
   6 q! q; v) Z4 Q/ O& L* ?7 [* a
7. 7      a = 3;
   / A; [7 p) S/ c! r7 L1 z
8. 8      b = 4                                                        
   ( \  K& b8 r0 U
9. 9      printf("a+b=\n", a + b);                                    
   5 {! z: S- X( N. |* E
10. 10 }

复制代码

3 \' a1 M5 I4 B在上述代码中有两处错误：
第8行、第一处是“b=4”少写了个一个“；”号。
4 ^3 x% e5 K5 s% K  U1 e第9行、第二处应该是printf(“a+b=%d\n”,  a + b);
我们编译以下上述代码，看看GCC编译器是否能够检查出错误，编译结果如图3.2.2.1所示：
: {3 `- z, P+ x
/ u) ?6 C/ d6 U: Z/ e  R/ ~
/ ?" i0 h  c6 t9 {$ H
5 L( W  G- W9 f; ~% P" c2 X图3.2.2.1 错误提示
从图3.2.2.1中可以看出有一个error，提示在main.c文件的第9行有错误，错误类型是在printf之前没有“；”号，这就是第一处错误，我们在“b = 4”后面加上分号，然后接着编译，结果又提示有一个错误，如图3.2.2.2所示：
% k! c9 T8 S7 A% g  R
2 h6 P1 ^5 D' @

图3.2.2.2 错误提示
% c4 a( }1 q; P9 i6 X在图3.2.2.2中，提示我们说文件main.c的第9行：printf(“a+b=\n”, a + b)有warning，错误是因为太多参数了，我们将其改为：
printf(“a+b=%d\n”, a + b);
4 O7 A% {+ j! ]- \; K8 B修改完成以后接着重新编译一下，结果如图3.2.2.3所示：

3 ]% C! Z( Z9 O% n6 h' F. ~

图3.2.2.3 编译成功
/ D: r7 A' ^# J: d3 e# e% O! Q在图3.2.2.3中我们编译成功，生成了可执行文件main，执行一下main，看看结果和我们设计的是否一样，如图3.2.2.4所示：
: A7 `  f2 k" A  i' u* j6 `
7 G6 G: `1 B: U- F9 [! _
/ E5 C% i+ N/ A
图3.2.2.4 执行结果
可以看出，GCC编译器和其它编译器一样，不仅能够检测出错误类型，而且标记除了错误发生在哪个文件？哪一行？方便我们去修改代码。
" d( e; x4 L& d5 ^' D8 \3.2.3 编译流程
2 K- P- I1 }# H% O1 O+ g' l7 m8 e) PGCC编译器的编译流程是：预处理、编译、汇编和链接。预处理就是展开所有的头文件、替换程序中的宏、解析条件编译并添加到文件中。编译是将经过预编译处理的代码编译成汇编代码，也就是我们常说的程序编译。汇编就是将汇编语言文件编译成二进制目标文件。链接就是将汇编出来的多个二进制目标文件链接在一起，形成最终的可执行文件，链接的时候还会涉及到静态库和动态库等问题。
上一小节演示的例程都只有一个文件，而且文件非常简单，因此可以直接使用gcc命令生成可执行文件，并没有先将c文件编译成.o文件，然后再链接在一起。
8 x, u* ]0 b2 w& E0 ^1 {
  e( e* j6 |; a# K+ i, S, Z3.3 Makefile基础
3.3.1 何为Makefile
上一小节我们讲了如何使用GCC编译器在Linux进行C语言编译，通过在终端执行gcc命令来完成C文件的编译，如果我们的工程只有一两个C文件还好，需要输入的命令不多，当文件有几十、上百甚至上万个的时候用终端输入GCC命令的方法显然是不现实的。如果我们能够编写一个文件，这个文件描述了编译哪些源码文件、如何编译那就好了，每次需要编译工程的时只需要使用这个文件就行了。这种问题怎么可能难倒聪明的程序员，为此提出了一个解决大工程编译的工具：make，描述哪些文件需要编译、哪些需要重新编译的文件就叫做Makefile，Makefile就跟脚本文件一样，Makefile里面还可以执行系统命令。使用的时候只需要一个make命令即可完成整个工程的自动编译，极大的提高了软件开发的效率。如果大家以前一直使用IDE来编写C语言的话肯定没有听说过Makefile这个东西，其实这些IDE是有的，只不过这些IDE对其进行了封装，提供给大家的是已经经过封装后的图形界面了，我们在IDE中添加要编译的C文件，然后点击按钮就完成了编译。在Linux下用的最多的是GCC编译器，这是个没有UI的编译器，因此Makefile就需要我们自己来编写了。作为一个专业的程序员，是一定要懂得Makefile的，一是因为在Linux下你不得不懂Makefile，再就是通过Makefile你就能了解整个工程的处理过程。
6 r, }2 G2 ~; H, X* b$ w* Q  _8 o9 i由于Makefile的知识比较多，完全可以单独写本书，因此本章我们只讲解Makefile基础入门，如果想详细的研究Makefile，推荐大家阅读《跟我一起写Makefile》这份文档，文档已经放到了开发板光盘->4、参考资料里面了，本章也有很多地方参考了此文档。
3.3.2 Makefile的引入
" k9 b6 h2 d3 I我们完成这样一个小工程，通过键盘输入两个整形数字，然后计算他们的和并将结果显示在屏幕上，在这个工程中我们有main.c、input.c和calcu.c这三个C文件和input.h、calcu.h这两个头文件。其中main.c是主体，input.c负责接收从键盘输入的数值，calcu.h进行任意两个数相加，其中main.c文件内容如下：
示例代码3.3.2.1 main.c文件代码

1. 1 #include <stdio.h>
   
2. 2 #include "input.h"
   
3. 3 #include "calcu.h"
     D$ _) H- @. G  z
4. 4
   
5. 5 int main(int argc, char *argv[])
   ; `0 t! ~* Y$ v4 b6 J: B
6. 6 {
   7 L/ _, j& j! J$ w$ v
7. 7     int a, b, num;
   & H5 Z' m# a8 m; l
8. 8
   
9. 9     input_int(&a, &b);
   
10. 10    num  = calcu(a, b);
    
11. 11    printf("%d + %d = %d\r\n", a, b, num);
    - P7 c9 X+ s6 z5 U4 Z9 y
12. 12 }

复制代码

7 d& B0 c: I9 P9 P. C9 }) Dinput.c文件内容如下：

- r, T6 _4 ^' `6 ^: N: b示例代码3.3.2.2 input.c文件代码

1. 1 #include <stdio.h>
   
2. 2 #include "input.h"
   
3. 3
   ; I" r+ V# e, S( h' c/ k
4. 4 void input_int(int *a, int *b)
   - x  Y/ v* I8 V1 K+ Y
5. 5 {
     D- j: Y- Y9 g2 d
6. 6     printf("input two num:");
   " R. N' K0 M; J  Q
7. 7     scanf("%d %d", a, b);
   2 D3 c' d) F# i) ~* }0 V1 ~
8. 8     printf("\r\n");
   ( L7 ^& r: Q7 E3 B, F
9. 9 }

复制代码

calcu.c文件内容如下：

; e+ W# p9 D  {  T3 E4 {示例代码3.3.2.3 calcu.c文件代码

1. 1 #include "calcu.h"
   
2. 2
   
3. 3 int calcu(int a, int b)
   9 v3 H; T  z$ w6 K( {6 ^
4. 4 {
   
5. 5     return (a + b);
   / \, M5 M  C3 T8 f% Z3 R0 r
6. 6 }

复制代码

9 H' z9 ?  P7 H2 G  c文件input.h内容如下：

1. 示例代码3.3.2.4 input.h文件代码
   
2. 
   0 m7 v$ p& c* r( f" U
3. 1 #ifndef _INPUT_H
   
4. 2 #define _INPUT_H
   
5. 3
   & a3 U/ s0 t: }0 v: d
6. 4 void input_int(int *a, int *b);
   * z2 f( K+ V9 b8 {' v% m- B
7. 5 #endif
   
8.         文件calcu.h内容如下：
   2 _( v1 y2 G1 q' E; w  d5 j
9. 示例代码3.3.2.5 calcu.h文件代码
   " [( z/ e/ w) V3 ]$ i9 N
10. 1 #ifndef _CALCU_H
      V) I) L- A9 a2 `/ a
11. 2 #define _CALCU_H
    
12. 3
    
13. 4 int calcu(int a, int b);
    3 x2 V3 X. B8 f. ]9 f* B
14. 5 #endif

复制代码

以上就是我们这个小工程的所有源文件，我们接下来使用3.1节讲的方法来对其进行编译，在终端输入如下命令：
' c, S6 V" J7 p& F
; Y6 C( m# Z: H4 |7 g- `# \gcc main.c calcu.c input.c -o main
) u$ E+ o9 @2 I' U; q; U上面命令的意思就是使用gcc编译器对main.c、calcu.c和input.c这三个文件进行编译，编译生成的可执行文件叫做main。编译完成以后执行main这个程序，测试一下软件是否工作正常，结果如图3.3.2.1所示：
" _9 G1 \+ e  V5 ^5 \* d+ \5 O
7 X9 I2 ~4 X% D/ S/ g6 X
1 O' R& t  I& m6 \9 B2 ?/ i5 P* S
图3.3.2.1 程序测试
0 \- ]0 x; r7 R' `$ j" N可以看出我们的代码按照我们所设想的工作了，使用命令“gcc main.c calcu.c input.c -o main”看起来很简单是吧，只需要一行就可以完成编译，但是我们这个工程只有三个文件啊！如果几千个文件呢？再就是如果有一个文件被修改了以，使用上面的命令编译的时候所有的文件都会重新编译，如果工程有几万个文件(Linux源码就有这么多文件！)，想想这几万个文件编译一次所需要的时间就可怕。最好的办法肯定是哪个文件被修改了，只编译这个被修改的文件即可，其它没有修改的文件就不需要再次重新编译了，为此我们改变我们的编译方法，如果第一次编译工程，我们先将工程中的文件都编译一遍，然后后面修改了哪个文件就编译哪个文件，命令如下：
8 Y2 y# x' b5 C5 M5 ?( |
3 W6 M9 p3 R& R  D& x

1. gcc -c main.c
   
2. gcc -c input.c
   
3. gcc -c calcu.c
   
4. gcc main.o input.o calcu.o -o main

复制代码

: Q0 ?, I* A; e& H9 P! f上述命令前三行分别是将main.c、input.c和calcu.c编译成对应的.o文件，所以使用了“-c”选项，“-c”选项我们上面说了，是只编译不链接。最后一行命令是将编译出来的所有.o文件链接成可执行文件main。假如我们现在修改了calcu.c这个文件，只需要将caclue.c这一个文件重新编译成.o文件，然后在将所有的.o文件链接成可执行文件即，只需要下面两条命令即可：
+ u+ a7 h7 l: t3 r
: `& A% l( h5 _- n. Vgcc -c calcu.c
gcc main.o input.o calcu.o -o main
但是这样就又有一个问题，如果修改的文件一多，我自己可能都不记得哪个文件修改过了，然后忘记编译，然后……，为此我们需要这样一个工具：
/ V+ n. ]& |* A/ l$ e2 x( R( y1、如果工程没有编译过，那么工程中的所有.c文件都要被编译并且链接成可执行程序。
4 [% \  F" V! J9 A, c, z5 I2、如果工程中只有个别C文件被修改了，那么只编译这些被修改的C文件即可。
3、如果工程的头文件被修改了，那么我们需要编译所有引用这个头文件的C文件，并且链接成可执行文件。
1 r/ M1 E% a: V$ P( b9 a很明显，能够完成这个功能的就是Makefile了，在工程目录下创建名为“Makefile”的文件，文件名一定要叫做“Makefile”！！！区分大小写的哦！如图3.3.2.2所示：
8 C" S1 F. O$ I( v7 s) f
. T4 }3 r! @' d1 e  J; s图3.3.2.2 Makefile文件
6 s6 L3 V- u1 S  o9 |0 Y) V3 d  Z在图3.3.2.2中Makefile和C文件是处于同一个目录的，在Makefile文件中输入如下代码：
示例代码3.3.2.6 Makefile文件代码
3 `" O6 w) v: @7 {) N9 N" _
( S/ X; F3 t  ~

1. 1  main: main.o input.o calcu.o
   
2. 2      gcc -o main  main.o input.o calcu.o
   8 N- ?/ m" I' k- [7 C0 |+ _) K
3. 3  main.o: main.c
   2 d( F+ b: |  k% N7 Y" w8 t; a
4. 4      gcc -c main.c
   # F- c3 Q6 }9 v: f# h1 F
5. 5  input.o: input.c
   
6. 6      gcc -c input.c
   . ]( F# |5 {* g  B
7. 7  calcu.o: calcu.c
   
8. 8      gcc -c calcu.c
   ; c4 y% Z! ?% [. l7 \) I6 |
9. 9  
   , j6 w( q" X9 N  w0 c
10. 10 clean:
    
11. 11     rm *.o
    
12. 12     rm main

复制代码

上述代码中所有行首需要空出来的地方一定要使用“TAB”键！不要使用空格键！这是Makefile的语法要求，编写好得Makefile如图3.3.2.3所示：

' V8 N/ C0 w1 g1 J' a/ D3 C
1 d# Z# O. G7 x. l( k/ Q6 _& }
图3.3.2.3 Makefile源码
Makefile编写好以后我们就可以使用make命令来编译我们的工程了，直接在命令行中输入“make”即可，make命令会在当前目录下查找是否存在“Makefile”这个文件，如果存在的话就会按照Makefile里面定义的编译方式进行编译，如图3.3.2.4所示：
' F1 m. Y. T" T

: @8 f" k2 k! g7 q! D
* t, Y0 M, H4 U7 ?, z* T& i1 w图3.3.2.4 Make编译工程
" D& A4 h; L: ^. C5 D$ J在图3.3.2.4中，使用命令“make”编译完成以后就会在当前工程目录下生成各种.o和可执行文件，说明我们编译成功了。使用make命令编译工程的时候可能会提示如图3.3.2.5所示错误:

& `. q" u1 w, L" o9 r5 ~
7 F  Q; ^+ _- M0 ^' [6 X
图3.3.2.5 Make失败
2 v6 P7 C9 D3 D- h/ }' ^! `图3.3.2.5中的错误来源一般有两点:
% A6 d9 x& a1 E7 ?5 S( q1、Makefile中命令缩进没有使用TAB键！
8 G( C0 M( M0 a* }+ W* v2、VI/VIM编辑器使用空格代替了TAB键，修改文件/etc/vim/vimrc，在文件最后面加上如下所示代码：
0 [1 ^2 K! k% n1 c, `+ a0 Xset noexpandtab
我们修改一下input.c文件源码，随便加几行空行就行了，保证input.c被修改过即可，修改完成以后再执行一下“make”命令重新编译一下工程，结果如图3.3.2.6所示：
2 w7 b0 E8 |% _5 K6 d3 b: }
1 |( z" k  h4 S# O
& k: O. h  ]7 i" [
( ?( h+ @5 P( D2 j/ ?- _4 R9 u1 \图3.3.2.6 重新编译工程
————————————————
版权声明：正点原子