编程

Appearance

苏木2026-03-10
5842
22.4m

LV001-Makefile简介 ​

一、 Make 是什么？ ​

在一个大型工程项目中，我们一定会希望有工具自动识别修改的文件，而且不需要输入冗长的命令，就可以进行编译链接等操作，像 keil 就有，一键编译，不需要像在 Linux 中一样，使用 gcc 曲边义链接各个文件，于是 Make 工程管理器应运而生。

  • Make 可以自动识别文件时间戳，只处理修改的文件，从而避免完全编译，减少编译的工作量。
  • Make 动作的依据是 makefile 文件，这也是 Make 的唯一配置文件。

也可能会有不同的make工具，例如GNU的make和VC的nmake、BCB的 make，但是大多数情况下接触的还是GNU的make。

二、 Makefile 是什么？ ​

1. Makefile 简介 ​

Makefile 可以简单的认为是一个工程文件的编译规则，描述了整个工程的编译和链接等规则。其中包含需要编译的文件和不需要编译的文件，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重建等。编译整个工程需要涉及到的，都可以在 Makefile 中进行描述。从而避免每次都手动输入一堆源文件和参数。

那么为什么要使用 Makefile 文件呢？我自己在 Linux 中使用 C 语言 开发，我直接用 gcc 命令编译不行吗？当然可以，说白了， Makefile 其实就是这些编译命令的集合，那不使用 Makefile 会有哪些可能的问题呢？

一般来说，在 Linux 中进行 C 语言 开发，我们编译文件的编译命令如下：

shell
gcc -o outfile name1.c name2.c ...

其中 outfile 要生成的可执行程序的名字， nameN.c 是源文件的名字。

（1）链接库

如果 name1.c 用到了数学计算库 math 中的函数，我们得手动添加参数 -Im ； name5.c 使用到了线程，我们需要去手动添加参数 -lpthread 。

这个时候如果有大量的源文件，都涉及了第三方库的话，编译的时候命令就会很长，并且在编译的时候我们可能会涉及到文件链接的顺序问题，这个时候我们怎么办，写一份文档倒是很不错的办法，但是还是需要 CV 大法来粘贴命令不是。

（2）大工程

如果我们一个完整的工程项目，免不了要去修改工程项目的源文件，每次修改后都要去重新编译。一个大的工程项目可不仅仅只有几个源文件，多的甚至可能有成百上千个。例如一个内核，或者是一个软件的源码包。

但是如果写了 Makefile 文件的话， make 命令只会编译我们修改过的文件，没有修改的文件不用重新编译，也极大的解决了我们耗费时间的问题。

在 Windows 下的一些集成开发环境（例如 IAR、Keil 等）已经内置了 Makefile ，或者说会自动生成 Makefile ，所以我们不用去手动编写。但是 Linux 中却不能这样，需要我们去手动的完成这项工作。

2. 文件名 ​

2.1 默认文件名 ​

Make 命令在执行时会查找特定的 Makefile 文件，默认情况下会按照以下顺序搜索：

优先级文件名说明
1GNUmakefileGNU make 特有的文件名
2makefile常用的小写文件名
3Makefile推荐使用的全大写文件名

Make 会按优先级顺序查找，找到第一个存在的文件后就停止搜索。在实际项目中，通常推荐使用 Makefile（全大写），因为：

  • 在 Linux 系统中，全大写的文件名更醒目，便于识别
  • 与其他配置文件（如 README、CHANGELOG）风格一致

2.2 指定特定文件 ​

除了使用默认的 Makefile 名称，我们还可以通过 -f 参数指定特定的 Makefile 文件：

shell
# 使用指定的 makefile 文件
make -f mybuild.mk

# 指定其他目录下的 makefile
make -f ../builds/project.mk

# 也可以使用 --file 参数
make --file custom.makefile

当使用 -f 参数指定文件后，make 不会再自动查找默认的 Makefile 文件。使用 -f 参数指定 Makefile 时，对文件名和后缀名没有特殊要求，可以任意命名：

