【Makefile笔记】小白入门篇

文章目录

【Makefile笔记】小白入门篇
- 所需组件
- 一、简单了解Makefile
- - 1.Makefile简介
  - 2.Makefile 原理
- 二、为什么要使用Makefile
- - 1.解决编译时链库的不便
  - 2.提高编译效率，缩短编译时间（尤其是大工程）
- 三、Makefile语法规则
- - 1.基本语法结构
  - 2.使用make和Makefile进行编译
  - - 2.1 gcc编译
    - 2.2 利用make和Makefile进行编译
    - 2.3 伪目标
    - - 2.3.1 目标冲突
      - 2.3.2 引入伪目标
  - 3.常用语法规则
  - - 3.1 注释
    - 3.2 变量赋值与引用
    - - 3.2.1 = 延迟赋值
      - 3.2.2 := 立即赋值
      - 3.2.3 ?= 是否赋值
      - 3.2.4 += 追加赋值
    - 3.3 变量引用
    - - 3.3.1 直接引用
      - 3.3.2 替换引用
    - 3.4 换行符 \
    - 3.5 使用依赖
    - 3.6 预定义变量
    - 3.7 常用函数
    - - 3.7.1 wildcard 通配匹配文件名函数
      - 3.7.2 shell
      - 3.7.3 patsubst 替换函数（要配合%通配符去使用）
      - 3.7.4 subst 替换函数
      - 3.7.5 dir 取目录函数
      - 3.7.6 suffix 取后缀名函数
      - 3.7.7 basename 取前缀名函数（与suffix相反）
      - 3.7.8 addsuffix 添加后缀名函数
      - 3.7.9 addprefix 添加前缀名函数
      - 3.7.10 foreach 循环函数
      - 3.7.11 条件判断函数

所需组件

烧录好镜像已经启动好的树莓派
VScode + Remote Development 远程访问插件（用于远程操作访问树莓派）

一、简单了解Makefile

1.Makefile简介

Makefile是一个GNU make程序在执行时默认读取的配置文件，写好Makefile之后，配合make工具，只需要一个“make”命令，整个工程就能完全自动编译，极大地提高了软件开发的效率。

Makefile 可以简单的认为是一个工程文件的编译规则，描述了整个工程的编译和链接等规则。

其中包含了哪些文件需要编译，哪些文件不需要编译，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重建等等。编译整个工程需要涉及到的，在 Makefile 中都可以进行描述。

换句话说，Makefile 可以使得我们的项目工程的编译变得自动化，不需要每次都手动输入一堆源文件和参数。

2.Makefile 原理

基本原理：若想生成目标, 检查规则中的所有的依赖文件是否都存在

当有依赖文件不存在

如果有的依赖文件不存在, 则向下搜索规则, 看是否有生成该依赖文件的规则
如果有规则用来生成该依赖文件,则执行规则中的命令生成依赖文件
如果没有规则用来生成该依赖文件, 则报错

在这里插入图片描述

当所有依赖文件存在

如果所有依赖都存在, 检查规则中的目标是否需要更新, 必须先检查它的所有依赖,依赖中有任何一个被更新, 则目标必须更新.(检查的规则是哪个时间大哪个最新)

在这里插入图片描述

二、为什么要使用Makefile

以 Linux 下的 C 语言开发为例来具体说明一下，多文件编译生成一个文件，编译的命令如下所示：

gcc bathroomLight.c mainPro.c socketContrl.c voiceContrl.c beep.c fire.c livingroomLight.c restaurantLight.c upstairsLight.c func.c mp3.c  -lwiringPi -lpthread -lsqlite3 -o smart

smart 要生成的可执行程序的名字，后缀为.c 的都是源文件，-l后边是我们链接的库文件。

这是我们在 Linux 下使用 gcc 编译器编译 C 文件的例子。如果我们遇到的源文件的数量不是很多的话，可以选择这样的编译方式。如果像上面那样源文件非常的多的话，这样就会有以下不便。

1.解决编译时链库的不便

下面列举了一些需要我们手动链接的标准库：

