C语言的本质——Makefile

除了Hello World这种极简单的程序之外，一般的程序都是由多个源文件编译链接而成的，这些源文件的处理步骤通常用Makefile来管理。makefile带来的好处就是——“自动化编译”，一旦写好，只需要一个make命令，整个工程完全自动编译，极大的提高了软件开发的效率。make是一个命令工具，是一个解释makefile中指令的命令工具，一般来说，大多数的IDE都有这个命令

C语言首先要把源文件编译成中间代码文件，在Windows下也就是 .obj 文件，UNIX下是 .o 文件，即 ObjectFile，这个动作叫做编译（compile）。然后再把大量的Object File合成执行文件，这个动作叫作链接（link）。

编译时，编译器需要的是语法的正确，函数与变量的声明的正确。对于后者，通常是你需要告诉编译器头文件的所在位置（头文件中应该只是声明，而定义应该放在C/C++文件中），只要所有的语法正确，编译器就可以编译出中间目标文件。一般来说，每个源文件都应该对应于一个中间目标文件（O文件或是OBJ文件）。

链接时，主要是链接函数和全局变量，所以，我们可以使用这些中间目标文件（O文件或是OBJ文件）来链接我们的应用程序。链接器并不管函数所在的源文件，只管函数的中间目标文件（Object File），在大多数时候，由于源文件太多，编译生成的中间目标文件太多，而在链接时需要明显地指出中间目标文件名，这对于编译很不方便，所以，我们要给中间目标文件打个包，在Windows下这种包叫“库文件”（Library File)，也就是 .lib 文件，在UNIX下，是Archive File，也就是 .a 文件。

总结一下，源文件首先会生成中间目标文件，再由中间目标文件生成执行文件。在编译时，编译器只检测程序语法，和函数、变量是否被声明。如果函数未被声明，编译器会给出一个警告，但可以生成Object File。而在链接程序时，链接器会在所有的Object File中找寻函数的实现，如果找不到，那到就会报链接错误码（Linker Error），在VC下，这种错误一般是：Link 2001错误，意思说是说，链接器未能找到函数的实现。你需要指定函数的Object File.

make命令执行时，需要一个 Makefile 文件，以告诉make命令需要怎么样的去编译和链接程序。

首先，我们用一个示例来说明Makefile的书写规则。以便给大家一个感兴认识。这个示例来源于GNU的make使用手册，在这个示例中，我们的工程有8个C文件，和3个头文件，我们要写一个Makefile来告诉make命令如何编译和链接这几个文件。我们的规则是：

1）如果这个工程没有编译过，那么我们的所有C文件都要编译并被链接。

2）如果这个工程的某几个C文件被修改，那么我们只编译被修改的C文件，并链接目标程序。

3）如果这个工程的头文件被改变了，那么我们需要编译引用了这几个头文件的C文件，并链接目标程序。

只要我们的Makefile写得够好，所有的这一切，我们只用一个make命令就可以完成，make命令会自动智能地根据当前的文件修改的情况来确定哪些文件需要重编译，从而自己编译所需要的文件和链接目标程序。

Makefile的规则

我们先来粗略地看一看Makefile的规则。

target … : prerequisites …

       command

       ...

       ...

target也就是一个目标文件，可以是Object File，也可以是执行文件。还可以是一个标签（Label），对于标签这种特性，在后续的“伪目标”章节中会有叙述。

prerequisites就是，要生成那个target所需要的文件或是目标。

command也就是make需要执行的命令。（任意的Shell命令）

这是一个文件的依赖关系，也就是说，target这一个或多个的目标文件依赖于prerequisites中的文件，其生成规则定义在command中。说白一点就是说，prerequisites中如果有一个以上的文件比target文件要新的话，command所定义的命令就会被执行。这就是Makefile的规则。也就是Makefile中最核心的内容。

一个示例：