示例说明
make -f Makefile使用标准的 Makefile
make -f build.mk使用 .mk 后缀（常见做法）
make -f makefile使用小写文件名
make -f GNUmakefileGNU make 特定文件名
make -f my_build_script无后缀的文件名
make -f Makefile.linux带额外后缀的文件名
make -f 01-Makefile数字开头的文件名
  • Makefile 可以使用任意合法的文件名
  • 后缀名可以是 .mk、.makefile、.mak 等，也可以没有后缀
  • 文件名可以包含数字、字母、下划线、连字符等字符
  • 只要文件内容符合 Makefile 语法规范即可

2.3 多个 Makefile ​

如果项目比较复杂，可以将不同的构建规则拆分到多个 Makefile 文件中，然后在主 Makefile 中使用 include 指令来包含它们：

makefile
# 包含其他 Makefile 文件
include Makefile.rules
include Makefile.targets

这种模块化的方式可以让 Makefile 更容易维护。

3. 第一个 makefile ​

接下来，先不管 Makefile 文件内容，只是写一下基本使用方式。

3.1 编写源文件 ​

c
#include <stdio.h>

int main(int argc, const char *argv[])
{
	printf("Hello, World!\n");
	
	return 0;
}

3.2 编写 Makefile ​

  • （1）创建一个 Makefile 文件
shell
vim Makefile

然后在命令模式下执行 : w ，将文件写入硬盘保存起来。

  • （2）编写 Makefile 文件内容

在文件中添加以下内容：

makefile
main: main.o
	gcc main.o -o main
main.o: main.c
	gcc -c  main.c -o main.o

【说明】 main 和 main.o 都被称之为规则的目标，后边会再详细说明。

3.3 安装 make ​

刚开始使用的时候可能会提醒没有安装 make 命令，如果有这样的情况的话，按提示安装即可。

shell
sudo apt-get update
sudo apt-get install ubuntu-make
sudo apt-get install make

可以通过以下命令查看 make 版本，也可以检测是否安装成功：

shell
make --version

3.4 运行 Makefile ​

在 Makefile 文件所在目录执行以下命令：

shell
make

这个时候就可以以发现，目录下多了一个 main 和一个 main.o 的文件，这就是生成的文件，在终端中执行 ./main 可以看到打印出以下内容：

shell
Hello, World!

这与我们之前使用 gcc 命令编译产生的可执行文件是一致的。

3.5 指定目标 ​

接下来我们尝试在 make 后边加上 main 和 main.o 会有什么现象。我们先手动删除刚才生成的 main 和 main.o 文件，然后在终端执行：

shell
make main

然后我们发现，在目录下重新生成了 main 和 main.o 文件，也就是说 Makefile 文件内的两条命令都执行了。然后我们再次删除刚才生成的两个文件，在终端运行：

shell
make main.o

这次会发现，仅仅生成了 main.o 文件，这说明， make 后边跟上目标名称，可以运行单个规则，但是加的是最终目标名称的话，是所有规则都运行（什么是规则？什么是最终目标？请看下一节）。

三、 Makefile 基础 ​

1. 文件内容 ​

一般来说， Makefile 文件主要包含有五个部分：

显式规则 显式规则说明了，如何生成一个或多的的目标文件。这是由 Makefile 的书写者明显指出，要生成的文件，文件的依赖文件，生成的命令。
隐晦规则 由于我们的 make 命名有自动推导的功能，所以隐晦的规则可以让我们比较粗糙地简略地书写 Makefile，这是由 make 命令所支持的。
变量定义 在 Makefile 中我们要定义一系列的变量，变量一般都是字符串，这个有点像 C 语言中的宏，当 Makefile 被执行时，其中的变量都会被扩展到相应的引用位置上。
文件指示 其包括了三个部分，一个是在一个 Makefile 中引用另一个 Makefile，就像 C 语言中的 include 一样；另一个是指根据某些情况指定 Makefile 中的有效部分，就像 C 语言中的预编译 #if 一样；还有就是定义一个多行的命令。有关这一部分的内容，我会在后续的部分中讲述。
注释 Makefile 中只有行注释，和 UNIX 的 Shell 脚本一样，其注释是用“#”字符。如果要在我们的 Makefile 中使用“#”字符，可以用反斜框进行转义，如：“\#”。

2. 书写规则 ​

2.1 基本格式 ​

Makefile 文件描述的是文件编译的相关规则，它的规则主要是两个部分组成，分别是 依赖的关系 和 执行的命令，其结构如下所示：