beep.c 用到了硬件驱动库 wiringPi中的函数，我们得手动添加参数 -lwiringPi；

mainPro.c 用到了小型数据库 SQLite 中的函数，我们得手动添加参数 -lsqlite3；

socketContrl.c 使用到了线程，我们需要去手动添加参数 -lpthread；

因为有很多的文件，还要去链接很多的第三方库，所以在编译的时候命令会很长，并且在编译的时候我们可能会涉及到文件链接的顺序问题，所以手动编译会很麻烦。

如果我们学会使用 Makefile 就不一样了，它会彻底简化编译的操作。把要链接的库文件放在 Makefile 中，制定相应的规则和对应的链接顺序。这样只需要执行 make 命令，工程就会自动编译，省略掉手动编译中的参数选项和命令，非常的方便。

2.提高编译效率，缩短编译时间（尤其是大工程）

Makefile 支持多线程并发操作，会极大的缩短我们的编译时间，并且当我们修改了源文件之后，编译整个工程的时候，make 命令只会编译我们修改过的文件，没有修改的文件不用重新编译，也极大的解决了我们耗费时间的问题。

并且文件中的 Makefile 只需要完成一次，一般我们只要不增加或者是删除工程中的文件，Makefile 基本上不用去修改，编译时只用一个 make 命令。为我们提供了极大的便利，很大程度上提高编译的效率。

三、Makefile语法规则

1.基本语法结构

Makefile的语法规则主要是两个部分组成，分别是依赖的关系和执行的命令，其结构如下所示：

targets : prerequisites
    command
    ...
  
目标 ... : 依赖 ...
	命令1
	命令2
	. . .

targets：

规则的目标，是必须要有的，可以是 Object File（一般称它为中间文件），也可以是可执行文件，还可以是一个标签；

prerequisites：

是我们的依赖文件，要生成 targets 需要的文件或者是目标。可以是多个，用空格隔开，也可以是没有；

command：

make 需要执行的命令（任意的 shell 命令）。可以有多条命令，每一条命令占一行；（如果 command 太长, 可以用 \ 作为换行符）

注意：我们的目标和依赖文件之间要使用冒号分隔开，命令的开始一定要使用 Tab 键，不能使用空格键。

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

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

如，编写简单Makefile打印调试：

无依赖，只有目标和命令，打印hello world的同时会打印出命令

debug:
	echo "hello world"

在这里插入图片描述

不打印命令，加个@

debug:
	@echo "hello world"

在这里插入图片描述

2.使用make和Makefile进行编译

2.1 gcc编译

在这里插入图片描述

2.2 利用make和Makefile进行编译

make后面没有加上编译的目标的话，默认执行第一个目标的命令

在这里插入图片描述

make+空格+目标名，执行指定目标的命令，下图可以看见编译成功

在这里插入图片描述

可在Makefile添加删除命令，方便删除

在这里插入图片描述

2.3 伪目标

伪目标是Makefile中一个重要的特殊目标。

伪目标：它不代表一个真正的文件名，在执行make时可以指定这个目标来执行其所在规则定义的命令，也可以将一个伪目标称为标签。

使用伪目标有两点原因：

1）避免在我们的Makefile中定义的只执行命令的目标（就是说定义该目标的目的是为了执行一系列的命令，比如clean，为了执行rm的一些操作）和工作目录下的实际文件出现名字冲突；

当冲突时make会认为当前目录下的同名文件是最新的，而不会去执行Makefile同名目标下的命令
2）提高执行make时的效率，特别是对于一个大型的工程来说，编译的效率也许你同样关心

2.3.1 目标冲突

如下，当操作目录存在同目标名字相同的文件时，该同名目标下的命令不被执行

在这里插入图片描述

2.3.2 引入伪目标

debug:
	@echo "hello world"

hello:
	gcc hello.c -o hello

clean:
	@rm hello

以上由于这个规则没有任何依赖文件，所以当前操作目录下的目标被认为是最新的而不去执行规则所定义的命令，因此命令“rm”将不会被执行，这并不是我们期望的执行结果，为了解决这个问题，我们需要将目标“clean”声明为伪目标，将一个目标声明为伪目标的方法是将它作为特殊目标".PHONY"的依赖