正如前面所说的，如果一个工程有3个头文件，和8个C文件，我们为了完成前面所述的那三个规则，我们的Makefile应该是下面的这个样子的。

   edit : main.o kbd.o command.o display.o \
          insert.o search.o files.o utils.o
           cc -o edit main.o kbd.o command.o display.o \
                       insert.o search.ofiles.o utils.o
 
   main.o : main.c defs.h
           cc -c main.c
   kbd.o : kbd.c defs.h command.h
           cc -c kbd.c
   command.o : command.c defs.h command.h
           cc -c command.c
   display.o : display.c defs.h buffer.h
           cc -c display.c
   insert.o : insert.c defs.h buffer.h
           cc -c insert.c
   search.o : search.c defs.h buffer.h
           cc -c search.c
   files.o : files.c defs.h buffer.h command.h
           cc -c files.c
   utils.o : utils.c defs.h
           cc -c utils.c
   clean :
           rm edit main.o kbd.o command.o display.o \
               insert.o search.o files.outils.o

反斜杠（\）是换行符的意思。这样比较便于Makefile的易读。我们可以把这个内容保存在文件为“Makefile”或“makefile”的文件中，然后在该目录下直接输入命令“make”就可以生成执行文件edit。如果要删除执行文件和所有的中间目标文件，那么，只要简单地执行一下“make clean”就可以了。

在这个makefile中，目标文件（target）包含：执行文件edit和中间目标文件（*.o），依赖文件（prerequisites）就是冒号后面的那些 .c 文件和 .h文件。每一个 .o 文件都有一组依赖文件，而这些 .o 文件又是执行文件 edit 的依赖文件。依赖关系的实质上就是说明了目标文件是由哪些文件生成的，换言之，目标文件是哪些文件更新的。

在定义好依赖关系后，后续的那一行定义了如何生成目标文件的操作系统命令，一定要以一个Tab键作为开头。记住，make并不管命令是怎么工作的，他只管执行所定义的命令。make会比较targets文件和prerequisites文件的修改日期，如果prerequisites文件的日期要比targets文件的日期要新，或者target不存在的话，那么，make就会执行后续定义的命令。

这里要说明一点的是，clean不是一个文件，它只不过是一个动作名字，有点像C语言中的lable一样，其冒号后什么也没有，那么，make就不会自动去找文件的依赖性，也就不会自动执行其后所定义的命令。要执行其后的命令，就要在make命令后明显得指出这个lable的名字。这样的方法非常有用，我们可以在一个makefile中定义不用的编译或是和编译无关的命令，比如程序的打包，程序的备份，等等。

在默认的方式下，也就是我们只输入make命令。那么，
1、make会在当前目录下找名字叫“Makefile”或“makefile”的文件。

2、如果找到，它会找文件中的第一个目标文件（target），在上面的例子中，他会找到“edit”这个文件，并把这个文件作为最终的目标文件。

3、如果edit文件不存在，或是edit所依赖的后面的 .o 文件的文件修改时间要比edit这个文件新，那么，他就会执行后面所定义的命令来生成edit这个文件。

4、如果edit所依赖的.o文件也存在，那么make会在当前文件中找目标为.o文件的依赖性，如果找到则再根据那一个规则生成.o文件。（这有点像一个堆栈的过程）

5、当然，你的C文件和H文件是存在的啦，于是make会生成 .o 文件，然后再用 .o 文件生命make的终极任务，也就是执行文件edit了。

这就是整个make的依赖性，make会一层又一层地去找文件的依赖关系，直到最终编译出第一个目标文件。在找寻的过程中，如果出现错误，比如最后被依赖的文件找不到，那么make就会直接退出，并报错，而对于所定义的命令的错误，或是编译不成功，make根本不理。make只负责文件的依赖性。

通过上述分析，我们知道，像clean这种，没有被第一个目标文件直接或间接关联，那么它后面所定义的命令将不会被自动执行，不过，我们可以显示要make执行。即命令——“make clean”，以此来清除所有的目标文件，以便重编译。

于是在我们编程中，如果这个工程已被编译过了，当我们修改了其中一个源文件，比如file.c，那么根据我们的依赖性，我们的目标file.o会被重编译（也就是在这个依性关系后面所定义的命令），于是file.o的文件也是最新的啦，于是file.o的文件修改时间要比edit要新，所以edit也会被重新链接了（详见edit目标文件后定义的命令）。

