Makefile基础

Make的工作主要依赖于一个叫Makefile的文件。Makefile文件描述了整个程序的编译、链接等规则。

Makefile格式

all: hello
hello: main.o function1.o function2.o
        g++ main.o function1.o function2.o -o hello
main.o: main.cpp
        g++ -c main.cpp
function1.o: function1.cpp
        g++ -c function1.cpp
function2.o: function2.cpp
        g++ -c function2.cpp

clean:
        rm -rf *.o hello

Makefile构成-伪目标

Makefile把那些只包含命令，没有任何依赖的目标称为“伪目标”.

# Makefile (井号为注释)
all:
        g++ -o hello main.cpp function1.cpp function2.cpp
clean:
        rm -rf *.o hello

其中 all 、clean的术语为 target，我也可以随意指定一个名字，例如 abc，真正执行编译的是它下面缩进行的命令。

clean 表示清除编译结果，它下方就是普通的命令行删除文件命令。命令行输入 make 将默认执行第一个 target （即 all）下方的命令；如要执行清理操作，则需要输入 make clean，指定执行 clean 这个 target 下方的命令。

Makefile构成-最终目标

Make led.o //在Makefile查找目标为led.o的规则并执行。
Make //默认执行第一条规则，第一条规则的依赖文件找不到的话，自动执行目标文件为第一条规则的依赖文件的规则。
用户自定义的变量

Makefile构成-自定义变量

obj=func1.o func2.o
app1: app1.o $(obj)
    gcc app1.o $(obj) -o app1
app2: app2.o $(obj)
    gcc app2.o $(obj) -o app2

变量的基本赋值
知道了如何定义，下面我们来说一下 Makefile 的变量的四种基本赋值方式：

• 简单赋值 ( := ) 编程语言中常规理解的赋值方式，只对当前语句的变量有效。
• 递归赋值 ( = ) 赋值语句可能影响多个变量，所有目标变量相关的其他变量都受影响。
• 条件赋值 ( ?= ) 如果变量未定义，则使用符号中的值定义变量。如果该变量已经赋值，则该赋值语句无效。
• 追加赋值 ( += ) 原变量用空格隔开的方式追加一个新值。

系统定义好的变量

$^：代表所有的依赖文件

$@：代表目标

$<：代表第一个依赖文件

$% 当目标文件是一个静态库文件时，代表静态库的一个成员名。

$? 所有比目标文件更新的依赖文件列表，空格分隔。如果目标文件时静态库文件，代表的是库文件（.o 文件）。

Makefile构成-通配符

%.o //表示所有以.o结尾的文件

%.c //表示所有以.c结尾的文件

%.s //表示所有以.s结尾的文件

通配符	使用说明
*	匹配0个或者是任意个字符
？	匹配任意一个字符
[]	我们可以指定匹配的字符放在 “[]” 中

实例1

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

实例2

test:*.c
    gcc -o $@ $^

这个实例可以说明我们的通配符不仅可以使用在规则的命令中，还可以使用在规则中。用来表示生所有的以 .c 结尾的文件

Makefile的工流程

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

在 shell 命令行执行的 make 命令，就可以得到可执行文件 main 和中间文件 main.o、test1.o 和 test2.o，main 就是我们要生成的最终文件。通过 Makefile 我们可以发现，目标 main"在 Makefile 中是第一个目标，因此它就是 make 的终极目标，当修改过任何 C 文件后，执行 make 将会重建终极目标 main。

它的具体工作顺序是：当在 shell 提示符下输入 make 命令以后。 make 读取当前目录下的 Makefile 文件，并将 Makefile 文件中的第一个目标作为其执行的“终极目标”，开始处理第一个规则（终极目标所在的规则）。在我们的例子中，第一个规则就是目标 “main” 所在的规则。规则描述了 “main” 的依赖关系，并定义了链接 “.o” 文件生成目标 “main” 的命令；make 在执行这个规则所定义的命令之前，首先处理目标 “main” 的所有的依赖文件（例子中的那些 “.o” 文件）的更新规则（以这些 “.o” 文件为目标的规则）。