.PHONY：clean

在书写伪目标规则时，首先需要声明目标是一个伪目标，之后才是伪目标的规则定义，如下：

debug:
	@echo "hello world"

hello:
	gcc hello.c -o hello

.PYTHON:clean

clean:
	@rm hello

这样目标“clean” 就被声明为一个伪目标，无论在当前目录下是否存在“clean”这个文件，我们输入“make clean”之后，“rm”命令都会被强制执行

而且，当一个目标被声明为伪目标后，make在执行此规则时不会去试图去查找隐含规则来创建它。这样也提高了make的执行效率，同时也不用担心由于目标和文件名重名而使我们的期望失败。

执行结果，如下：

在这里插入图片描述

3.常用语法规则

3.1 注释

#号 + 注释内容（#号一般顶格写）

# 这是一个Makefile
debug:
	@echo "hello world"

hello:
	gcc hello.c -o hello

.PHONY:clean

clean:
	@rm hello

3.2 变量赋值与引用

3.2.1 = 延迟赋值

TARGET = hello，hello赋值给变量TARGET

# 这是一个Makefile
TARGET = hello

debug:
	@echo "hello world"

hello:
#两种引用都可以
#	gcc hello.c -o ${TARGET}
	gcc hello.c -o $(TARGET)

.PHONY:clean

clean:
	@rm hello

在这里插入图片描述

3.2.2 := 立即赋值

CC := gcc，gcc赋值给变量CC

这种方法，前面的变量不能使用后面的变量，只能使用前面已定义好了的变量
y := $(x) bar
x := foo
那么，y 的值是“bar”，而不是“foo bar”

而，如果用延迟赋值的方式，如下
y = $(x) bar
x = foo
那么，y 的值就是“foo bar”

# 这是一个Makefile
TARGET = hello
CC := gcc

debug:
	@echo "hello world"

hello:
#	gcc hello.c -o ${TARGET}
	$(CC) hello.c -o $(TARGET)

.PHONY:clean

clean:
	@rm hello

在这里插入图片描述

3.2.3 ?= 是否赋值

**CC ?= g++ **

如果前面没有定义，那么该行定义生效g++赋值给CC；反之，不生效，不再定义

# 这是一个Makefile
TARGET = hello
CC := gcc
CC ?= g++  # 如果前面没有定义，那么该行定义生效；反之，不生效，不再定义

debug:
	@echo "hello world"

hello:
#	gcc hello.c -o ${TARGET}
	$(CC) hello.c -o $(TARGET)

.PHONY:clean

clean:
	@rm hello

3.2.4 += 追加赋值

# 这是一个Makefile
TARGET = hello
CC := gcc
CC ?= g++ # 如果前面没有定义，那么该行定义生效；反之，不生效，不再定义
CC += -g

debug:
	@echo "hello world"

hello:
#	gcc hello.c -o ${TARGET}
	$(CC) hello.c -o $(TARGET)

.PHONY:clean

clean:
	@rm hello

在这里插入图片描述

3.3 变量引用

3.3.1 直接引用

$(变量名)

${变量名}

# 这是一个Makefile
TARGET = hello
CC := gcc

debug:
	@echo "hello world"

hello:
#	gcc hello.c -o ${TARGET}
	$(CC) hello.c -o $(TARGET)

3.3.2 替换引用

SRC = hello.c
OBJ = $(SRC:.c=.o)

把后缀.c都改成.o再进行赋值引用

# 这是一个Makefile
TARGET = hello
CC := gcc
CC ?= g++ # 如果前面没有定义，那么该行定义生效；反之，不生效，不再定义
CC += -g

SRC = hello.c
OBJ = $(SRC:.c=.o)

debug:
	@echo "hello world"
	echo $(TARGET)
	echo $(OBJ)

在这里插入图片描述

3.4 换行符 \

hello:
#	gcc hello.c -o ${TARGET}
	$(CC) hello.c \
	-o $(TARGET)

3.5 使用依赖