而如果我们改变了“command.h”，那么，kdb.o、command.o和files.o都会被重编译，并且，edit会被重链接。

makefile中使用变量

在上面的例子中，先让我们看看edit的规则：

     edit : main.o kbd.o command.o display.o \
                  insert.o search.o files.outils.o
           cc -o edit main.o kbd.o command.o display.o \
                       insert.o search.ofiles.o utils.o

我们可以看到[.o]文件的字符串被重复了两次，如果我们的工程需要加入一个新的[.o]文件，那么我们需要在两个地方加（应该是三个地方，还有一个地方在clean中）。当然，我们的makefile并不复杂，所以在两个地方加也不累，但如果makefile变得复杂，那么我们就有可能会忘掉一个需要加入的地方，而导致编译失败。所以，为了makefile的易维护，在makefile中我们可以使用变量。makefile的变量也就是一个字符串，理解成C语言中的宏可能会更好。

比如，我们声明一个变量，叫objects, OBJECTS, objs, OBJS, obj, 或是 OBJ，反正不管什么啦，只要能够表示obj文件就行了。我们在makefile一开始就这样定义：

    objects = main.o kbd.o command.o display.o \
              insert.o search.o files.o utils.o

于是，我们就可以很方便地在我们的makefile中以“$(objects)”的方式来使用这个变量了，于是我们的改良版makefile就变成下面这个样子：

   objects = main.o kbd.o command.o display.o \
              insert.o search.o files.o utils.o
 
   edit : $(objects)
           cc -o edit $(objects)
   main.o : main.c defs.h
           cc -c main.c
   kbd.o : kbd.c defs.h command.h
           cc -c kbd.c
   command.o : command.c defs.h command.h
           cc -c command.c
   display.o : display.c defs.h buffer.h
           cc -c display.c
   insert.o : insert.c defs.h buffer.h
           cc -c insert.c
   search.o : search.c defs.h buffer.h
           cc -c search.c
   files.o : files.c defs.h buffer.h command.h
           cc -c files.c
   utils.o : utils.c defs.h
           cc -c utils.c
   clean :
           rm edit $(objects)

于是如果有新的 .o 文件加入，我们只需简单地修改一下 objects 变量就可以了。

让make自动推导

GNU的make很强大，它可以自动推导文件以及文件依赖关系后面的命令，于是我们就没必要去在每一个[.o]文件后都写上类似的命令，因为，我们的make会自动识别，并自己推导命令。

只要make看到一个[.o]文件，它就会自动的把[.c]文件加在依赖关系中，如果make找到一个whatever.o，那么whatever.c，就会是whatever.o的依赖文件。并且 cc -c whatever.c 也会被推导出来，于是，我们的makefile再也不用写得这么复杂。

   objects = main.o kbd.o command.o display.o \
              insert.o search.o files.o utils.o
 
   edit : $(objects)
           cc -o edit $(objects)
 
   main.o : defs.h
   kbd.o : defs.h command.h
   command.o : defs.h command.h
   display.o : defs.h buffer.h
   insert.o : defs.h buffer.h
   search.o : defs.h buffer.h
   files.o : defs.h buffer.h command.h
   utils.o : defs.h
 
   .PHONY : clean
   clean :
           rm edit $(objects)

这种方法，也就是make的“隐晦规则”。上面文件内容中，“.PHONY”表示，clean是个伪目标文件。

Makefile有很多灵活的写法，可以写得更简洁，同时减少出错的可能。本节我们来看看这样一个例子还有哪些改进的余地。

一个目标依赖的所有条件不一定非得写在一条规则中，也可以拆开写，例如：

main.o: main.h stack.h maze.h
 
main.o: main.c
         gcc-c main.c

就相当于：

main.o: main.c main.h stack.h maze.h
         gcc-c main.c

如果一个目标拆开写多条规则，其中只有一条规则允许有命令列表，其它规则应该没有命令列表，否则make会报警告并且采用最后一条规则的命令列表。

这样我们的例子可以改写成：