对这些 “.o” 文件为目标的规则处理有下列三种情况：
目标 “.o” 文件不存在，使用其描述规则创建它；
目标 “.o” 文件存在，目标 “.o” 文件所依赖的 “.c” 源文件 “.h” 文件中的任何一个比目标 “.o” 文件“更新”（在上一次 make 之后被修改）。则根据规则重新编译生成它；
目标 “.o” 文件存在，目标 “.o” 文件比它的任何一个依赖文件（".c" 源文件、".h" 文件）“更新”（它的依赖文件在上一次 make 之后没有被修改），则什么也不做。

通过上面的更新规则我们可以了解到中间文件的作用，也就是编译时生成的 “.o” 文件。作用是检查某个源文件是不是进行过修改，最终目标文件是不是需要重建。我们执行 make 命令时，只有修改过的源文件或者是不存在的目标文件会进行重建，而那些没有改变的文件不用重新编译，这样在很大程度上节省时间，提高编程效率。小的工程项目可能体会不到，项目工程文件越大，效果才越明显。

清除工作目录中的过程文件

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

其中 “*.o” 是执行过程中产生的中间文件，“test” 是最终生成的执行文件。我们可以看到 clean 是独立的，它只是一个伪目标，不是具体的文件。不会与第一个目标文件相关联，所以我们在执行 make 的时候也不会执行下面的命令。在shell 中执行 “make clean” 命令，编译时的中间文件和生成的最终目标文件都会被清除，方便我们下次的使用。

所谓的伪目标可以这样来理解，它并不会创建目标文件，只是想去执行这个目标下面的命令。

当文件夹中没有clean这个文件的时候，我们输入"make clean"能按照初衷执行，但是一旦文件夹中出现clean文件，我们再次输入"make clean"，由于这个规则没有任何依赖文件，所以目标被认为是最新的而不去执行规则所定义的命令。所以rm命令不会被执行。为了解决问题，我们将目标clean定义成伪目标。

目标文件搜索

常见的搜索的方法的主要有两种：一般搜索VPATH和选择搜索vpath。

VPATH 和 vpath 的区别：VPATH 是变量，更具体的说是环境变量，Makefile 中的一种特殊变量，使用时需要指定文件的路径；vpath 是关键字，按照模式搜索，也可以说成是选择搜索。搜索的时候不仅需要加上文件的路径，还需要加上相应限制的条件。

VPATH的使用
在 Makefile 中可以这样写：

VPATH := src

我们可以这样理解，把 src 的值赋值给变量 VPATH，所以在执行 make 的时候会从 src 目录下找我们需要的文件。

当存在多个路径的时候我们可以这样写：

VPATH := src car

或者是

VPATH := src:car

多个路径之间要使用空格或者是冒号隔开，表示在多个路径下搜索文件。搜索的顺序为我们书写时的顺序，拿上面的例子来说，我们应该先搜索 src 目录下的文件，再搜索 car 目录下的文件。

vpath的使用
学习了 VPATH的使用，我们再来了解一下关键字搜索 vpath 的使用，这种搜索方式一般被称作选择性搜索。使用上的区别我们可以这样理解：VPATH 是搜索路径下所有的文件，而 vpath 更像是添加了限制条件，会过滤出一部分再去寻找。

具体用法：

• vpath PATTERN DIRECTORIES
• vpath PATTERN
• vpath

( PATTERN：可以理解为要寻找的条件，DIRECTORIES：寻找的路径 )

首先是用法一，命令格式如下：

vpath test.c src

可以这样理解，在 src 路径下搜索文件 test.c。多路径的书写规则如下：

vpath test.c src car         或者是         vpath test.c src : car

多路径的用法其实和 VPATH 差不多，都是使用空格或者是冒号分隔开，搜索路径的顺序是先 src 目录，然后是 car 目录。

其次是用法二，命令格式如下：

vpath test.c

用法二的意思是清除符合文件 test.c 的搜索目录。

最后是用法三，命令格式如下：

vpath

vpath 单独使的意思是清除所有已被设置的文件搜索路径。

另外在使用 vpath 的时候，搜索的条件中可以包含模式字符“%”，这个符号的作用是匹配一个或者是多个字符，例如“%.c”表示搜索路径下所有的 .c 结尾的文件。如果搜索条件中没有包含“%" ，那么搜索的文件就是具体的文件名称。

实例

vpath %.c src
vpath %.h include
main:main.o list1.o list2.o
    gcc -o $@ $<
main.o:main.c
    gcc -o $@ $^
