Makefile介绍

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

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

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

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

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

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

Makefile的规则

在讲述这个Makefile之前，还是让我们先来粗略地看一看Makefile的规则。

1
2
3
4
target ... : prerequisites ...
    recipe
    ...
    ...

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

prerequisites
生成该target所依赖的文件和/或target。

recipe
该target要执行的命令（任意的shell命令）。

这是一个文件的依赖关系，也就是说，target这一个或多个的目标文件依赖于prerequisites中的文件，其生成规则定义在command中。说白一点就是说:

1
prerequisites中如果有一个以上的文件比target文件要新的话,recipe所定义的命令就会被执行。

这就是makefile的规则，也就是makefile中最核心的内容。

说到底，makefile的东西就是这样一点，好像我的这篇文档也该结束了。呵呵。还不尽然，这是makefile 的主线和核心，但要写好一个makefile还不够，我会在后面一点一点地结合我的工作经验给你慢慢道来。内容还多着呢。:)

一个示例

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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.o files.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.o utils.o

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

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

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

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

make是如何工作的

在默认的方式下，也就是我们只输入 make 命令。那么，

  1. make会在当前目录下找名字叫“Makefile”或“makefile”的文件。

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

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

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

  5. 当然，你的C文件和头文件是存在的啦，于是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 会被重链接。

又一个示例（2024-5-20）

（爆笑）今天520，又是羡慕别人的一天。只有我这个…
有三个cpp文件，一个头文件。目录层级如下：

1
2
3
4
5
6
7
8
.
├── factorial.cpp
├── functional.h
├── main.cpp
├── Makefile
└── printhello.cpp

1 directory, 6 files

main.cpp如下：

1
2
3
4
5
6
7
8
9
10
#include <iostream>
#include "functional.h"
using namespace std;

int main(){
  printhello();
  cout << "This is main:" << '\n';
  cout << "The factorial of 5 is:" << factorial(5) << '\n';
  return 0;
}

factorial.cpp如下：

1
2
3
4
5
6
7
8
9
#include "functional.h"

int factorial(int n){
  if(n == 1){
    return 1;
  }else{
    return n * factorial(n-1);
  }
}

printhello.cpp如下：

1
2
3
4
5
6
#include <iostream>
#include "functional.h"

void printhello(){
  std::cout << "Hello World!" << '\n';
}

functional.h如下：

1
2
3
4
5
#ifndef FUNCTIONAL_H
#define FUNCTIONAL_H
void printhello();
int factorial(int n);
#endif // FUNCTIONAL_H

如果不适用make工具进行编译，那么只需在命令行执行 g++ main.cpp factorial.cpp printhello.cpp -o main一次性生成可执行文件。但是对于一个大项目来说，源文件和头文件往往百十个，每次编辑文件之后，需要执行很长的命令很费时，因此使用Makefile文件协助编译。

版本1

只是简单的将命令写到Makefile文件里面，并没有进行简化。如果需要增加cpp文件，则需手动在Makefile文件里面修改。

1
2
3
##VERSION 1
 hello: main.cpp factorial.cpp printhello.cpp 
	g++ -o hello main.cpp factorial.cpp printhello.cpp

版本2

这个版本才是真正的Makefile文件。利用依赖关系书写。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
##VERSION 2
CXX = g++
TARGET = hello
OBJ = main.o printhello.o factorial.o 

$(TARGET): $(OBJ)
	$(CXX) -o $(TARGET) $(OBJ)

main.o: main.cpp
	$(CXX) -c main.cpp

printhello.o: printhello.cpp
	$(CXX) -c printhello.cpp

factorial.o: factorial.cpp
	$(CXX) -c factorial.cpp

版本3

相比于版本2，将编译参数单独拿出作为一个变量CXXFLAGS,使用$@代替目标文件，使用$^代替所有的依赖文件，使用$<代理第一个依赖文件。
加入了clean目标，清空中间文件（所有的.o文件）和目标文件。.PYTHON: clean作用是避免和名字叫做clean的文件产生歧义，加入这行代码，检测到.PYTHON(伪目标)不存在，去找clean依赖，clean依赖不存在，执行rm -f *.o $(TARGET)命令。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
##VERSION 3
CXX = g++
TARGET = hello
OBJ = main.o printhello.o factorial.o 

CXXFLAGS = -c -Wall

$(TARGET): $(OBJ)
	$(CXX) -o $@ $^

%.o: %.cpp
	$(CXX) $(CXXFLAGS) $< -o $@

.PHONY: clean

clean:
	rm -f *.o $(TARGET)

版本4

较于版本3，不在一个一个书写所有的依赖文件，而是利用wildcard和patsubst函数生成所有的依赖文件（.o文件）。这对庞大项目很有用处。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# ##VERSION 4
CXX = g++
TARGET = hello
SRC = $(wildcard *.cpp) 
#　$(wildcard <PATTERN...>)
# 返回make工作下的所有.cpp以及.c文件  
# $(wildcard *.cpp *.c)
OBJ = $(patsubst %.cpp, %.o, $(SRC))
# $(patsubst  <pattern>,<replacement>,<text>)
# 把字符串“x.c.c bar.c”符合模式%.c的单词替换成%.o，返回“x.c.o bar.o”。
# $(patsubst %.c,%.o,x.c.c bar.c)

CXXFLAGS = -c -Wall

$(TARGET): $(OBJ)
	$(CXX) -o $@ $^
# 使用 $^ 表示所有的依赖文件，使用 $@ 表示目标文件名。

%.o: %.cpp
	$(CXX) $(CXXFLAGS) $< -o $@
# $< 表示第一个依赖文件，使用 $@ 表示目标文件。

.PHONY: clean

clean:
	rm -f *.o $(TARGET)

运行结果

第一次make：写好所有文件和Makefile文件，执行make，对所有文件编译链接等等，然后生成可执行文件。
第二次make: 第一次make之后没有对源文件做任何变化，因此显示已经是最新的。
第三次make：对factorial.cpp文件编辑之后，然后执行make。由于只改动了factorial.cpp文件，只对它单独进行编译，然后链接生成可执行文件。这是make的优势所在，只对改变的cpp文件编译，对引用修改的.h头文件的cpp文件进行编译。
make clean:删除所有.o和目标文件。