main: main.o stack.o maze.o
         gccmain.o stack.o maze.o -o main
 
main.o: main.h stack.h maze.h
stack.o: stack.h main.h
maze.o: maze.h main.h
 
main.o: main.c
         gcc-c main.c
 
stack.o: stack.c
         gcc-c stack.c
 
maze.o: maze.c
         gcc-c maze.c
 
clean:
         -rmmain *.o
 
.PHONY: clean

这不是比原来更繁琐了吗？现在可以把提出来的三条规则删去，写成：

main: main.o stack.o maze.o
         gccmain.o stack.o maze.o -o main
 
main.o: main.h stack.h maze.h
stack.o: stack.h main.h
maze.o: maze.h main.h
 
clean:
         -rmmain *.o
 
.PHONY: clean

这就比原来简单多了。可是现在main.o、stack.o和maze.o这三个目标连编译命令都没有了，怎么编译的呢？试试看：

$ make
cc   -c -o main.o main.c
cc   -c -o stack.o stack.c
cc   -c -o maze.o maze.c
gcc main.o stack.o maze.o -o main

现在解释一下前三条编译命令是怎么来。如果一个目标在Makefile中的所有规则都没有命令列表，make会尝试在内建的隐含规则（Implicit Rule）数据库中查找适用的规则。make的隐含规则数据库可以用make -p命令打印，打印出来的格式也是Makefile的格式，包括很多变量和规则，其中和我们这个例子有关的隐含规则有：

# default
OUTPUT_OPTION = -o $@
 
# default
CC = cc
 
# default
COMPILE.c = $(CC) $(CFLAGS) $(CPPFLAGS)$(TARGET_ARCH) -c
 
%.o: %.c
# commands to execute (built-in):
       $(COMPILE.c) $(OUTPUT_OPTION) $<

#号在Makefile中表示单行注释，就像C语言的//注释一样。CC是一个Makefile变量，用CC = cc定义和赋值，用$(CC)取它的值，其值应该是cc。Makefile变量像C的宏定义一样，代表一串字符，在取值的地方展开。cc是一个符号链接，通常指向gcc，在有些UNIX系统上可能指向另外一种C编译器。

CFLAGS这个变量没有定义,$(CFLAGS)展开是空，CPPFLAGS和TARGE{T}_{A}RCH也是如此。这样$(COMPILE.c)展开应该是cc 空 空 空 -c，去掉“空”得到cc -c，注意中间留下4个空格，所以%.o:%.c规则的命令$(COMPILE.c) $(OUTPUT_OPTION) $<展开之后是cc -c -o $@$<，和上面的编译命令已经很接近了。

$@和$<是两个特殊的变量，$@的取值为规则中的目标，$<的取值为规则中的第一个条件。%.o: %.c是一种特殊的规则，称为模式规则（Pattern Rule）。现在回顾一下整个过程，在我们的Makefile中以main.o为目标的规则都没有命令列表，所以make会查找隐含规则，发现隐含规则中有这样一条模式规则适用，main.o符合%.o的模式，现在%就代表main（称为main.o这个名字的Stem），再替换到%.c中就是main.c。所以这条模式规则相当于：

main.o: main.c
         cc    -c -o main.o main.c

随后，在处理stack.o目标时又用到这条模式规则，这时又相当于：

stack.o: stack.c
         cc    -c -o stack.o stack.c

maze.o也同样处理。这三条规则可以由make的隐含规则推导出来，所以不必写在Makefile中。

先前我们写Makefile都是以目标为中心，一个目标依赖于若干条件，现在换个角度，以条件为中心，Makefile还可以这么写：

main: main.o stack.o maze.o
         gccmain.o stack.o maze.o -o main
 
main.o stack.o maze.o: main.h
main.o maze.o: maze.h
main.o stack.o: stack.h
 
clean:
         -rmmain *.o
 
.PHONY: clean

我们知道，写规则的目的是让make建立依赖关系图，不管怎么写，只要把所有的依赖关系都描述清楚了就行。对于多目标的规则，make会拆成几条单目标的规则来处理，例如