list1.o:list1.c list1.h
    gcc -o $@ $<
list2.o:list2.c list2.h
    gcc -o $@ $<

条件判断

关键字	功能
ifeq	判断参数是否不相等，相等为 true，不相等为 false。
ifneq	判断参数是否不相等，不相等为 true，相等为 false。
ifdef	判断是否有值，有值为 true，没有值为 false。
ifndef	判断是否有值，没有值为 true，有值为 false。

格式：

ifeq (ARG1, ARG2)
ifeq 'ARG1' 'ARG2'
ifeq "ARG1" "ARG2"
ifeq "ARG1" 'ARG2'
ifeq 'ARG1' "ARG2"

实例

libs_for_gcc= -lgnu
normal_libs=
foo:$(objects)
ifeq($(CC),gcc)
    $(CC) -o foo $(objects) $(libs_for_gcc)
else
    $(CC) -o foo $(objects) $(noemal_libs)
endif

include文件包含

当 make 读取到 “include” 关键字的时候，会暂停读取当前的 Makefile，而是去读 “include” 包含的文件，读取结束后再继读取当前的 Makefile 文件。

include <filenames>

-include <filename>

filenames 是 shell 支持的文件名（可以使用通配符表示的文件）。

这两种方式之间的区别：

• 使用 "include " ，make 在处理程序的时候，文件列表中的任意一个文件不存在的时候或者是没有规则去创建这个文件的时候，make 程序将会提示错误并保存退出。-
• 使用 "-include "，当包含的文件不存在或者是没有规则去创建它的时候，make 将会继续执行程序，只有真正由于不能完成终极目标重建的时候我们的程序才会提示错误保存退出。

Makefile使用技巧

注释：“#注释内容”
去回显：命令前加“@” 如果在命令前加了 @ 则不会输出到控制台了

wildcard

wildcard 用于获取符合特定规则的文件名，例如下面的代码：

