makefile常用的命令总结及简单示例

1、Makefile编译过程

  Makefile文件中的命令有一定规范，一旦该文件编写好以后在Linux命令行中执行一条make命令即可自动编译整个工程。不同厂家的make可能会稍有不同，并且语法上也有区别，不过基本思想都差不多，主要还是落在目标依赖上，最广泛使用的是GNUmake。

2、语法规则

目标 ... : 依赖 ...

命令1

命令2

. . .

        Makefile的核心规则，类似于一位厨神做菜，目标就是做好一道菜，那么所谓的依赖就是各种食材，各种厨具等等，然后需要厨师好的技术方法类似于命令，才能作出一道好菜。

        同时这些依赖也有可能此时并不存在，需要现场制作，或者是由其他厨师做好，那么这个依赖就成为了其他规则的目标，该目标也会有他自己的依赖和命令。这样就形成了一层一层递归依赖组成了Makefile文件。

  Makefile并不会关心命令是如何执行的，仅仅只是会去执行所有定义的命令，和我们平时直接输入命令行是一样的效果。

1、目标即要生成的文件。如果目标文件的更新时间晚于依赖文件更新时间，则说明依赖文件没有改动，目标文件不需要重新编译。否则会进行重新编译并更新目标文件。

2、默认情况下Makefile的第一个目标为终极目标。

3、依赖：即目标文件由哪些文件生成。

4、命令：即通过执行命令由依赖文件生成目标文件。注意每条命令之前必须有一个tab保持（8个空格）缩进，这是语法要求（会有一些编辑工具默认tab为4个空格，会造成Makefile语法错误）。

5、all：Makefile文件默认只生成第一个目标文件即完成编译，但是我们可以通过all 指定所需要生成的目标文件。

3、变量

$符号表示取变量的值，当变量名多于一个字符时，使用"( )"

$符的其他用法

$^ 表示所有的依赖文件

$@ 表示生成的目标文件

$< 代表第一个依赖文件

SRC = $(wildcard *.c)
OBJ = $(patsubst %.c, %.o, $(SRC))
 
ALL: hello.out
 
hello.out: $(OBJ)
        gcc $< -o $@
 
$(OBJ): $(SRC)
        gcc -c $< -o $@

4、变量赋值

  1、"="是最普通的等号，在Makefile中容易搞错赋值等号，使用 “=”进行赋值，变量的值是整个Makefile中最后被指定的值。

VIR_A = A
VIR_B = $(VIR_A) B
VIR_A = AA

  经过上面的赋值后，最后VIR_B的值是AA B，而不是A B，在make时，会把整个Makefile展开，来决定变量的值

  2、":=" 表示直接赋值，赋予当前位置的值。

VIR_A := A
VIR_B := $(VIR_A) B
VIR_A := AA

  最后BIR_B的值是A B，即根据当前位置进行赋值。因此相当于“=”，“：=”才是真正意义上的直接赋值

  3、"?=" 表示如果该变量没有被赋值，赋值予等号后面的值。

VIR ?= new_value

  如果VIR在之前没有被赋值，那么VIR的值就为new_value。

VIR := old_value
VIR ?= new_value

  这种情况下，VIR的值就是old_value

  4、"+="和平时写代码的理解是一样的，表示将符号后面的值添加到前面的变量上

　　5、在设计Makefile时，不希望在Makefile中定义的变量被覆盖，就可以使用override

　　　　1）未使用override前

]# cat Makefile 
.PHONY: all
foo = x
all:
    @echo "foo = $(foo)"
    
    执行make（结果：变量的值被覆盖了）

]# make foo=1217
foo = 1217

　　　　2）使用override

]# cat Makefile 
.PHONY: all
override foo = x
all:
    @echo "foo = $(foo)"

    执行make（结果变量的值没有发生改变）

]# make foo=1217
foo = x

5、预定义变量

CC：c编译器的名称，默认值为cc。cpp c预编译器的名称默认值为$(CC) -E

CC = gcc

回显问题，Makefile中的命令都会被打印出来。如果不想打印命令部分 可以使用@去除回显

@echo "clean done!"

6、函数

通配符