target1 target2: prerequisite1prerequisite2
         command$< -o $@

这样一条规则相当于：

target1: prerequisite1 prerequisite2
commandprerequisite1 -o target1

target2: prerequisite1 prerequisite2
commandprerequisite1 -o target2

注意两条规则的命令列表是一样的，但$@的取值不同。

我们详细看看Makefile中关于变量的语法规则。先看一个简单的例子：

foo = $(bar)
bar = Huh?
 
all:
    @echo$(foo)

我们执行make将会打出Huh?。当make读到foo = $(bar)时，确定foo的值是$(bar)，但并不立即展开$(bar)，然后读到bar = Huh?，确定bar的值是Huh?，然后在执行规则all:的命令列表时才需要展开$(foo)，得到$(bar)，再展开$(bar)，得到Huh?。因此，虽然bar的定义写在foo之后，$(foo)展开还是能够取到$(bar)的值。
这种特性有好处也有坏处。好处是我们可以把变量的值推迟到后面定义，例如：

main.o: main.c
    $(CC)$(CFLAGS) $(CPPFLAGS) -c $<
 
CC = gcc
CFLAGS = -O -g
CPPFLAGS = -Iinclude

编译命令可以展开成gcc -O -g -Iinclude -cmain.c。通常把CFLAGS定义成一些编译选项，例如-O、-g等，而把CPPFLAGS定义成一些预处理选项，例如-D、-I等。用=号定义变量的延迟展开特性也有坏处，就是有可能写出无穷递归的定义，例如CFLAGS = $(CFLAGS) -O，或者：

A = $(B)
B = $(A)

当然，make有能力检测出这样的错误而不会陷入死循环。有时候我们希望make在遇到变量定义时立即展开，可以用:=运算符，例如：

x := foo
y := $(x) bar
 
all:
    @echo"-$(y)-"

当make读到y :=$(x) bar定义时，立即把$(x)展开，使变量y的取值是foo bar，如果把这两行颠倒过来：

y := $(x) bar
x := foo

那么当make读到y :=$(x) bar时，x还没有定义，展开为空值，所以y的取值是 bar，注意bar前面有个空格。一个变量的定义从=后面的第一个非空白字符开始（从$(x)的$开始），包括后面的所有字符，直到注释或换行之前结束。如果要定义一个变量的值是一个空格，可以这样：

nullstring :=
space := $(nullstring) # end ofthe line

nullstring的值为空，space的值是一个空格，后面写个注释是为了增加可读性，如果不写注释就换行，则很难看出$(nullstring)后面有个空格。
还有一个比较有用的赋值运算符是?=，例如foo ?= $(bar)的意思是：如果foo没有定义过，那么?=相当于=，定义foo的值是$(bar)，但不立即展开；如果先前已经定义了foo，则什么也不做，不会给foo重新赋值。
+=运算符可以给变量追加值，例如：

objects = main.o
objects += $(foo)
foo = foo.o bar.o

object是用=定义的，+=仍然保持=的特性，objects的值是main.o$(foo)（注意$(foo)前面自动添一个空格），但不立即展开，等到后面需要展开$(objects)时会展开成main.o foo.o bar.o。

再比如：

objects := main.o
objects += $(foo)
foo = foo.o bar.o

object是用:=定义的，+=保持:=的特性，objects的值是main.o$(foo)，立即展开得到main.o （这时foo还没定义），注意main.o后面的空格仍保留。

如果变量还没有定义过就直接用+=赋值，那么+=相当于=。
上一节我们用到了特殊变量$@和$<，这两个变量的特点是不需要给它们赋值，在不同的上下文中它们自动取不同的值。常用的特殊变量有：
• $@，表示规则中的目标。

• $<，表示规则中的第一个条件。

• $?，表示规则中所有比目标新的条件，组成一个列表，以空格分隔。

• $^，表示规则中的所有条件，组成一个列表，以空格分隔。

例如前面写过的这条规则：

main: main.o stack.o maze.o
    gccmain.o stack.o maze.o -o main

可以改写成：

main: main.o stack.o maze.o
    gcc$^ -o $@

