工程管理-Makefile

标签：txt 工程 管理 cc make Makefile world main hello

简介

              Linux的 make 程序用来自动化编译大型源码，很多时候，我们在Linux下编译安装软件，只需要 敲一个 make 就可以全自动完成，非常方便。

            make 能自动化完成这些工作，是因为项目提供了一个 Makefile 文件，它负责告诉 make ，应该 如何编译和链接程序。

              Makefile 相当于Java项目的 pom.xml ，Node工程的 package.json ，Rust项目的 Cargo.toml ， 不同之处在于， make 虽然最初是针对C语言开发，但它实际上并不限定C语言，而是可以应用到任意 项目，甚至不是编程语言。此外， make 主要用于Unix/Linux环境的自动化开发，掌握 Makefile 的写 法，可以更好地在Linux环境下做开发，也可以为后续开发Linux内核做好准备。

安装make【选修】

安装 make 时，因为 make 只能在Unix/Linux下运行（Unix/Linux自带make，可直接使用），所以，如 果使用Windows系统，我们要先想办法在Windows下跑一个Linux。

方法一：安装VirtualBox，然后下载Linux发行版安装盘，推荐Ubuntu 22.04，这样就可以在虚拟机中 运行Linux。

方法二：对于Windows 10/11，可以首先安装WSL（Windows Subsystem for Linux）：

然后，在Windows应用商店，搜索Ubuntu 22.04，直接安装后运行，Windows会弹出PowerShell的窗 口连接到Linux，在PowerShell中即可输入Linux命令，和SSH连接类似。

以Ubuntu为例，在Linux命令行下，用 apt 命令安装 make 以及GCC工具链：

$ sudo apt install build-essential

对于macOS系统，因为它的内核是BSD（一种Unix），所以也能直接跑 make ，推荐安装Homebrew， 然后通过Homebrew安装 make 以及GCC工具链：

$ brew install make gcc

安装完成后，可以输入 make -v 验证：

$ make -v
GNU Make 4.3
...

输入 gcc --version 验证GCC工具链：

$ gcc --version
gcc (Ubuntu ...) 11.4.0
...

这样，我们就成功地安装了 make ，以及GCC工具链。

Makefile基础

在Linux环境下，当我们输入 make 命令时，它就在当前目录查找一个名为 Makefile 的文件，然后，根 据这个文件定义的规则，自动化地执行任意命令，包括编译命令。

Makefile 这个单词，顾名思义，就是指如何生成文件。

我们举个例子：在当前目录下，有3个文本文件： a.txt ， b.txt 和 c.txt 。

现在，我们要合并 a.txt 与 b.txt ，生成中间文件 m.txt ，再用中间文件 m.txt 与 c.txt 合并，生 成最终的目标文件 x.txt ，整个逻辑如下图所示：

根据上述逻辑，我们来编写 Makefile 。

规则

Makefile 由若干条规则（Rule）构成，每一条规则指出一个目标文件（Target），若干依赖文件 （prerequisites），以及生成目标文件的命令。

例如，要生成 m.txt ，依赖 a.txt 与 b.txt ，规则如下：

# 目标文件: 依赖文件1 依赖文件2
m.txt: a.txt b.txt
cat a.txt b.txt > m.txt

一条规则的格式为 目标文件: 依赖文件1 依赖文件2 ... ，紧接着，以Tab开头的是命令，用来生成目标 文件。上述规则使用 cat 命令合并了 a.txt 与 b.txt ，并写入到 m.txt 。用什么方式生成目标文件 make 并不关心，因为命令完全是我们自己写的，可以是编译命令，也可以是 cp 、 mv 等任何命令。

以 # 开头的是注释，会被 make 命令忽略。

注意：Makefile的规则中，命令必须以Tab开头，不能是空格。

类似的，我们写出生成 x.txt 的规则如下：

x.txt: m.txt c.txt
cat m.txt c.txt > x.txt