SRC = $(wildcard ./*.c)

匹配目录下所有.c 文件，并将其赋值给SRC变量。

OBJ = $(patsubst %.c, %.o, $(SRC))

这个函数有三个参数，意思是取出SRC中的所有值，然后将.c 替换为.o 最后赋值给OBJ变量。

示例：如果目录下有很多个.c 源文件，就不需要写很多条规则语句了，而是可以像下面这样写

SRC = $(wildcard *.c)
OBJ = $(patsubst %.c, %.o, $(SRC))
 
ALL: hello.out
 
hello.out: $(OBJ)
        gcc $(OBJ) -o hello.out
 
$(OBJ): $(SRC)
        gcc -c $(SRC) -o $(OBJ)

这里先将所有.c 文件编译为 .o 文件，这样后面更改某个 .c 文件时，其他的 .c 文件将不在编译，而只是编译有更改的 .c 文件，可以大大提高大项目中的编译速度。

1、addprefix 函数

　　用来再给字符串中每个子串前加上一个前缀，格式为$(addprefix prefix, names...)

.PHONY:all
without_dir= foo.c bar.c main.c
with_dir:=$(addprefix objs/, $(without_dir))
all:
        @echo $(with_dir)

　　make执行结果

]# make
objs/foo.c objs/bar.c objs/main.c

2、filter函数

　　filter 函数⽤于从⼀个字符串中，根据模式得到满⾜模式的字符串，其形式是：$(filter pattern..., text)

.PHONY: all
sources = foo.py bar.go baz.sh ugh.js
sources := $(filter %.py %.sh, $(sources))
all:
        @echo $(sources)

　　make执行结果

]# make
foo.py baz.sh

 3、filter-out函数

　　filter-out 函数⽤于从⼀个字符串中根据模式滤除⼀部分字符串，其形式是：$(filter-out pattern..., text)

]# cat Makefile 
.PHONY: all
sources = foo.py bar.go baz.sh ugh.js
sources := $(filter-out %.py %.sh, $(sources))
all:
        @echo $(sources)

　　make执行结果

]# make
bar.go ugh.js

4、patsubst函数

#查找text中的单词，如果匹配pattern,那么就用replacement的内容替换
#返回：函数返回被替换过后的字符串。
#$(patsubst 原模式， 目标模式， 文件列表)
$(patsubst <pattern>,<replacement>,<text>) 

功能详解

patsubst函数在Makefile中是一个非常强大的文本处理工具，它允许用户按照特定的模式查找和替换文本。以下是对其功能的详细描述：

1.查找与替换

patsubst的核心功能是查找并替换文本中的单词。这里的“单词”是指由空格、Tab、回车或换行符分隔的文本片段。

2.模式匹配

函数的工作方式是，它会检查每个单词是否与给定的匹配。这个模式可以是一个具体的文本，也可以包含通配符“%”来匹配任意长度的字符串。

3.通配符的使用

通配符“%”在patsubst中起到了关键的作用。它可以匹配文本中的任意长度的字符串，这使得函数在处理文件名和路径时非常有用。

4.替换文本

当一个单词与匹配时，它将被替换。这个替换文本可以是一个固定的字符串，也可以包含通配符“%”。如果中的“%”与中的“%”匹配，那么它将被替换为中的“%”所匹配的文本。

5.转义字符

在某些情况下，我们可能需要在文本中使用真正的“%”字符，而不是作为通配符。在这种情况下，可以使用“\”来转义它，即“\%”。

6.应用场景

patsubst在Makefile中有许多应用场景，如文件名转换、路径修改、添加前缀或后缀等。它为文本处理提供了强大而灵活的工具，使得Makefile的编写更加简洁和高效。

通过对patsubst函数的深入理解，我们可以更好地利用它来简化和优化Makefile的编写。　　

7.例子：

]# cat Makefile 
.PHONY:all
mixed=foo.c bar.c main.o
objects:=$(patsubst %.c, %.o, $(mixed))
all:
        @echo $(objects)

　　make执行结果

]# make 
foo.o bar.o main.o

5、strip函数

　　strip 函数⽤于去除变量中的多余的空格，其形式是：$(strip string)

]# cat Makefile 
.PHONY:all
original=foo.c     bar.c 
stripped:=$(strip $(original))
all:
        @echo "original = $(original)"
        @echo "stripped = $(stripped)"

　　make执行结果

]# make
original = foo.c     bar.c 
stripped = foo.c bar.c

6、wildcard函数

　　wildcard 是通配符函数，通过它可以得到我们所需的⽂件，这个函数类似我们在 Windows 或Linux 命令⾏中的“*”。其形式是：$(wildcard pattern)

　　环境

]# ls
bar.c  foo.c  main.c  Makefile

　　Makefile内容

]# cat Makefile 
.PHONY:all
SRC=$(wildcard *.c)
all:
        @echo "SRC = $(SRC)"

　　make执行的结果 

]# make
SRC = foo.c main.c bar.c

7、伪目标 .PHONY

伪目标只是一个标签，clean是个伪目标没有依赖文件，只有用make来调用时才会执行当目录下有与make命令同名的文件时执行make命令就会出现错误。

解决办法就是使用伪目标。希望执行伪目标clean，就需要make clean。可以将指令写在同一个makefile中。

SRC = $(wildcard *.c)
OBJ = $(patsubst %.c, %.o, $(SRC))
 
ALL: hello.out
 
hello.out: $(OBJ)
        gcc $< -o $@
 
$(OBJ): $(SRC)
        gcc -c $< -o $@
 
clean:
        rm -rf $(OBJ) hello.out
 
.PHONY: clean ALL

通常也会把ALL设置成伪目标

8、其他常用功能

代码清理clean

我们可以编译一条属于自己的clean语句，来清理make命令所产生的所有文件，列如

SRC = $(wildcard *.c)
OBJ = $(patsubst %.c, %.o, $(SRC))
 
ALL: hello.out
 
hello.out: $(OBJ)
        gcc $< -o $@
 
$(OBJ): $(SRC)
        gcc -c $< -o $@
 
clean:
        rm -rf $(OBJ) hello.out

9、嵌套执行Makefile

  在一些大工程中，会把不同模块或不同功能的源文件放在不同的目录中，我们可以在每个目录中都写一个该目录的Makefile这有利于让我们的Makefile变的更加简洁，不至于把所有东西全部写在一个Makefile中。

  列如在子目录subdir目录下有个Makefile文件，来指明这个目录下文件的编译规则。外部总Makefile可以这样写

subsystem:
            cd subdir && $(MAKE)
#其等价于：
subsystem:
            $(MAKE) -C subdir

  定义$(MAKE)宏变量的意思是，也许我们的make需要一些参数，所以定义成一个变量比较有利于维护。两个例子意思都是先进入"subdir"目录，然后执行make命令

我们把这个Makefile叫做总控Makefile，总控Makefile的变量可以传递到下级的Makefile中，但是不会覆盖下层Makefile中所定义的变量，除非指定了 "-e"参数。

  如果传递变量到下级Makefile中，那么可以使用这样的声明

  export

  如果不想让某些变量传递到下级Makefile，可以使用

  unexport

export variable = value
#等价于
variable = value
export variable
#等价于
export variable := value
#等价于
variable := value
export variable
#如果需要传递所有变量，那么只要一个export就行了。后面什么也不用跟，表示传递所有变量

10、指定头文件路径

一般都是通过"-I"（大写i）来指定，假设头文件在：

/home/develop/include

则可以通过-I指定：

-I/home/develop/include

将该目录添加到头文件搜索路径中

在Makefile中则可以这样写：

CFLAGS=-I/home/develop/include

然后在编译的时候，引用CFLAGS即可，如下

yourapp:*.c
    gcc $(CFLAGS) -o yourapp

11、指定库文件路径

与上面指定头文件类似只不过使用的是"-L"来指定

LDFLAGS=-L/usr/lib -L/path/to/your/lib

告诉链接器要链接哪些库文件，使用"-l"（小写L）如下：

LIBS = -lpthread -liconv

12 、MAKECMDGOALS

MAKECMDGOALS变量　　

　　表示当前用户所输入的make目标是什么

.PHONY: all clean
all clean:
    @echo "\$$@ = $@"
    @echo "MAKECMDGOALS = $(MAKECMDGOALS)"

　　执行返回的结果

]# make
$@ = all
MAKECMDGOALS = 

]# make all
$@ = all
MAKECMDGOALS = all

]# make clean
$@ = clean
MAKECMDGOALS = clean

]# make all clean
$@ = all
MAKECMDGOALS = all clean
$@ = clean
MAKECMDGOALS = all clean

13、include功能

        Makefile中的include命令与C语言中的include命令类似，命令include file.dep，即把file.dep文件在当前Makefile文件中展开，亦即把file.dep文件的内容包含进当前Makefile文件；如果Makefile中有以file.dep为目标的规则，make会先使用规则对file.dep文件进行更新，然后将更新后的file.dep文件包含进当前Makefile文件。

        Makefile中的include命令先将文件file.dep包含进当前Makefile文件（第一次包含），这样Makefile文件中就有了file.dep文件的内容；[断点A]

        然后在集合U（特别注意，这里是集合U）中检查是否有以file.dep为目标的规则。如果U中没有以file.dep为目标的规则，或者虽然有以file.dep为目标的规则，但根据依赖关系（即便在规则中的命令执行后也）不能使file.dep文件发生更新，则Makefile文件最终包含的就是file.dep文件的当前内容，include命令执行结束；[断点B]

        如果集合U中有以file.dep为目标的规则，并且该规则使得file.dep文件发生了更新，则include命令会将更新后的file.dep文件再次包含进当前Makefile文件（再次包含），跳转到断点A往下继续执行。

这里需要澄清的有几点：

        第一，多数情况下，U中没有规则能使file.dep文件发生更新，这就给我们这样一个假象：Makefile的include命令和C语言的include命令一样，只是简单的把file.dep文件的内容包含进当前Makefile文件，即include命令执行到断点A就执行完毕了，甚至都没有执行到断点B。

        第二，很多情况下，file.dep文件中并不包含以file.dep为目标的规则，这就给我们另外一个假象：include file.dep后，检查是否有规则对file.dep文件进行更新时，检查的范围仅仅是集合U1，而不是集合U。

        第三，由于多数情况下include命令会在第一次执行到断点B后结束，这就给我们第三个假象：include命令只会把file.dep文件包含一次，不会将其再次包含甚至多次包含。

14、exprort

Makefile 中的 export 命令详细介绍

        在 Makefile 中，export 命令用于将变量从 Makefile 导出到由 Makefile 启动的子进程的环境中。这通常在你需要在 Makefile 中设置环境变量，并确保这些变量在编译过程中启动的任何子 shell 或程序中都是可用的情况下使用。

        当你在 Makefile 中导出一个变量时，任何由 make 启动的子进程（比如调用的 shell 脚本或其他程序）都将能够访问该环境变量。

导出与未导出变量的区别

        如果一个变量没有被导出，那么它只在当前的 Makefile 及其包含的 Makefile 中可用。子进程和子 shell 无法访问未导出的变量。只有被明确导出的变量才能够在子进程的环境中被检测到。

        export 命令在 Makefile 中非常有用，它允许你定义全局环境变量，这些变量可以在整个编译过程中的所有子进程中被访问。这样可以确保环境的一致性，并可以简化复杂项目中 Makefile 的管理。

15、subst 函数

subst是Makefile的一个内建函数，它用于在文本中替换字符串。subst函数的语法如下：

$(subst from,to,text)

这个函数会在text中找到所有的from字符串，并将它们替换为to。

下面是一个使用subst函数的简单示例：

TEXT = foo.c bar.c baz.c 
NEW_TEXT = $(subst .c,.o,$(TEXT)) 

all: 
    @echo $(NEW_TEXT)

在这个示例中，subst .c,.o,$(TEXT)会将TEXT中的所有.c后缀替换为.o。新的字符串被保存在NEW_TEXT变量中。

当你运行make all时，将会在命令行中打印出foo.o bar.o baz.o：

]# make all
foo.o bar.o baz.o

注意：subst函数只进行字符串替换，它不会修改文件名或进行任何文件操作。如果你想要修改文件名或进行其他类型的替换，你可能需要在Makefile中调用外部的shell命令或脚本。

16、abspath函数

abspath 是 makefile中的一个函数，它用来将相对路径转换成绝对路径。这在编程中是非常有用的，比如当你需要引用其他目录下的文件时，使用绝对路径可以更准确地找到文件的位置。

abspath 函数的语法是：

$(abspath NAMES...)

NAMES是一个或多个文件的相对路径或者绝对路径。

举个例子：

RELATIVE_PATH = ./src/program.c 
ABSOLUTE_PATH = $(abspath $(RELATIVE_PATH)) 

all: 
    @echo "Relative path: $(RELATIVE_PATH)" 
    @echo "Absolute path: $(ABSOLUTE_PATH)"

在这个例子中，我们将"./src/program.c"这个相对路径转换为绝对路径。当我们运行makefile时，它会打印出相对路径和绝对路径：

]# make all
Relative path: ./src/program.c
Absolute path: /home/sam/workbase/test/src/program.c

注意：如果给定的路径不存在或者无法访问，abspath函数将返回空字符串。

17、word

1.word函数

作用：取字符串text中第n个单词(从1开始)，如果n比text中的单词数要大，那么返回空字符串。

$(word <n>,<text> )

例子：$(word 3, foo bar abc)的返回值为abc

2.words函数

作用：统计text中字符串中的单词个数。

$(words <text> )

例子：$(words foo bar abc)的返回值为3

3.firstword函数

作用：返回text中字符串中的第一个单词。

$(firstword <text> )

例子：$(firstword foo bar abc)的返回值为foo

4.lastword函数

作用：返回text中字符串中的最后一个单词。

$(lastword <text> )

例子：$(lastword foo bar abc)的返回值为abc

注意： GNU Make 3.80中没有lastword内置函数，可用以下两种方法实现lastword函数

1.$(word $(words <text>) <text>)

2.lastword = $(if $(firstword $1),$(word $(words $1),$1)) #定义一个函数 $(call lastword,...)#调用该函数

18、shell

语法:

$(shell <shell command>)

它的作用就是执行一个 shell 命令, 并将 shell 命令的结果作为函数的返回.

作用和  一样, ` 是反引号

all:
    echo $(shell pwd)

执行 make 结果：

ethan@ubuntu1804:~/cpp/func$ make
echo /home/wohu/cpp/func
/home/wohu/cpp/func
ethan@ubuntu1804:~/cpp/func$ 

19、打印函数

在Makefile中，除了使用echo命令打印信息外，还可以使用$(info )，$(warning )和$(error )函数。

$(info )：这个函数用于在解析Makefile时打印一些信息。它不会像echo那样等到目标被执行时才打印，而是在Makefile解析时就会打印。例如：

$(info "Start parsing the makefile") 
all: 
    @echo "Compiling the program..."

这将在make all命令执行之前就打印出"Start parsing the makefile"。

$(warning )：这个函数用于在解析Makefile时打印一些警告信息，并继续解析和执行。例如：

$(warning "This is a warning") 
all: 
    @echo "Compiling the program..."

这将在解析Makefile时打印出"This is a warning"，然后继续解析和执行。

$(error )：这个函数用于在解析Makefile时打印一些错误信息，并停止解析和执行。例如：

$(error "This is an error") 
all: 
    @echo "Compiling the program..."

这将在解析Makefile时打印出"This is an error"，然后停止解析和执行。$(error )函数通常用于在某些条件不满足时停止Makefile的执行。

注意，这三个函数都是在 Makefile 解析阶段，而不是目标执行阶段打印信息的，所以它们通常用于打印一些Makefile本身的信息，而不是目标的执行结果。

Makefile 中如何打印变量？

在Makefile中，我们可以使用$(info )函数或echo命令来打印变量的值。

例如，假设我们在Makefile中定义了一个变量SRC，并且我们想要打印其值，我们可以采用以下两种方法：

使用$(info )函数：

SRC = main.c foo.c bar.c 
all: 
    $(info $(SRC))

当我们运行make all时，Make将在解析Makefile时打印出SRC变量的值。

使用echo命令：

SRC = main.c foo.c bar.c 
all: 
    @echo $(SRC)

当我们运行make all时，Make将在执行all目标时打印出SRC变量的值。

注意，在使用echo命令时，我们通常在命令前面加上一个@字符，这样Make就不会打印出命令本身，只会打印出命令的输出。

另外，如果你的变量的值包含了空格或者特殊字符，你可能需要用引号来保护它们，例如@echo "$(SRC)"。

Makefile 中如何打印字符串？

在Makefile中，我们可以用$(info )函数和echo命令来打印字符串。以下是一些示例：

使用$(info )函数打印字符串：

all: 
    $(info "Hello, World!")

这将在解析Makefile时打印出"Hello, World!"。

使用echo命令打印字符串：

all: 
    @echo "Hello, World!"

这将在执行all目标时，打印出"Hello, World!"。注意，我们在命令前面加上@以避免Make打印出命令本身。

使用变量和字符串：

MESSAGE = "Hello, World!" 
all: 
    $(info $(MESSAGE)) 
    @echo $(MESSAGE)

上面的两行命令分别在解析Makefile和执行all目标时，打印出"Hello, World!"。

20、Makefile里面打印信息

Makefile的规则相对来说还是比较复杂的，上手不容易，没有系统研究过，往往搞不清楚状况。如果掌握了基本的调试手段，那对我们写出正确的Makefile会非常有帮助。而在Makefile中，最重要的调试手段莫过于输出信息。

　　Makefile中需要打印信息，可以通过如下方法：

　　$(info info text)、$(warning warning text)或者$(error error text)

　　示例：

CXX = g++ 
CompileOpt = -g -std=gnu++11
LinkOpt = -lpthread  $(asan)

Target = main

$(Target) : main.o memory_leak.o
    $(CXX) main.o memory_leak.o -o $(Target) $(LinkOpt)
    $(info info text)
    $(warning warn text)
    $(warning $(asan))
    $(error error text)

main.o : main.cpp memory_leak.h
    $(CXX) -c $(CompileOpt) main.cpp

memory_leak.o : memory_leak.cpp memory_leak.h
    $(CXX) -c $(CompileOpt) memory_leak.cpp


clean:
    rm main.o memory_leak.o

　　编译输出：

$ make asan='-fsanitize=leak -fsanitize=address'                                                                                                             
g++ -c -g -std=gnu++11 main.cpp
g++ -c -g -std=gnu++11 memory_leak.cpp
info text
Makefile:11: warn text
Makefile:11: -fsanitize=leak -fsanitize=address
Makefile:11: *** error text.  Stop.

21、简单的Makefile实例

目录结构

include

myinclude.h

#include <stdio.h>
void print1() ;
void print2() ;

f1

f1.c

#include "../include/myinclude.h"                                                                              

void print1()  
{  
    printf("Message f1.c\n");  
    return;  
} 

Makefile

目标前面的路径，意思是将目标生成到指定的目录下

../$(OBJS_DIR)/f1.o:f1.c
        @$(CC) -c $^ -o $@ 

f2

f2.c

                                                                       

void print2()  
{  
    printf("Message f2.c\n");  
    return;  
} 

Makefile

../$(OBJS_DIR)/f2.o:f2.c
        @$(CC) -c $^ -o $@ 

main

main.c

#include "../include/myinclude.h"                                                                                            
 
int main(int argc, char const *argv[])
{
    print1();  
    print2();  
    return 0;
}

Makefile

../$(OBJS_DIR)/main.o:main.c
        @$(CC) -c $^ -o $@  

obj

此目录用来存放相关生成的目标文件

Makefile

../$(BIN_DIR)/$(BIN) : $(OBJS)
    @$(CC) $^ -o $@ 

主Makefile

#预定义变量
CC = gcc
#预定义编译目录
SUBDIRS = f1 \
        f2 \
        main \
        obj
#预定义目标
OBJS = f1.o f2.o main.o
BIN = myapp
OBJS_DIR = obj
BIN_DIR = bin
#传递预定义参数
export CC OBJS BIN OBJS_DIR BIN_DIR

all:CHECK_DIR $(SUBDIRS)
CHECK_DIR:
    @mkdir -p $(BIN_DIR)
$(SUBDIRS):ECHO
    @make -C $@ 

ECHO:
    @echo $(SUBDIRS)
    @echo begin compile
clean:
    @$(RM) $(OBJS_DIR)/*.o
    @rm -rf $(BIN_DIR)

bin

此文件用来存放生成的二进制文件

执行结果

主Makefile执行过程

生成.o文件

生成二进制文件执行结果