这样即使以后又往条件里添加了新的目标文件，编译命令也不需要修改，减少了出错的可能。

$?变量也很有用，有时候希望只对更新过的条件进行操作，例如有一个库文件libsome.a依赖于几个目标文件：

libsome.a: foo.o bar.o lose.owin.o
    arr libsome.a $?
    ranliblibsome.a

这样，只有更新过的目标文件才需要重新打包到libsome.a中，没更新过的目标文件原本已经在libsome.a中了，不必重新打包。

在上一节我们看到make的隐含规则数据库中用到了很多变量，有些变量没有定义（例如CFLAGS），有些变量定义了缺省值（例如CC），我们写Makefile时可以重新定义这些变量的值，也可以在缺省值的基础上追加。以下列举一些常用的变量，请读者体会其中的规律。

AR

静态库打包命令的名字，缺省值是ar。

ARFLAGS

静态库打包命令的选项，缺省值是rv。

AS

汇编器的名字，缺省值是as。

ASFLAGS

汇编器的选项，没有定义。

CC

C编译器的名字，缺省值是cc。

CFLAGS

C编译器的选项，没有定义。

CXX

C++编译器的名字，缺省值是g++。

CXXFLAGS

C++编译器的选项，没有定义。

CPP

C预处理器的名字，缺省值是$(CC) -E。

CPPFLAGS

C预处理器的选项，没有定义。

LD

链接器的名字，缺省值是ld。

LDFLAGS

链接器的选项，没有定义。

TARGET_ARCH

和目标平台相关的命令行选项，没有定义。

OUTPUT_OPTION

输出的命令行选项，缺省值是-o $@。

LINK.o

把.o文件链接在一起的命令行，缺省值是$(CC) $(LDFLAGS) $(TARGET_ARCH)。

LINK.c

把.c文件链接在一起的命令行，缺省值是$(CC) $(CFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH)。

LINK.cc

把.cc文件（C++源文件）链接在一起的命令行，缺省值是$(CXX) $(CXXFLAGS) $(CPPFLAGS) $(LDFLAGS) $(TARGET_ARCH)。

COMPILE.c

编译.c文件的命令行，缺省值是$(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c。

COMPILE.cc

编译.cc文件的命令行，缺省值是$(CXX) $(CXXFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c。

RM

删除命令的名字，缺省值是rm -f。

常用的make命令行选项：

-n选项只打印要执行的命令，而不会真的执行命令，这个选项有助于我们检查Makefile写得是否正确，由于Makefile不是顺序执行的，用这个选项可以先看看命令的执行顺序，确认无误了再真正执行命令。

-C选项可以切换到另一个目录执行那个目录下的Makefile，比如先退到上一级目录再执行我们的Makefile（假设我们的源代码都放在testmake目录下）：

$ cd ..
$ make -C testmake
make: Entering directory`/home/djkings/testmake'
cc    -c -o main.o main.c
cc    -c -o stack.o stack.c
cc    -c -o maze.o maze.c
gcc main.o stack.o maze.o -o main
make: Leaving directory`/home/djkings/testmake'

一些规模较大的项目会把不同的模块或子系统的源代码放在不同的子目录中，然后在每个子目录下都写一个该目录的Makefile，然后在一个总的Makefile中用make -C命令执行每个子目录下的Makefile。例如Linux内核源代码根目录下有Makefile，子目录fs、net等也有各自的Makefile，二级子目录fs/ramfs、net/ipv4等也有各自的Makefile。

在make命令行也可以用=或:=定义变量，如果这次编译我想加调试选项-g，但我不想每次编译都加-g选项，可以在命令行定义CFLAGS变量，而不必修改Makefile编译完了再改回来：

$ make CFLAGS=-g
cc -g   -c -o main.o main.c
cc -g   -c -o stack.o stack.c
cc -g   -c -o maze.o maze.c
gcc main.o stack.o maze.o -o main

如果在Makefile中也定义了CFLAGS变量，则命令行的值覆盖Makefile中的值。
————————————————
版权声明：本文为CSDN博主「尹成」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/itcastcpp/article/details/38081971