由于 make 执行时，默认执行第一条规则，所以，我们把规则 x.txt 放到前面。完整的 Makefile 如 下：

x.txt: m.txt c.txt
cat m.txt c.txt > x.txt
m.txt: a.txt b.txt
cat a.txt b.txt > m.txt

在当前目录创建 a.txt 、 b.txt 和 c.txt ，输入一些内容，执行 make ：

$ make
cat a.txt b.txt > m.txt
cat m.txt c.txt > x.txt

make 默认执行第一条规则，也就是创建 x.txt ，但是由于 x.txt 依赖的文件 m.txt 不存在（另一个 依赖 c.txt 已存在），故需要先执行规则 m.txt 创建出 m.txt 文件，再执行规则 x.txt 。执行完成 后，当前目录下生成了两个文件 m.txt 和 x.txt 。

可见， Makefile 定义了一系列规则，每个规则在满足依赖文件的前提下执行命令，就能创建出一个目 标文件，这就是英文Make file的意思。

把默认执行的规则放第一条，其他规则的顺序是无关紧要的，因为 make 执行时自动判断依赖。

此外， make 会打印出执行的每一条命令，便于我们观察执行顺序以便调试。

如果我们再次运行 make ，输出如下：

$ make
make: `x.txt' is up to date.

make 检测到 x.txt 已经是最新版本，无需再次执行，因为 x.txt 的创建时间晚于它依赖的 m.txt 和 c.txt 的最后修改时间。

make使用文件的创建和修改时间来判断是否应该更新一个目标文件。

修改 c.txt 后，运行 make ，会触发 x.txt 的更新：

$ make
cat m.txt c.txt > x.txt

但并不会触发 m.txt 的更新，原因是 m.txt 的依赖 a.txt 与 b.txt 并未更新，所以， make 只会根据 Makefile 去执行那些必要的规则，并不会把所有规则都无脑执行一遍。

在编译大型程序时，全量编译往往需要几十分钟甚至几个小时。全量编译完成后，如果仅修改了几个 文件，再全部重新编译完全没有必要，用 Makefile 实现增量编译就十分节省时间。

当然，是否能正确地实现增量更新，取决于我们的规则写得对不对， make 本身并不会检查规则逻辑是 否正确。

伪目标

因为 m.txt 与 x.txt 都是自动生成的文件，所以，可以安全地删除。

删除时，我们也不希望手动删除，而是编写一个 clean 规则来删除它们：

clean:
rm -f m.txt
rm -f x.txt

clean 规则与我们前面编写的规则有所不同，它没有依赖文件，因此，要执行 clean ，必须用命令 ma ke clean ：

$ make clean
rm -f m.txt
rm -f x.txt

然而，在执行 clean 时，我们并没有创建一个名为 clean 的文件，所以，因为目标文件 clean 不存 在，每次运行 make clean ，都会执行这个规则的命令。

如果我们手动创建一个 clean 的文件，这个 clean 规则就不会执行了！

如果我们希望 make 把 clean 不要视为文件，可以添加一个标识：

.PHONY: clean
clean:
rm -f m.txt
rm -f x.txt

此时， clean 就不被视为一个文件，而是伪目标（Phony Target）。

大型项目通常会提供 clean 、 install 这些约定俗成的伪目标名称，方便用户快速执行特定任务。

一般来说，并不需要用 .PHONY 标识 clean 等约定俗成的伪目标名称，除非有人故意搞破坏，手动创 建名字叫 clean 的文件。

执行多条命令

一个规则可以有多条命令，例如：

cd:
pwd
cd ..
pwd

执行 cd 规则：

$ make cd
pwd
/home/ubuntu/makefile-tutorial/v1
cd ..
pwd
/home/ubuntu/makefile-tutorial/v1

观察输出，发现 cd .. 命令执行后，并未改变当前目录，两次输出的 pwd 是一样的，这是因为 make 针对每条命令，都会创建一个独立的Shell环境，类似 cd .. 这样的命令，并不会影响当前目录。

解决办法是把多条命令以 ; 分隔，写到一行：

cd_ok:
pwd; cd ..; pwd;

再执行 cd_ok 目标就得到了预期结果：

$ make cd_ok
pwd; cd ..; pwd
/home/ubuntu/makefile-tutorial/v1
/home/ubuntu/makefile-tutorial

可以使用 \ 把一行语句拆成多行，便于浏览：

cd_ok:
pwd; \
cd ..; \
pwd

另一种执行多条命令的语法是用 && ，它的好处是当某条命令失败时，后续命令不会继续执行：

cd_ok:
cd .. && pwd

控制打印

默认情况下， make 会打印出它执行的每一条命令。如果我们不想打印某一条命令，可以在命令前加 上 @ ，表示不打印命令（但是仍然会执行）：

no_output:
@echo 'not display'
echo 'will display'

执行结果如下：

$ make no_output
not display
echo 'will display'
will display

注意命令 echo 'not display' 本身没有打印，但命令仍然会执行，并且执行的结果仍然正常打印。

控制错误

make 在执行命令时，会检查每一条命令的返回值，如果返回错误（非0值），就会中断执行。 例如，不使用 -f 删除一个不存在的文件会报错：

has_error:
rm zzz.txt
echo 'ok'

执行上述目标，输出如下：

$ make has_error
rm zzz.txt
rm: zzz.txt: No such file or directory
make: *** [has_error] Error 1

由于命令 rm zzz.txt 报错，导致后面的命令 echo 'ok' 并不会执行， make 打印出错误，然后退出。 有些时候，我们想忽略错误，继续执行后续命令，可以在需要忽略错误的命令前加上 - ：

ignore_error:
-rm zzz.txt
echo 'ok'

执行上述目标，输出如下：

$ make ignore_error
rm zzz.txt
rm: zzz.txt: No such file or directory
make: [ignore_error] Error 1 (ignored)
echo 'ok'
ok

make 检测到 rm zzz.txt 报错，并打印错误，但显示 (ignored) ，然后继续执行后续命令。 对于执行可能出错，但不影响逻辑的命令，可以用 - 忽略。

源代码

效果

a.txt

A

b.txt

B

c.txt

C

Makefile

# 第一条规则是默认执行规则:
x.txt: m.txt c.txt
cat m.txt c.txt > x.txt
m.txt: a.txt b.txt
cat a.txt b.txt > m.txt
# clean 是一个伪目标:
clean:
rm -f m.txt
rm -f x.txt
# 多条命令是独立Shell执行的:
cd:
pwd
cd ..
pwd
# 用 ; 分隔多条命令在一个Shell执行:
cd_ok:
pwd; \
cd ..; \
pwd
# 用 @ 控制不打印命令本身:
no_output:
@echo 'not display'
echo 'will display'
# 执行出错后中断:
has_error:
rm zzz.txt
echo 'ok'
# 执行出错后忽略错误继续执行:
ignore_error:
-rm zzz.txt
echo 'ok'

编译C程序

C程序的编译通常分两步：

1. 将每个 .c 文件编译为 .o 文件；

2. 将所有 .o 文件链接为最终的可执行文件。 我们假设如下的一个C项目，包含 hello.c 、 hello.h 和 main.c 。

hello.c 内容如下：

#include <stdio.h>
int hello()
{
printf("hello, world!\n");
return 0;
}

hello.h 内容如下：

int hello();

main.c 内容如下：

#include <stdio.h>
#include "hello.h"
int main()
{
printf("start...\n");
hello();
printf("exit.\n");
return 0;
}

注意到 main.c 引用了头文件 hello.h 。我们很容易梳理出需要生成的文件，逻辑如下：

假定最终生成的可执行文件是 world.out ，中间步骤还需要生成 hello.o 和 main.o 两个文件。根据 上述依赖关系，我们可以很容易地写出 Makefile 如下：

# 生成可执行文件:
world.out: hello.o main.o
cc -o world.out hello.o main.o
# 编译 hello.c:
hello.o: hello.c
cc -c hello.c
# 编译 main.c:
main.o: main.c hello.h
cc -c main.c
clean:
rm -f *.o world.out

执行 make ，输出如下：

$ make
cc -c hello.c
cc -c main.c
cc -o world.out hello.o main.o

在当前目录下可以看到 hello.o 、 main.o 以及最终的可执行程序 world.out 。执行 world.out ：

$ ./world.out
start...
hello, world!
exit.

与我们预期相符。 修改 hello.c ，把输出改为 "hello, bob!\n" ，再执行 make ，观察输出：

$ make
cc -c hello.c
cc -o world.out hello.o main.o

仅重新编译了 hello.c ，并未编译 main.c 。由于 hello.o 已更新，所以，仍然要重新生成 world.ou t 。执行 world.out ：

$ ./world.out
start...
hello, bob!
exit.

与我们预期相符。

修改 hello.h ：

// int 变为 void:
void hello();

以及 hello.c ，再次执行 make ：

$ make
cc -c hello.c
cc -c main.c
cc -o world.out hello.o main.o

会触发 main.c 的编译，因为 main.c 依赖 hello.h 。 执行 make clean 会删除所有的 .o 文件，以及可执行文件 world.out ，再次执行 make 就会强制全量 编译：

$ make clean && make
rm -f *.o world.out
cc -c hello.c
cc -c main.c
cc -o world.out hello.o main.o

这个简单的 Makefile 使我们能自动化编译C程序，十分方便。 不过，随着越来越多的 .c 文件被添加进来，如何高效维护 Makefile 的规则？我们后面继续讲解。

源代码

效果图

hello.h

int hello();

hello.c

#include <stdio.h>
int hello()
{
printf("hello, world!\n");
return 0;
}

main.c

#include <stdio.h>
#include "hello.h"
int main()
{
printf("start...\n");
hello();
printf("exit.\n");
return 0;
}

Makefile

# 生成可执行文件:
world.out: hello.o main.o
cc -o world.out hello.o main.o
# 编译 hello.c:
hello.o: hello.c
cc -c hello.c
# 编译 main.c:
main.o: main.c hello.h
cc -c main.c
clean:
rm -f *.o world.out

使用隐式规则

我们仍然以上一节的C项目为例，当我们添加越来越多的 .c 文件时，就需要编写越来越多的规则来生 成 .o 文件。

实际上，有的同学可能发现了，即使我们把 .o 的规则删掉，也能正常编译：

# 只保留生成 world.out 的规则:
world.out: hello.o main.o
cc -o world.out hello.o main.o
clean:
rm -f *.o world.out

执行 make ，输出如下：

$ make
cc -c -o hello.o hello.c
cc -c -o main.o main.c
cc -o world.out hello.o main.o

我们没有定义 hello.o 和 main.o 的规则，为什么 make 也能正常创建这两个文件？ 因为 make 最初就是为了编译C程序而设计的，为了免去重复创建编译 .o 文件的规则， make 内置了隐 式规则（Implicit Rule），即遇到一个 xyz.o 时，如果没有找到对应的规则，就自动应用一个隐式规 则：

xyz.o: xyz.c
cc -c -o xyz.o xyz.c

make 针对C、C++、ASM、Fortran等程序内置了一系列隐式规则，可以参考官方手册查看。 对于C程序来说，使用隐式规则有一个潜在问题，那就是无法跟踪 .h 文件的修改。如果我们修改了 he llo.h 的定义，由于隐式规则 main.o: main.c 并不会跟踪 hello.h 的修改，导致 main.c 不会被重新 编译，这个问题我们放到后面解决。

源代码

效果图

Makefile

# 使用隐式规则 Implicit Rules
world.out: hello.o main.o
cc -o world.out hello.o main.o
# 自动创建 hello.o 文件的隐式规则:
# hello.o: hello.c
# cc -c -o hello.o hello.c
# 以及 main.o 文件的隐式规则:
# ...
clean:
rm -f *.o world.out

使用变量

当我们在 Makefile 中重复写很多文件名时，一来容易写错，二来如果要改名，要全部替换，费时费 力。 编程语言使用变量（Variable）来解决反复引用的问题，类似的，在 Makefile 中，也可以使用变量来 解决重复问题。

以上一节的 Makefile 为例：

world.out: hello.o main.o
cc -o world.out hello.o main.o
clean:
rm -f *.o world.out

编译的最终文件 world.out 重复出现了3次，因此，完全可以定义一个变量来替换它：

TARGET = world.out
$(TARGET): hello.o main.o
cc -o $(TARGET) hello.o main.o
clean:
rm -f *.o $(TARGET)

变量定义用 变量名 = 值 或者 变量名 := 值 ，通常变量名全大写。引用变量用 $(变量名) ，非常简单。 注意到 hello.o main.o 这个“列表”也重复了，我们也可以用变量来替换：

OBJS = hello.o main.o
TARGET = world.out
$(TARGET): $(OBJS)
cc -o $(TARGET) $(OBJS)
clean:
rm -f *.o $(TARGET)

如果有一种方式能让 make 自动生成 hello.o main.o 这个“列表”，就更好了。注意到每个 .o 文件是由 对应的 .c 文件编译产生的，因此，可以让 make 先获取 .c 文件列表，再替换，得到 .o 文件列表：

# $(wildcard *.c) 列出当前目录下的所有 .c 文件: hello.c main.c
# 用函数 patsubst 进行模式替换得到: hello.o main.o
OBJS = $(patsubst %.c,%.o,$(wildcard *.c))
TARGET = world.out
$(TARGET): $(OBJS)
cc -o $(TARGET) $(OBJS)
clean:
rm -f *.o $(TARGET)

这样，我们每添加一个 .c 文件，不需要修改 Makefile ，变量 OBJS 会自动更新。 思考：为什么我们不能直接定义 OBJS = $(wildcard *.o) 让 make 列出所有 .o 文件？

内置变量

我们还可以用变量 $(CC) 替换命令 cc ：

$(TARGET): $(OBJS)
$(CC) -o $(TARGET) $(OBJS)

没有定义变量 CC 也可以引用它，因为它是 make 的内置变量（Builtin Variables），表示C编译器的名 字，默认值是 cc ，我们也可以修改它，例如使用交叉编译时，指定编译器：

CC = riscv64-linux-gnu-gcc
...

自动变量

在 Makefile 中，经常可以看到 $@ 、 $< 这样的变量，这种变量称为自动变量（Automatic Variable），它们在一个规则中自动指向某个值。 例如， $@ 表示目标文件， $^ 表示所有依赖文件，因此，我们可以这么写：

world.out: hello.o main.o
cc -o $@ $^

在没有歧义时可以写 $@ ，也可以写 $(@) ，有歧义时必须用括号，例如 $(@D) 。

为了更好地调试，我们还可以把变量打印出来：

world.out: hello.o main.o
@echo '$$@ = $@' # 变量 $@ 表示target
@echo '$$< = $<' # 变量 $< 表示第一个依赖项
@echo '$$^ = $^' # 变量 $^ 表示所有依赖项
cc -o $@ $^

执行结果输出如下：

$@ = world.out
$< = hello.o
$^ = hello.o main.o
cc -o world.out hello.o main.o

源代码

效果图

Makefile

# 变量 Variables
# $(wildcard *.c) 列出当前目录下的所有 .c 文件: hello.c main.c
# 用函数 patsubst 进行模式替换得到: hello.o main.o
OBJS = $(patsubst %.c,%.o,$(wildcard *.c))
TARGET = world.out
$(TARGET): $(OBJS)
@echo '$$@ = $@' # 变量 $@ 表示target
@echo '$$< = $<' # 变量 $< 表示第一个依赖项
@echo '$$^ = $^' # 变量 $^ 表示所有依赖项
$(CC) -o $@ $^
clean:
rm -f *.o $(TARGET)

使用模式规则

前面我们讲了使用隐式规则可以让 make 在必要时自动创建 .o 文件的规则，但 make 的隐式规则的命 令是固定的，对于 xyz.o: xyz.c ，它实际上是：

$(CC) $(CFLAGS) -c -o $@ $<

能修改的只有变量 $(CC) 和 $(CFLAGS) 。如果要执行多条命令，使用隐式规则就不行了。 这时，我们可以自定义模式规则（Pattern Rules），它允许 make 匹配模式规则，如果匹配上了，就自 动创建一条模式规则。 我们修改上一节的 Makefile 如下：

OBJS = $(patsubst %.c,%.o,$(wildcard *.c))
TARGET = world.out
$(TARGET): $(OBJS)
cc -o $(TARGET) $(OBJS)
# 模式匹配规则：当make需要目标 xyz.o 时，自动生成一条 xyz.o: xyz.c 规则:
%.o: %.c
@echo 'compiling $<...'
cc -c -o $@ $<
clean:
rm -f *.o $(TARGET)

当 make 执行 world.out: hello.o main.o 时，发现没有 hello.o 文件，于是需要查找以 hello.o 为目 标的规则，结果匹配到模式规则 %.o: %.c ，于是 make 自动根据模式规则为我们动态创建了如下规 则：

hello.o: hello.c
@echo 'compiling $<...'
cc -c -o $@ $<

查找 main.o 也是类似的匹配过程，于是我们执行 make ，就可以用模式规则完成编译：

$ make
compiling hello.c...
cc -c -o hello.o hello.c
compiling main.c...
cc -c -o main.o main.c
cc -o world.out hello.o main.o

模式规则的命令完全由我们自己定义，因此，它比隐式规则更灵活。

但是，模式规则仍然没有解决修改 hello.h 头文件不会触发 main.c 重新编译的问题，这个依赖问题我 们继续放到后面解决。

最后注意，模式规则是按需生成，如果我们在当前目录创建一个 zzz.o 文件，因为 make 并不会在执 行过程中用到它，所以并不会自动生成 zzz.o: zzz.c 这个规则。

源代码

效果图

Makefile

OBJS = $(patsubst %.c,%.o,$(wildcard *.c))
TARGET = world.out
$(TARGET): $(OBJS)
cc -o $(TARGET) $(OBJS)
# 模式匹配规则：当make需要目标 xyz.o 时，自动生成一条 xyz.o: xyz.c 规则:
%.o: %.c
@echo 'compiling $<...'
cc -c -o $@ $<
clean:
rm -f *.o $(TARGET)

自动生成依赖

前面我们讲了隐式规则和模式规则，这两种规则都可以解决自动把 .c 文件编译成 .o 文件，但都无法 解决 .c 文件依赖 .h 文件的问题。 因为一个 .c 文件依赖哪个 .h 文件必须要分析文件内容才能确定，没有一个简单的文件名映射规则。 但是，要识别出 .c 文件的头文件依赖，可以用GCC提供的 -MM 参数：

$ cc -MM main.c
main.o: main.c hello.h

上述输出告诉我们，编译 main.o 依赖 main.c 和 hello.h 两个文件。 因此，我们可以利用GCC的这个功能，对每个 .c 文件都生成一个依赖项，通常我们把它保存到 .d 文 件中，再用 include 引入到 Makefile ，就相当于自动化完成了每个 .c 文件的精准依赖。 我们改写上一节的 Makefile 如下：

# 列出所有 .c 文件:
SRCS = $(wildcard *.c)
# 根据SRCS生成 .o 文件列表:
OBJS = $(SRCS:.c=.o)
# 根据SRCS生成 .d 文件列表:
DEPS = $(SRCS:.c=.d)
TARGET = world.out
# 默认目标:
$(TARGET): $(OBJS)
$(CC) -o $@ $^
# xyz.d 的规则由 xyz.c 生成:
%.d: %.c
rm -f $@; \
$(CC) -MM $< >[email protected]; \
sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < [email protected] > $@; \
rm -f [email protected]
# 模式规则:
%.o: %.c
$(CC) -c -o $@ $<
clean:
rm -rf *.o *.d $(TARGET)
# 引入所有 .d 文件:
include $(DEPS)

变量 $(SRCS) 通过扫描目录可以确定为 hello.c main.c ，因此，变量 $(OBJS) 赋值为 hello.o main. o ，变量 $(DEPS) 赋值为 hello.d main.d 。

通过 include $(DEPS) 我们引入 hello.d 和 main.d 文件，但是这两个文件一开始并不存在，不过， make 通过模式规则匹配到 %.d: %.c ，这就给了我们一个机会，在这个模式规则内部，用 cc -MM 命 令外加 sed 把 .d 文件创建出来。

运行 make ，首次输出如下：

$ make
Makefile:31: hello.d: No such file or directory
Makefile:31: main.d: No such file or directory
rm -f main.d; \
cc -MM main.c >main.d.tmp; \
sed 's,\(main\)\.o[ :]*,\1.o main.d : ,g' < main.d.tmp > main.d; \
rm -f main.d.tmp
rm -f hello.d; \
cc -MM hello.c >hello.d.tmp; \
sed 's,\(hello\)\.o[ :]*,\1.o hello.d : ,g' < hello.d.tmp > hello.d; \
rm -f hello.d.tmp
cc -c -o hello.o hello.c
cc -c -o main.o main.c
cc -o world.out hello.o main.o

make 会提示找不到 hello.d 和 main.d ，不过随后自动创建出 hello.d 和 main.d 。 hello.d 内容如 下：

hello.o hello.d : hello.c

上述规则有两个目标文件，实际上相当于如下两条规则：

hello.o : hello.c
hello.d : hello.c

因此， main.o 依赖于 main.c 和 hello.h ，这个依赖关系就和我们手动指定的一致。 改动 hello.h ，再次运行 make ，可以触发 main.c 的编译：

$ make
rm -f main.d; \
cc -MM main.c >main.d.tmp; \
sed 's,\(main\)\.o[ :]*,\1.o main.d : ,g' < main.d.tmp > main.d; \
rm -f main.d.tmp
cc -c -o main.o main.c
cc -o world.out hello.o main.o

在实际项目中，对每个 .c 文件都可以生成一个对应的 .d 文件表示依赖关系，再通过 include 引入 到 Makefile ，同时又能让 make 自动更新 .d 文件，有点蛋生鸡和鸡生蛋的关系，不过，这种机制能 正常工作，除了 .d 文件不存在时会打印错误，有强迫症的同学肯定感觉不满意，这个问题我们后面解 决。

小结

利用GCC生成 .d 文件，再用 include 引入 Makefile ，可解决一个 .c 文件应该如何正确触发编译的 问题。

源代码

效果图

Makefile

# 列出所有 .c 文件:
SRCS = $(wildcard *.c)
# 根据SRCS生成 .o 文件列表:
OBJS = $(SRCS:.c=.o)
# 根据SRCS生成 .d 文件列表:
DEPS = $(SRCS:.c=.d)
TARGET = world.out
# 默认目标:
$(TARGET): $(OBJS)
$(CC) -o $@ $^
# xyz.d 的规则由 xyz.c 生成:
%.d: %.c
rm -f $@; \
$(CC) -MM $< >[email protected]; \
sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < [email protected] > $@; \
rm -f [email protected]
# 模式规则:
%.o: %.c
$(CC) -c -o $@ $<
clean:
rm -rf *.o *.d $(TARGET)
# 引入所有 .d 文件:
include $(DEPS)

完善Makefile

上一节我们解决了自动生成依赖的问题，这一节我们对项目目录进行整理，把所有源码放入 src 目 录，所有编译生成的文件放入 build 目录：

<project>
├── Makefile
├── build
└── src
├── hello.c
├── hello.h
└── main.c

整理 Makefile ，内容如下：

SRC_DIR = ./src
BUILD_DIR = ./build
TARGET = $(BUILD_DIR)/world.out
CC = cc
CFLAGS = -Wall
# ./src/*.c
SRCS = $(shell find $(SRC_DIR) -name '*.c')
# ./src/*.c => ./build/*.o
OBJS = $(patsubst $(SRC_DIR)/%.c,$(BUILD_DIR)/%.o,$(SRCS))
# ./src/*.c => ./build/*.d
DEPS = $(patsubst $(SRC_DIR)/%.c,$(BUILD_DIR)/%.d,$(SRCS))
# 默认目标:
all: $(TARGET)
# build/xyz.d 的规则由 src/xyz.c 生成:
$(BUILD_DIR)/%.d: $(SRC_DIR)/%.c
@mkdir -p $(dir $@); \
rm -f $@; \
$(CC) -MM $< >[email protected]; \
sed 's,\($*\)\.o[ :]*,$(BUILD_DIR)/\1.o $@ : ,g' < [email protected] > $@; \
rm -f [email protected]
# build/xyz.o 的规则由 src/xyz.c 生成:
$(BUILD_DIR)/%.o: $(SRC_DIR)/%.c
@mkdir -p $(dir $@)
$(CC) $(CFLAGS) -c -o $@ $<
# 链接:
$(TARGET): $(OBJS)
@echo "buiding $@..."
@mkdir -p $(dir $@)
$(CC) -o $(TARGET) $(OBJS)
# 清理 build 目录:
clean:
@echo "clean..."
rm -rf $(BUILD_DIR)
# 引入所有 .d 文件:
-include $(DEPS)

这个 Makefile 定义了源码目录 SRC_DIR 、生成目录 BUILD_DIR ，以及其他变量，同时用 -include 消 除了 .d 文件不存在的错误。执行 make ，输出如下：

$ make
cc -Wall -c -o build/hello.o src/hello.c
cc -Wall -c -o build/main.o src/main.c
buiding build/world.out...
cc -o ./build/world.out ./build/hello.o ./build/main.o

可以说基本满足编译需求。

源代码

效果图

Makefile

SRC_DIR = ./src
BUILD_DIR = ./build
TARGET = $(BUILD_DIR)/world.out
CC = cc
CFLAGS = -Wall
# ./src/*.c
SRCS = $(shell find $(SRC_DIR) -name '*.c')
# ./src/*.c => ./build/*.o
OBJS = $(patsubst $(SRC_DIR)/%.c,$(BUILD_DIR)/%.o,$(SRCS))
# ./src/*.c => ./build/*.d
DEPS = $(patsubst $(SRC_DIR)/%.c,$(BUILD_DIR)/%.d,$(SRCS))
# 默认目标:
all: $(TARGET)
# build/xyz.d 的规则由 src/xyz.c 生成:
$(BUILD_DIR)/%.d: $(SRC_DIR)/%.c
@mkdir -p $(dir $@); \
rm -f $@; \
$(CC) -MM $< >[email protected]; \
sed 's,\($*\)\.o[ :]*,$(BUILD_DIR)/\1.o $@ : ,g' < [email protected] > $@; \
rm -f [email protected]
# build/xyz.o 的规则由 src/xyz.c 生成:
$(BUILD_DIR)/%.o: $(SRC_DIR)/%.c
@mkdir -p $(dir $@)
$(CC) $(CFLAGS) -c -o $@ $<
# 链接:
$(TARGET): $(OBJS)
@echo "buiding $@..."
@mkdir -p $(dir $@)
$(CC) -o $(TARGET) $(OBJS)
# 清理 build 目录:
clean:
@echo "clean..."
rm -rf $(BUILD_DIR)
# 引入所有 .d 文件:
-include $(DEPS)

标签：txt,工程,管理,cc,make,Makefile,world,main,hello
From： https://blog.csdn.net/m0_74916669/article/details/141931324