# 这是一个Makefile
TARGET = hello
CC := gcc
CC ?= g++ # 如果前面没有定义，那么该行定义生效；反之，不生效，不再定义
CC += -g

SRC = hello.c
OBJ = $(SRC:.c=.o)

debug:
	@echo "hello world"
	echo $(TARGET)
	echo $(OBJ)

hello:$(OBJ)
#	gcc hello.c -o ${TARGET}
	$(CC) hello.c \
	-o $(TARGET)


.PHONY:clean

clean:
	@rm hello

在执行过程中，因为没有hello.o这个依赖，所以make工具会自动先生成依赖文件hello.o（隐式规则），再执行下面的命令

在这里插入图片描述

3.6 预定义变量

自动变量的引用	含义
$<	第一个依赖文件的名称
$@	目标文件的完整名称
$^	所有不重复的目标依赖文件，以空格分开
$?	所有时间戳比目标文件晚的的依赖文件，并以空格分开

# 这是一个Makefile
TARGET = hello
CC := gcc
CC ?= g++ # 如果前面没有定义，那么该行定义生效；反之，不生效，不再定义
CC += -g

SRC = hello.c
OBJ = $(SRC:.c=.o)

debug:
	@echo "hello world"
	echo $(TARGET)
	echo $(OBJ)

$(TARGET):$(SRC)
#	gcc hello.c -o ${TARGET}
#	$(CC) hello.c -o $(TARGET)
	$(CC) $< -o $@

.PHONY:clean compile

compile:$(TARGET)

clean:
	@rm hello

在这里插入图片描述

3.7 常用函数

Makefile中，函数的调用和变量的引用格式很像，变量引用的格式为$(变量名)，而函数调用的格式如下：

$(<function> <arguments>) 或者 ${<function> <arguments>}

Makefile函数的使用方法为：
返回值＝$(函数名 [参数1],[参数2],[...])

function 是函数名，arguments 是函数的参数。
参数之间要用逗号分隔开。
参数和函数名之间使用空格分开。
调用函数的时候要使用字符“$”，后面可以跟小括号或者大括号（花括号）

3.7.1 wildcard 通配匹配文件名函数

作用：Makefile中的wildcard函数用于扩展通配符，返回与通配符匹配的文件列表

通配符：一种特殊字符，可以表示多个文件名或目录名，常见的通配符有 * 和？，分别代表任意长度的任意字符和单个任意字符

$(wildcard 指定文件类型)

比如，*.c表示所有以.c结尾的文件名，a?.txt表示所有以a开头，中间有一个任意字符，以.txt结尾的文件名，例如：

表示查找并返回src目录下所有的 .c 文件，* 表示通配符，匹配一个或多个任意字符