makefile
target: dependency_files
<Tab>[option]command

# 或者写成一行
target: dependency_files ; command

【注意】两边的空格总是会被 make 自动删除。

target 规则的目标，可以是 Object File（一般称它为中间文件），也可以是可执行文件，还可以是一个标签
dependency_files 是目标的依赖文件，就是要生成 target 需要的文件或者是目标。可以是多个，也可以是没有
< Tab> 表示命令的开始(命令前边一定要有 Tab)
option @ 输出的信息中，不要显示此行命令（make 执行过程中，默认会显示所执行的命令）。
- 忽略当前此行命令执行时候所遇到的错误。如果不忽略，make 在执行命令的时候，如果遇到 error，会退出执行的，加上减号后，即便此行命令执行中出错，比如删除一个不存在的文件等，那么也会继续执行 make。
command make 需要执行的命令（任意的 shell 命令）。可以有多条命令，每一条命令占一行

（1）如果说，命令前边没有用 Tab ，或者用了几个空格代替，那就有可能会报以下错误：

shell
Makefile:8: *** 遗漏分隔符 (null)。 停止。

（2）如果命令太长，可以使用反斜杠（\ ）作为换行符。make 对一行上有多少个字符没有限制。规则 告诉 make 两件事，文件的依赖关系和如何生成目标文件。

（3）一般来说，make 会以 UNIX 的标准 Shell，也就是 /bin/sh 来执行命令。

2.2 使用实例 ​

这里主要是写一个多文件编译的实例，单文件编译的实例在《第一个 Makefile》笔记中已经写了一个。

2.2.1 测试文件 ​

各文件所在目录的结构如下：

c
.
├── main.c
├── Makefile
├── test1.c
├── test2.c
└── test.h
  • main.c
c
#include <stdio.h>
#include "test.h"

int main(int argc, const char *argv[])
{
	printf("This is main file!\n");
	test1Fun();
	test2Fun();
	return 0;
}
  • test1.c
c
#include <stdio.h>

void test1Fun()
{
    printf("This is test1.c file\n");
}
  • test2.c
c
#include <stdio.h>

void test2Fun()
{
    printf("This is test2.c file\n");
}
  • test.h
c
void test1Fun();
void test2Fun();
2.2.2 Makefile ​

在 Makefile 中我们需要指明每个目标的依赖文件。

makefile
OBJ = main.o test1.o test2.o

main: ${OBJ}
	gcc $(OBJ) -o main

main.o: main.c
	gcc -c main.c -o main.o

test1.o: test1.c
	gcc -c test1.c -o test1.o

test2.o: test2.c
	gcc -c test2.c -o test2.o

.PHONY: clean
clean:
	rm -rf *.o main

然后我们在终端执行 make 命令，会发现有如下信息输出：

shell
gcc -c main.c -o main.o
gcc -c test1.c -o test1.o
gcc -c test2.c -o test2.o
gcc main.o test1.o test2.o -o main

我们执行生成的 main 可执行文件,，在终端执行 ./main ，会发现有如下信息打印：

shell
This is main file!
This is test1.c file
This is test2.c file

3. 工作流程 ​

3.1 工作流程分析 ​

那么 Makefile 是怎样工作的呢？当我们在执行 make 命令的时候， make 就会去当前目录下找要执行的编译规则，也就是 Makefile 文件。

编写 Makefile 的时可以使用的文件的名称 GNUmakefile 、 makefile 、 Makefile ， make 执行时会去寻找 Makefile 文件，找文件也是按照这个顺序进行的（一般推荐使用 Makefile ）。执行 make 命令后，当不存在 Makefile 文件时，将会出现以下提示：

shell
make: *** 没有指明目标并且找不到 makefile。 停止。

接下来我们就来分析一下， Makefile 文件工作的流程。以下边文件内容为例：

makefile
main : main.o test1.o test2.o
	gcc main.o test1.o test2.o -o main
main.o : main.c test.h
	gcc -c main.c -o main.o
test1.o : test1.c test.h
	gcc -c test1.c -o test1.o
test2.o : test2.c test.h
	gcc -c test2.c -o test2.o

在编译项目文件的时候，默认情况下， make 执行的是 Makefile 中的 第一规则（ Makefile 中出现的第一个依赖关系），这个规则的 第一目标 称之为 最终目标 或者是 终极目标。

  • 执行 make ，确定最终目标