SOURCE_DIR = . # 如果是当前目录，也可以不指定
SOURCE_FILE = $(wildcard $(SOURCE_DIR)/*.cpp)
target:
        @echo $(SOURCE_FILE)

make 后发现，输出的为当前目录下所有的 .cpp 文件：

./function1.cpp ./function2.cpp ./main.cpp

其中 @echo 前加 @是为了避免命令回显，上文中 make clean 调用了 rm -rf 会在 terminal 中输出这行命令，如果在 rm 前加了 @ 则不会输出了。

patsubst

patsubst 应该是 pattern substitution 的缩写。用它可以方便地将 .cpp 文件的后缀换成 .o。它的基本语法是：$(patsubst 原模式，目标模式，文件列表)。运行下面的示例：

SOURCES = main.cpp function1.cpp function2.cpp
OBJS = $(patsubst %.cpp, %.o, $(SOURCES))
target:
        @echo $(SOURCES)
        @echo $(OBJS)

输出的结果为：

main.cpp function1.cpp function2.cpp
main.o function1.o function2.o

Static Pattern Rule

语法

targets: target-pattern: prereq-patterns

其中 targets 不再是一个目标文件了，而是一组目标文件。而 target-pattern 则表示目标文件的特征。例如目标文件都是 .o 结尾的，那么就将其表示为 %.o，prereq-patterns (prerequisites) 表示依赖文件的特征，例如依赖文件都是 .cpp 结尾的，那么就将其表示为 %.cpp。

通过上面的方式，可以对 targets 列表中任何一个元素，找到它对应的依赖文件，例如通过 targets 中的 main.o，可以锁定到 main.cpp。

# Makefile

#根据CPP文件得出所有OBJ文件
OBJS = $(patsubst %.cpp, %.o, $(wildcard *.cpp ))
#g++编译器
CC = g++
#编译参数
CFLAGS = -c -Wall
#链接参数
LFLAGS = -Wall

#第一个target 依赖hello target
all:hello

#hello target用于连接所有obj文件
hello: $(OBJS)
	$(CC) $(LFLAGS) $^ -o $@

#将所有的cpp编译成obj文件
$(OBJS): %.o: %.cpp
	$(CC) $(CFLAGS) $^ -o $@

clean:
	rm -rf *.o hello

Makefile进化史

直接使用g++编译

g++ -o hello main.cpp function1.cpp function2.cpp

第一版 Makefile

# Makefile (井号为注释)
all:
        g++ -o hello main.cpp function1.cpp function2.cpp
clean:
        rm -rf *.o hello

（注意上面代码片段的缩进，是一个而不是4个或者8个空格。）

其中 all 、clean的术语为 target，我也可以随意指定一个名字，例如 abc，真正执行编译的是它下面缩进行的命令。我们可以看到，这个命令和我们在命令行中手动敲的没有任何区别。因此，通过这个简单的 Makefile，就可以省去了每次手动敲命令的痛苦：只需要在命令行敲下 make 回车，即可完成编译。

clean 表示清除编译结果，它下方就是普通的命令行删除文件命令。命令行输入 make 将默认执行第一个 target （即 all）下方的命令；如要执行清理操作，则需要输入 make clean，指定执行 clean 这个 target 下方的命令。

这个 Makefile 虽然可以省去敲命令的痛苦，却无法选择性编译源码。因为我们把所有源文件都一股脑塞进了一条命令，每次都要编译整个工程，很浪费时间。第二版 Makefile 将解决这个问题。

第二版 Makefile
既然我们希望能够选择性地编译源文件，就不能像上一节那样把所有源文件放在一条命令里编译了，而是要分开写：

all: hello
hello: main.o function1.o function2.o
        g++ main.o function1.o function2.o -o hello
main.o: main.cpp
        g++ -c main.cpp
function1.o: function1.cpp
        g++ -c function1.cpp
function2.o: function2.cpp
        g++ -c function2.cpp

clean:
        rm -rf *.o hello

上面的 Makefile 包含了一条重要的语法：:。即，目标：目标依赖的文件。

顺着代码捋一下逻辑：

命令行输入 make ，将默认执行 all 这个 target；
而 all 这个 target 依赖于 hello，hello 在当前目录下并不存在，于是程序开始往下读取命令………终于找到了 hello 这个 target；
正待执行 hello 这个 target 的时候，却发现它依赖于 main.o，function1.o，function2.o 这三个文件，而它们在当前目录下都不存在，于是程序继续向下执行；
遇到 main.o target，它依赖于 main.cpp。而 main.cpp 是当前目录下存在的文件，终于可以编译了，生成 main.o 对象文件。后面两个函数以此类推，都编译好之后，再回到 hello target，连接各种二进制文件，生成 hello 文件。
第一次编译的时候，命令行会输出：

g++ -c main.cpp
g++ -c function1.cpp
g++ -c function2.cpp
g++ main.o function1.o function2.o -o hello

证明所有的源码都被编译了一遍。假如我们对 main.cpp 做一点修改，再重新 make（重新 make 前不要 make clean），则命令行只会显示：

g++ -c main.cpp
g++ main.o function1.o function2.o -o hello

这样，我们就发挥出 Makefile 选择性编译的功能了。下面，将介绍如何在 Makefile 中声明变量（declare variable）。

第三版 Makefile
我们希望将需要反复输入的命令整合成变量，用到它们时直接用对应的变量替代，这样如果将来需要修改这些命令，则在定义它的位置改一行代码即可。

CC = g++
CFLAGS = -c -Wall
LFLAGS = -Wall

all: hello
hello: main.o function1.o function2.o
        $(CC) $(LFLAGS) main.o function1.o function2.o -o hello
main.o: main.cpp
        $(CC) $(CFLAGS) main.cpp
function1.o: function1.cpp
        $(CC) $(CFLAGS) function1.cpp
function2.o: function2.cpp
        $(CC) $(CFLAGS) function2.cpp

clean:
        rm -rf *.o hello

上面的 Makefile 中，开头定义了三个变量：CC，CFLAGS，和 LFLAGS。其中 CC 表示选择的编译器（也可以改成 gcc）；CFLAGS 表示编译选项，-c 即 g++ 中的 -c，-Wall 表示显示编译过程中遇到的所有 warning；LFLAGS 表示链接选项，它就不加 -c 了。这些名字都是自定义的，真正起作用的是它们保存的内容，因此只要后面的代码正确引用，将它们定义成阿猫阿狗都没问题。容易看出，引用变量名时需要用 $() 将其括起来，表示这是一个变量名。

第四版 Makefile
第三版的 Makefile 还是不够简洁，例如我们的 dependencies 中的内容，往往和 g++ 命令中的内容重复：
我们不想敲那么多字，能不能善用 : 中的内容呢？这就需要引入下面几个特殊符号了（也正是这些特殊符号，把 Makefile 搞得像是天书，吓退了很多初学者）：$@，$<，$^。

例如我们有 target: dependencies 对：all: library.cpp main.cpp

$@ 指代 all ，即 target
$< 指代 library.cpp， 即第一个 dependency
$^ 指代 library.cpp 和 main.cpp，即所有的 dependencies

CC = g++
CFLAGS = -c -Wall
LFLAGS = -Wall

all: hello
hello: main.o function1.o function2.o
        $(CC) $(LFLAGS) $^ -o $@
main.o: main.cpp
        $(CC) $(CFLAGS) $<
function1.o: function1.cpp
        $(CC) $(CFLAGS) $<
function2.o: function2.cpp
        $(CC) $(CFLAGS) $<

clean:
        rm -rf *.o hello

但是手动敲文件名还是有点麻烦，能不能自动检测目录下所有的 cpp 文件呢？此外 main.cpp 和 main.o 只差一个后缀，能不能自动生成对象文件的名字，将其设置为源文件名字后缀换成 .o 的形式？

第五版 Makefile
使用wildcard和patsubst

OBJS = $(patsubst %.cpp, %.o, $(wildcard *.cpp))
CC = g++
CFLAGS = -c -Wall
LFLAGS = -Wall

all: hello
hello: $(OBJS)
        $(CC) $(LFLAGS) $^ -o $@
main.o: main.cpp
        $(CC) $(CFLAGS) $< -o $@
function1.o: function1.cpp
        $(CC) $(CFLAGS) $< -o $@
function2.o: function2.cpp
        $(CC) $(CFLAGS) $< -o $@

clean:
        rm -rf *.o hello

然而这一版的 Makefile 还有提升空间，它的 main.o，function1.o，function2.o 使用的都是同一套模板，不过换了个名字而已。第六版的 Makefile 将处理这个问题。

第六版 Makefile
使用 Static Pattern Rule
其中 targets 不再是一个目标文件了，而是一组目标文件。而 target-pattern 则表示目标文件的特征。例如目标文件都是 .o 结尾的，那么就将其表示为 %.o，prereq-patterns (prerequisites) 表示依赖文件的特征，例如依赖文件都是 .cpp 结尾的，那么就将其表示为 %.cpp。

通过上面的方式，可以对 targets 列表中任何一个元素，找到它对应的依赖文件，例如通过 targets 中的 main.o，可以锁定到 main.cpp。

# Makefile

#根据CPP文件得出所有OBJ文件
OBJS = $(patsubst %.cpp, %.o, $(wildcard *.cpp ))
#g++编译器
CC = g++
#编译参数
CFLAGS = -c -Wall
#链接参数
LFLAGS = -Wall

#第一个target 依赖hello target
all:hello

#hello target用于连接所有obj文件
hello: $(OBJS)
	$(CC) $(LFLAGS) $^ -o $@

#将所有的cpp编译成obj文件
$(OBJS): %.o: %.cpp
	$(CC) $(CFLAGS) $^ -o $@

clean:
	rm -rf *.o hello

例子1

目录结构

#Makefile

#程序版本号
VERSION = 1.0.0

#获取所有的.cpp文件
SOURCE = $(wildcard ./src/*.cpp)
#将.cpp文件转为.o文件
OBJ = $(patsubst %.cpp, %.o, $(SOURCE))

#头文件路径
INCLUDES = -I./include -I./include/activemq-cpp -I./include/apr

#库文件名字​
LIBS = -lactivemq-cpp
#库文件地址
LIB_PATH = -L./lib

#宏定义
DEBUG = -D_MACRO
#编译标志位
CFLAGS = -Wall -c -g

#应用程序名称
TARGET = ActiveDemo
CC = g++

$(TARGET): $(OBJ)
	@mkdir -p output/
	$(CC) $(OBJ) $(LIB_PATH) $(LIBS) -o output/$(TARGET).$(VERSION)

%.o: %.cpp
	$(CC) $(INCLUDES) $(DEBUG) $(CFLAGS) $< -o $@

clean:
	rm -rf $(OBJ) output/