SRC = $(wildcard src/*.c)

对之前的Makefile进行修改并调试

# 这是一个Makefile
TARGET = hello
CC := gcc
CC ?= g++ # 如果前面没有定义，那么该行定义生效；反之，不生效，不再定义
CC += -g

#SRC = hello.c
SRC = $(wildcard src/*.c)
OBJ = $(SRC:.c=.o)

debug:
	@echo "hello world"
	echo $(SRC)
	echo $(OBJ)

$(TARGET):$(SRC)
#	gcc hello.c -o ${TARGET}
#	$(CC) hello.c -o $(TARGET)
	$(CC) $< -o $@

.PHONY:clean compile

compile:$(TARGET)

clean:
	@rm hello

此时，已将hello.c放入新建文件夹src下，Makefile在原根目录下不动，运行结果如下

在这里插入图片描述

3.7.2 shell

$(shell <cmd> <args>)

cmd：执行命令名称
args：参数列表
返回值：返回命令执行结果

例如：

表示查找当前目录以及子目录下的所有.c结尾的文件

SRC = $(shell find . -name *.c)

修改相应Makefile并进行调试

# 这是一个Makefile
TARGET = hello
CC := gcc
CC ?= g++ # 如果前面没有定义，那么该行定义生效；反之，不生效，不再定义
CC += -g

#SRC = hello.c
#SRC = $(wildcard src/*.c)
SRC = $(shell find . -name *.c)
OBJ = $(SRC:.c=.o)

debug:
	@echo "hello world"
	echo $(SRC)
	echo $(OBJ)

$(TARGET):$(SRC)
#	gcc hello.c -o ${TARGET}
#	$(CC) hello.c -o $(TARGET)
	$(CC) $< -o $@

.PHONY:clean compile

compile:$(TARGET)

clean:
	@rm hello

在这里插入图片描述

3.7.3 patsubst 替换函数（要配合%通配符去使用）

$(patsubst <pattern>,<replacement>,<text>)

函数名的pat是pattern（模式）的缩写，而subst是substitute（替换）的缩写。
该函数查找 text 中的单词是否符合模式 pattern，如果匹配则用 replacement 替换。
如果test是列表，则其成员间以空格隔开。
返回值为替换后的新字符串。
pattern 和 replacement 均需包含通配符%

例如，如果有一个变量src，它的值是：

src = a.c b.c c.c

想把它的值中所有的.c后缀替换成.o后缀，可以这样写：

# obj = $(patsubst %.c,%.o,a.c b.c c.c)
obj = $(patsubst %.c,%.o,$(src))  # 这里的$(src)是变量引用

这样，obj的值就是：

obj = a.o b.o c.o

修改相应Makefile并进行调试

# 这是一个Makefile
TARGET = hello
CC := gcc
CC ?= g++ # 如果前面没有定义，那么该行定义生效；反之，不生效，不再定义
CC += -g

#SRC = hello.c
#SRC = $(wildcard src/*.c)
SRC = $(shell find . -name *.c)
#OBJ = $(SRC:.c=.o)
OBJ = $(patsubst %.c,%.o,$(SRC))

debug:
	@echo "hello world"
	@echo "SRC"
	echo $(SRC)
	@echo "OBJ"
	echo $(OBJ)

$(TARGET):$(SRC)
#	gcc hello.c -o ${TARGET}
#	$(CC) hello.c -o $(TARGET)
	$(CC) $< -o $@

.PHONY:clean compile

compile:$(TARGET)

clean:
	@rm hello

在这里插入图片描述

3.7.4 subst 替换函数

$(subst <from>,<to>,<text>)

from：要被替换的字符或单词
to：替换后的字符或单词
text：要处理的字符串
返回值：subst函数会在text中找到所有的from，并用to替换它们，然后返回替换后的字符串

例如：

$(subst ee,EE,feet on the street)

返回：

fEEt on the strEEt

修改相应Makefile并进行调试

# 这是一个Makefile
TARGET = hello
CC := gcc
CC ?= g++ # 如果前面没有定义，那么该行定义生效；反之，不生效，不再定义
CC += -g

#SRC = hello.c
#SRC = $(wildcard src/*.c)
SRC = $(shell find . -name *.c)
#OBJ = $(SRC:.c=.o)
#OBJ = $(patsubst %.c,%.o,$(SRC))
OBJ = $(subst .c,.o,$(SRC))

debug:
	@echo "hello world"
	@echo "SRC"
	echo $(SRC)
	@echo "OBJ"
	echo $(OBJ)

$(TARGET):$(SRC)
#	gcc hello.c -o ${TARGET}
#	$(CC) hello.c -o $(TARGET)
	$(CC) $< -o $@

.PHONY:clean compile

compile:$(TARGET)

clean:
	@rm hello

在这里插入图片描述

3.7.5 dir 取目录函数

$(dir <names>)

该函数从文件名序列 names 中取出目录部分。
返回值为目录部分，指的是最后一个反斜杠之前的部分，如果没有反斜杠将返回“./”。

例如：

修改相应Makefile并进行调试，返回SRC = hello.c 的目录

# 这是一个Makefile
TARGET = hello
CC := gcc
CC ?= g++ # 如果前面没有定义，那么该行定义生效；反之，不生效，不再定义
CC += -g

#SRC = hello.c
#SRC = $(wildcard src/*.c)
SRC = $(shell find . -name *.c)
#OBJ = $(SRC:.c=.o)
#OBJ = $(patsubst %.c,%.o,$(SRC))
OBJ = $(subst .c,.o,$(SRC))

TARGET_DIR = $(dir $(SRC))

debug:
	@echo "hello world"
	@echo "SRC"
	echo $(SRC)
	@echo "OBJ"
	echo $(OBJ)
	@echo "TARGET_DIR"
	echo $(TARGET_DIR)

$(TARGET):$(SRC)
#	gcc hello.c -o ${TARGET}
#	$(CC) hello.c -o $(TARGET)
	$(CC) $< -o $@

.PHONY:clean compile

compile:$(TARGET)

clean:
	@rm hello

在这里插入图片描述

3.7.6 suffix 取后缀名函数

$(suffix <names>)

该函数从文件名序列中 names 中取出各个文件的后缀名。
返回值为文件名序列 names 中的后缀序列，如果文件没有后缀名，则返回空字符串。

例如：

$(suffix src/foo.c src-1.0/bar.c hacks)

返回：

.c .c

修改相应Makefile并进行调试

# 这是一个Makefile
TARGET = hello
CC := gcc
CC ?= g++ # 如果前面没有定义，那么该行定义生效；反之，不生效，不再定义
CC += -g

#SRC = hello.c
#SRC = $(wildcard src/*.c)
SRC = $(shell find . -name *.c)
#OBJ = $(SRC:.c=.o)
#OBJ = $(patsubst %.c,%.o,$(SRC))
OBJ = $(subst .c,.o,$(SRC))

TARGET_DIR = $(dir $(SRC))

debug:
	@echo "hello world"
	@echo "SRC"
	echo $(SRC)
	@echo "OBJ"
	echo $(OBJ)
	@echo "TARGET_DIR"
	echo $(TARGET_DIR)
	@echo "suffix"
	echo $(suffix src/foo.c src-1.0/bar.c hacks)

$(TARGET):$(SRC)
#	gcc hello.c -o ${TARGET}
#	$(CC) hello.c -o $(TARGET)
	$(CC) $< -o $@

.PHONY:clean compile

compile:$(TARGET)

clean:
	@rm hello

在这里插入图片描述

3.7.7 basename 取前缀名函数（与suffix相反）

$(basename <names>)

该函数从文件名序列 names 中取出各个文件名的前缀部分（包括文件路径）。
返回值是被取出来的文件的前缀名，如果文件没有前缀名则返回空的字符串。

例如：

$(basename src/foo.c src-1.0/bar.c hacks)

返回：

src/foo src-1.0/bar hacks

修改相应Makefile并进行调试

# 这是一个Makefile
TARGET = hello
CC := gcc
CC ?= g++ # 如果前面没有定义，那么该行定义生效；反之，不生效，不再定义
CC += -g

#SRC = hello.c
#SRC = $(wildcard src/*.c)
SRC = $(shell find . -name *.c)
#OBJ = $(SRC:.c=.o)
#OBJ = $(patsubst %.c,%.o,$(SRC))
OBJ = $(subst .c,.o,$(SRC))

TARGET_DIR = $(dir $(SRC))

debug:
	@echo "hello world"
	@echo "SRC"
	echo $(SRC)
	@echo "OBJ"
	echo $(OBJ)
	@echo "TARGET_DIR"
	echo $(TARGET_DIR)
	@echo "suffix"
	echo $(suffix src/foo.c src-1.0/bar.c hacks)
	@echo "basename"
	echo $(basename src/foo.c src-1.0/bar.c hacks)

$(TARGET):$(SRC)
#	gcc hello.c -o ${TARGET}
#	$(CC) hello.c -o $(TARGET)
	$(CC) $< -o $@

.PHONY:clean compile

compile:$(TARGET)

clean:
	@rm hello

在这里插入图片描述

3.7.8 addsuffix 添加后缀名函数

$(addsuffix <suffix>,<names>)

该函数把后缀 suffix 加到 names 文件名(包括路径)列表中的每个字符串后面。
如果文件本来就存在后缀名，依然会加上后缀
返回值为添加上后缀的文件名序列。

例如：

$(addsuffix .c,foo bar)

foo.c bar.c

修改相应Makefile并进行调试：

# 这是一个Makefile
TARGET = hello
CC := gcc
CC ?= g++ # 如果前面没有定义，那么该行定义生效；反之，不生效，不再定义
CC += -g

#SRC = hello.c
#SRC = $(wildcard src/*.c)
SRC = $(shell find . -name *.c)
#OBJ = $(SRC:.c=.o)
#OBJ = $(patsubst %.c,%.o,$(SRC))
OBJ = $(subst .c,.o,$(SRC))

TARGET_DIR = $(dir $(SRC))

debug:
	@echo "hello world"
	@echo "SRC"
	echo $(SRC)
	@echo "OBJ"
	echo $(OBJ)
	@echo "TARGET_DIR"
	echo $(TARGET_DIR)
	@echo "suffix"
	echo $(suffix src/foo.c src-1.0/bar.c hacks)
	@echo "basename"
	echo $(basename src/foo.c src-1.0/bar.c hacks)
	@echo "addsuffix"
	echo $(addsuffix .c,foo bar)

$(TARGET):$(SRC)
#	gcc hello.c -o ${TARGET}
#	$(CC) hello.c -o $(TARGET)
	$(CC) $< -o $@

.PHONY:clean compile

compile:$(TARGET)

clean:
	@rm hello

在这里插入图片描述

3.7.9 addprefix 添加前缀名函数

$(addprefix <prefix>,<names>)

把前缀 prefix 加到 names 中的每个单词的前面。
返回值为添加上前缀的文件名序列。
我们可以使用这个函数给文件添加路径。

例如：

$(addprefix src/,foo bar)

src/foo src/bar

修改相应Makefile并进行调试：

# 这是一个Makefile
TARGET = hello
CC := gcc
CC ?= g++ # 如果前面没有定义，那么该行定义生效；反之，不生效，不再定义
CC += -g

#SRC = hello.c
#SRC = $(wildcard src/*.c)
SRC = $(shell find . -name *.c)
#OBJ = $(SRC:.c=.o)
#OBJ = $(patsubst %.c,%.o,$(SRC))
OBJ = $(subst .c,.o,$(SRC))

TARGET_DIR = $(dir $(SRC))

debug:
	@echo "hello world"
	@echo "SRC"
	echo $(SRC)
	@echo "OBJ"
	echo $(OBJ)
	@echo "TARGET_DIR"
	echo $(TARGET_DIR)
	@echo "suffix"
	echo $(suffix src/foo.c src-1.0/bar.c hacks)
	@echo "basename"
	echo $(basename src/foo.c src-1.0/bar.c hacks)
	@echo "addsuffix"
	echo $(addsuffix .c,foo bar)
	@echo "addprefix"
	echo $(addprefix src/,foo bar)

$(TARGET):$(SRC)
#	gcc hello.c -o ${TARGET}
#	$(CC) hello.c -o $(TARGET)
	$(CC) $< -o $@

.PHONY:clean compile

compile:$(TARGET)

clean:
	@rm hello

在这里插入图片描述

3.7.10 foreach 循环函数

foreach：把list中空格分割的单词逐一取出放到参数var这个变量中（即赋值给var），然后再执行text所包含的表达式

$(foreach <var>,<list>,<text>)

每一次text都会返回一个字符串，循环过程中，text返回的每个字符串会以空格分割，最后当整个循环结束的时候，由text所返回的每个字符串所组成的整个字符串（以空格分隔）将会是 foreach 函数的返回值。
var最好是一个变量名，list可以是一个表达式，而text中一般会只用var这个参数来枚举list中的单词。
注意，foreach 中的 var 参数是一个临时的局部变量，foreach 函数执行完后，参数var的变量将不再起作用，其作用域只在 foreach 函数当中。

例如：

(链接很多库或路径的时候，方便加上其前缀或后缀去依次解析)

file := foo bar baz
file-with-c := $(foreach file,files,$(file).c)

修改相应Makefile并进行调试：

# 这是一个Makefile
TARGET = hello
CC := gcc
CC ?= g++ # 如果前面没有定义，那么该行定义生效；反之，不生效，不再定义
CC += -g
INCLUDE := /usr/include/ \
			/usr/local/include

#SRC = hello.c
#SRC = $(wildcard src/*.c)
SRC = $(shell find . -name *.c)
#OBJ = $(SRC:.c=.o)
#OBJ = $(patsubst %.c,%.o,$(SRC))
OBJ = $(subst .c,.o,$(SRC))
I_FLAGS := $(foreach var,$(INCLUDE),-I$(var)) # -I/usr/include/ -I/usr/local/include

TARGET_DIR = $(dir $(SRC))

debug:
	@echo "hello world"
	@echo "SRC"
	echo $(SRC)
	@echo "OBJ"
	echo $(OBJ)
	@echo "TARGET_DIR"
	echo $(TARGET_DIR)
	@echo "suffix"
	echo $(suffix src/foo.c src-1.0/bar.c hacks)
	@echo "basename"
	echo $(basename src/foo.c src-1.0/bar.c hacks)
	@echo "addsuffix"
	echo $(addsuffix .c,foo bar)
	@echo "addprefix"
	echo $(addprefix src/,foo bar)
	@echo "-I"
	echo $(I_FLAGS)

$(TARGET):$(SRC)
#	gcc hello.c -o ${TARGET}
#	$(CC) hello.c -o $(TARGET)
	$(CC) $< -o $@

.PHONY:clean compile

compile:$(TARGET)

clean:
	@rm hello

在这里插入图片描述

3.7.11 条件判断函数

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

ifeq：判断参数是否相等，相等为true，否则为false
ifeq(arg1,arg2)
	#若arg1 arg2相等，执行这里的语句
else
	#若arg1 arg2不相等，执行这里的语句
endif
ifneq：判断参数是否不相等，不相等为true，否则为false
ifneq(arg1,arg2)
	#若arg1 arg2不相等，执行这里的语句
else
	#若arg1 arg2相等，执行这里的语句
endif

ifdef：判断参数是否有值，有值为true，否则为false

ifdef var
	#若定义了var，执行这里的语句
else
	#若没有定义var，执行这里的语句
endif

ifndef：判断参数是否没有值，没有值为true，否则为false

ifndef var
	#若没有定义var，执行这里的语句
else
	#若定义了var，执行这里的语句
endif

修改相应Makefile并进行调试：

# 这是一个Makefile
TARGET = hello
CC := gcc
# CC ?= g++ # 如果前面没有定义，那么该行定义生效；反之，不生效，不再定义
# CC += -g

ifdef CC
	CC += -g
else
	CC := gcc
endif

INCLUDE := /usr/include/ \
			/usr/local/include

#SRC = hello.c
#SRC = $(wildcard src/*.c)
SRC = $(shell find . -name *.c)
#OBJ = $(SRC:.c=.o)
#OBJ = $(patsubst %.c,%.o,$(SRC))
OBJ = $(subst .c,.o,$(SRC))
I_FLAGS := $(foreach var,$(INCLUDE),-I$(var)) # -I/usr/include/ -I/usr/local/include

TARGET_DIR = $(dir $(SRC))

debug:
	@echo $(CC)
	@echo "hello world"
	@echo "SRC"
	echo $(SRC)
	@echo "OBJ"
	echo $(OBJ)
	@echo "TARGET_DIR"
	echo $(TARGET_DIR)
	@echo "suffix"
	echo $(suffix src/foo.c src-1.0/bar.c hacks)
	@echo "basename"
	echo $(basename src/foo.c src-1.0/bar.c hacks)
	@echo "addsuffix"
	echo $(addsuffix .c,foo bar)
	@echo "addprefix"
	echo $(addprefix src/,foo bar)
	@echo "-I"
	echo $(I_FLAGS)

$(TARGET):$(SRC)
#	gcc hello.c -o ${TARGET}
#	$(CC) hello.c -o $(TARGET)
	$(CC) $< -o $@

.PHONY:clean compile

compile:$(TARGET)

clean:
	@rm hello