当我们在终端输入 make 命令后， make 命令会读取当前目录下的 Makefile 文件，并将 Makefile 文件中的第一个目标作为其执行的最终目标，也就是生成 main 可执行文件。

  • 处理最终目标的规则

接下来，开始处理 第一个规则，也就是最终目标所在的规则，在本例中就是：

makefile
main : main.o test1.o test2.o
	gcc main.o test1.o test2.o -o main

这个规则描述了最终要生成的 main 文件的依赖关系（需要哪些文件），并定义了链接 .o 文件生成 main 文件的命令。但是这是第一个规则， main.o 、 test1.o 和 test2.o 文件可能还没有生成啊，怎么办呢？其实在处理第一个规则所定义的命令之前， make 会先处理最终目标 main 的所有的依赖文件（也就是例子中的这些 .o 文件）的更新规则（就是后边以这些 .o 文件为目标的规则）

  • 处理最终目标的依赖文件

对这些 .o 文件为目标的规则处理有下列三种情况：

（1）目标 .o 文件不存在，使用其描述规则创建相应的 .o 文件。

（2）目标 .o 文件存在，目标 .o 文件所依赖的 .c 源文件和 .h 文件中的任何一个比目标 .o 文件 更新（就是说在上一次 make 之后被修改过），那么就根据规则重新编译生成相应的 .o 文件。

（3）目标 .o 文件存在，目标 .o " 文件比它的任何一个依赖文件（ .c 源文件、 .h" 文件）更新（它的依赖文件在上一次 make 之后没有被修改），则什么也不做。

3.2 小结 ​

通过上面的更新规则我们可以了解到中间文件的作用，也就是编译时生成的 .o 文件。它们的作用是检查某个源文件是不是进行过修改，最终目标文件是不是需要重建。我们执行 make 命令时，只有修改过的源文件或者是不存在的目标文件会进行重建，而那些没有改变的文件不用重新编译，这样在很大程度上节省时间，提高编程效率。GNU 的 make 工作时的执行步骤如下：（想来其它的 make 也是类似）

  • (1) 读入所有的 Makefile。
  • (2) 读入被 include 的其它 Makefile 。
  • (3) 初始化文件中的变量。
  • (4) 推导隐晦规则，并分析所有规则。
  • (5) 为所有的目标文件创建依赖关系链。
  • (6) 根据依赖关系，决定哪些目标要重新生成。
  • (7) 执行生成命令。

(1)-(5) 步为第一个阶段， (6)-(7) 为第二个阶段。第一个阶段中，如果定义的变量被使用了，那么， make 会把其展开在使用的位置。但 make 并不会完全马上展开，如果变量出现在依赖关系的规则中，那么只有当这条依赖被决定要使用了，变量才会在其内部展开。

4. 清除过程文件 ​

但是，很多时候我们并不需要中间的 .o 文件啊，而且如果文件超级多的话，生成的文件都混合在一起，这样的文件夹看起来也太乱了吧，没关系，我们不是有个命令叫 rm 嘛，当然也可以用在 Makefile 中啦。格式如下：

makefile
.PHONY: clean
clean:
    rm -rf *.o main
.PHONY: clean 说明 clean 是伪目标（后边会解释）, 不是具体的文件。
*.o 是执行过程中产生的中间文件
main 是最终生成的目标文件（也是第一个规则生成的目标文件）

clean 的书写规则与上边一致，但是它后边是没有依赖文件的，不是具体的文件。不会与第一个目标文件相关联，所以我们在执行 make 的时候也不会执行下面的命令。但是需要指明这是一个伪目标，后边会解释。然后我们在终端执行以下命令就可以删除所有的中间文件了：

shell
make clean

5. 书写命令 ​

每条规则中的命令和操作系统 Shell 的命令行是一致的。make 会一按顺序一条一条的执行命令，每 条命令的开头必须以 Tab 键开头，除非，命令是紧跟在依赖规则后面的分号后的。在命令行之间中的空 格或是空行会被忽略，但是如果该空格或空行是以 Tab 键开头的，那么 make 会认为其是一个空命令。

我们在 UNIX 下可能会使用不同的 Shell，但是 make 的命令默认是被 /bin/sh ——UNIX 的标准 Shell 解释执行的。除非我们特别指定一个其它的 Shell。Makefile 中，# 是注释符，很像 C/C++ 中的 // ，其后的本行字符都被注释。

5.1 显示命令 ​

通常，make 会把其要执行的命令行在命令执行前输出到屏幕上。当我们用 @ 字符在命令行前，那么， 这个命令将不被 make 显示出来，最具代表性的例子是，我们用这个功能来向屏幕显示一些信息。如:

makefile
@echo 正在编译 XXX 模块......

当 make 执行时，会输出“正在编译 XXX 模块……”字串，但不会输出命令，如果没有“@”，那 么，make 将输出:

shell
echo 正在编译 XXX 模块......
正在编译 XXX 模块......

如果 make 执行时，带入 make 参数 -n 或 --just-print ，那么其只是显示命令，但不会执行命令， 这个功能很有利于我们调试我们的 Makefile，看看我们书写的命令是执行起来是什么样子的或是什么顺序的。

而 make 参数 -s 或 --silent 或 --quiet 则是全面禁止命令的显示。

5.2 命令执行 ​

当依赖目标新于目标时，也就是当规则的目标需要被更新时，make 会一条一条的执行其后的命令。 需要注意的是，如果要让上一条命令的结果应用在下一条命令时，应该使用分号分隔这两条命令。比如第一条命令是 cd 命令，我们希望第二条命令得在 cd 之后的基础上运行，那么就不能把这两条命 令写在两行上，而应该把这两条命令写在一行上，用分号分隔。如：

makefile
# 示例一
exec1:
	cd /home/hchen
	pwd

# 示例二
exec2:
	cd /home/hchen; pwd

当我们执行 make exec1 时，第一个例子中的 cd 没有作用，pwd 会打印出当前的 Makefile 目录，而 第二个例子中，cd 就起作用了，pwd 会打印出“/home/hchen”。

make 一般是使用环境变量 SHELL 中所定义的系统 Shell 来执行命令，默认情况下使用 UNIX 的标 准 Shell——/bin/sh 来执行命令。但在 MS-DOS 下有点特殊，因为 MS-DOS 下没有 SHELL 环境变量， 当然我们也可以指定。如果指定了 UNIX 风格的目录形式，首先，make 会在 SHELL 所指定的路径中找 寻命令解释器，如果找不到，其会在当前盘符中的当前目录中寻找，如果再找不到，其会在 PATH 环境 变量中所定义的所有路径中寻找。MS-DOS 中，如果定义的命令解释器没有找到，其会给我们的命令解释器加上诸如 .exe 、.com 、.bat 、.sh 等后缀。

5.3 命令出错 ​

每当命令运行完后，make 会检测每个命令的返回码，如果命令返回成功，那么 make 会执行下一条 命令，当规则中所有的命令成功返回后，这个规则就算是成功完成了。如果一个规则中的某个命令出错 了（命令退出码非零），那么 make 就会终止执行当前规则，这将有可能终止所有规则的执行。

有些时候，命令的出错并不表示就是错误的。例如 mkdir 命令，我们一定需要建立一个目录，如果 目录不存在，那么 mkdir 就成功执行，万事大吉，如果目录存在，那么就出错了。我们之所以使用 mkdir 的意思就是一定要有这样的一个目录，于是我们就不希望 mkdir 出错而终止规则的运行。

为了做到这一点，忽略命令的出错，我们可以在 Makefile 的命令行前加一个减号 - （在 Tab 键之 后），标记为不管命令出不出错都认为是成功的。如：

makefile
clean:
	-rm -f *.o

还有一个全局的办法是，给 make 加上 -i 或是 --ignore-errors 参数，那么，Makefile 中所有命 令都会忽略错误。而如果一个规则是以 .IGNORE 作为目标的，那么这个规则中的所有命令将会忽略错误。 这些是不同级别的防止命令出错的方法，可以根据我们的不同喜欢设置。

还有一个要提一下的 make 的参数的是 -k 或是 --keep-going ，这个参数的意思是，如果某规则中 的命令出错了，那么就终止该规则的执行，但继续执行其它规则。

参考资料：

跟我一起写Makefile — 跟我一起写Makefile 1.0 文档