Makefile的使用

Martin272

已于 2024-05-18 17:52:52 修改

阅读量560

点赞数 26

文章标签：学习

于 2024-05-18 17:45:00 首次发布

本文链接：https://blog.csdn.net/weixin_66915667/article/details/139028897

版权

Makefile的使用

官方文档: http://www.gnu.org/software/make/manual/

在 Linux 中使用 make 命令来编译程序，特别是大程序；而 make 命令所执行的动作依赖于 Makefile 文件。最简单的 Makefile 文件如下：

	hello: hello.c
	gcc -o hello hello.c
	clean:
	rm -f hello

直接执行 make 命令即可编译程序，执行“make clean”即可清除编译出来的结果。

make 命令根据文件更新的时间戳来决定哪些文件需要重新编译，这使得可以避免编译已经编译过的、没有变化的程序，可以大大提高编译效率。

为什么需要Makefile

自动化：通过编写一个 Makefile，你可以定义一系列的构建规则，这些规则描述了如何从源代码生成最终的可执行文件或库。当源代码或依赖项发生变化时，你可以简单地运行 make 命令，而不需要手动执行一系列复杂的构建步骤。
依赖管理：Makefile 支持定义文件之间的依赖关系。如果一个源文件依赖于其他源文件或头文件，make 会自动确定需要首先编译哪些文件，以确保构建的正确性。
并行构建：make 工具支持并行构建，这意味着它可以同时编译多个源文件，从而加快构建过程。这对于具有大量源代码文件的项目尤其有用。
灵活性：Makefile 允许你使用变量、条件语句和循环等结构来定义构建规则，这使得你可以根据项目的需要定制构建过程。
可移植性：虽然 Makefile 是基于 Unix 和类 Unix 系统的，但它们在许多其他操作系统上也可以很好地工作，只需稍作修改。这使得你的构建过程可以在不同的平台上保持一致。

为讲解Makefile我们事先来写好一个程序，以供我们实验使用：

程序a.c

#include <stdio.h>

int main()
{
	func_b();
	return 0;
}

程序b.c

#include <stdio.h>

void func_b()
{
	printf("This is B\n");
}

编译：

gcc -o test a.c b.c

运行：

./test

结果：

This is B

Makefile的规则

makefie最基本的语法是规则，规则：

目标 : 依赖1 依赖2 ...
[TAB]命令

当“依赖”比“目标”新，执行它们下面的命令。我们要把上面三个命令写成makefile规则，如下：

test ：a.o b.o  //test是目标，它依赖于a.o b.o文件，一旦a.o或者b.o比test新的时候，
就需要执行下面的命令，重新生成test可执行程序。
gcc -o test a.o b.o
a.o : a.c  //a.o依赖于a.c，当a.c更加新的话，执行下面的命令来生成a.o
gcc -c -o a.o a.c
b.o : b.c  //b.o依赖于b.c,当b.c更加新的话，执行下面的命令，来生成b.o
gcc -c -o b.o b.c

我们来作一下实验：

在改目录下我们写一个Makefile文件：

文件：Makefile

1   test:a.o b.o
2       gcc -o test a.o b.o
3   
4   a.o : a.c
5       gcc -c -o a.o a.c
6
7   b.o : b.c
8       gcc -c -o b.o b.c

上面是makefile中的三条规则。makefile,就是名字为“makefile”的文件。当我们想编译程序时，直接执行make命令就可以了，一执行make命令它想生成第一个目标test可执行程序, 如果发现a.o 或者b.o没有，就要先生成a.o或者b.o，发现a.o依赖a.c，有a.c但是没有a.o,他就会认为a.c比a.o新，就会执行它们下面的命令来生成a.o，同理b.o和b.c的处理关系也是这样的。

如果修改a.c ，我们再次执行make，它的本意是想生成第一个目标test应用程序,它需要先生成a.o,发现a.o依赖a.c(执行我们修改了a.c)发现a.c比a.o更加新，就会执行gcc -c -o a.o a.c命令来生成a.o文件。b.o依赖b.c，发现b.c并没有修改，就不会执行gcc -c -o b.o b.c来重新生成b.o文件。现在a.o b.o都有了，其中的a.o比test更加新，就会执行 gcc -o test a.ob.o来重新链接得到test可执行程序。所以当执行make命令时候就会执行下面两条执行：

gcc -c -o a.o a.c
gcc -o test a.o b.o

我们第一次执行make的时候，会执行下面三条命令(三条命令都执行)：

gcc -c -o a.o a.c
gcc -c -o b.o b.c
gcc -o test a.o b.o

再次执行make 就会显示下面的提示：

make: `test' is up to date.

我们再次执行make就会判断Makefile文件中的依赖，发现依赖没有更新，所以目标文件就不会重现生成，就会有上面的提示。当我们修改a.c后，重新执行make,

就会执行下面两条指令：

gcc -c -o a.o a.c
gcc -o test a.o b.o

我们同时修改a.c b.c，执行make就会执行下面三条指令。

gcc -c -o a.o a.c
gcc -c -o b.o b.c
gcc -o test a.o b.o

a.c文件修改了，重新编译生成a.o, b.c修改了重新编译生成b.o，a.o,b.o都更新了重新链接生成test可执行程序，makefile的规则其实还是比较简单的。规则是Makefie的核心，

执行make命令的时候，就会在当前目录下面找到名字为：Makefile的文件，根据里面的内容来执行里面的判断/命令。

Makefile的语法

通配符

假如一个目标文件所依赖的依赖文件很多，那样岂不是我们要写很多规则，这显然是不合乎常理的

我们可以使用通配符，来解决这些问题。

我们对上节程序进行修改代码如下：

test: a.o b.o 
	gcc -o test $^
	
%.o : %.c
	gcc -c -o $@ $<

%.o：表示所用的.o文件

%.c：表示所有的.c文件

$@：表示目标

$<：表示第1个依赖文件

$^：表示所有依赖文件

我们来在该目录下增加一个 c.c 文件，代码如下：

#include <stdio.h>

void func_c()
{
	printf("This is C\n");
}

然后在main函数中调用修改Makefile，修改后的代码如下：

test: a.o b.o c.o
	gcc -o test $^
	
%.o : %.c
	gcc -c -o $@ $<

执行：

make

结果：

gcc -c -o a.o a.c
gcc -c -o b.o b.c
gcc -c -o c.o c.c
gcc -o test a.o b.o c.o

运行：

./test

结果：

This is B
This is C

假想目标: .PHONY

1.我们想清除文件，我们在Makefile的结尾添加如下代码就可以了：

clean:
	rm *.o test

1）执行 make ：生成第一个可执行文件。
2）执行 make clean : 清除所有文件，即执行： rm *.o test。

make后面可以带上目标名，也可以不带，如果不带目标名的话它就想生成第一个规则里面的第一个目标。

2.使用Makefile

执行：make [目标] 也可以不跟目标名，若无目标默认第一个目标。我们直接执行make的时候，会在makefile里面找到第一个目标然后执行下面的指令生成第一个目标。当我们执行 make clean 的时候，就会在 Makefile 里面找到 clean 这个目标，然后执行里面的命令，这个写法有些问题，原因是我们的目录里面没有 clean 这个文件，这个规则执行的条件成立，他就会执行下面的命令来删除文件。

如果：该目录下面有名为clean文件怎么办呢？

我们在该目录下创建一个名为 “clean” 的文件，然后重新执行：make然后make
clean，结果(会有下面的提示：)：

make: \`clean' is up to date.

它根本没有执行我们的删除操作，这是为什么呢？

我们之前说，一个规则能过执行的条件：

1）目标文件不存在
2）依赖文件比目标新

现在我们的目录里面有名为“clean”的文件，目标文件是有的，并且没有

依赖文件，没有办法判断依赖文件的时间。这种写法会导致：有同名的"clean"文件时，就没有办法执行make clean操作。解决办法：我们需要把目标定义为假象目标，用关键子PHONY

.PHONY: clean //把clean定义为假象目标。他就不会判断名为“clean”的文件是否存在，

然后在Makfile结尾添加.PHONY: clean语句，重新执行：make clean，就会执行删除操作。

变量

在makefile中有两种变量：

1）简单变量(即使变量)：

A := xxx # A的值即刻确定，在定义时即确定

对于即使变量使用 “:=” 表示，它的值在定义的时候已经被确定了

2）延时变量

B = xxx # B的值使用到时才确定

对于延时变量使用“=”表示。它只有在使用到的时候才确定，在定义/等于时并没有确定下来。

想使用变量的时候使用“$”来引用，如果不想看到命令是，可以在命令的前面加上"@"符号，就不会显示命令本身。当我们执行make命令的时候，make这个指令本身，会把整个Makefile读进去，进行全部分析，然后解析里面的变量。常用的变量的定义如下：

:= # 即时变量
= # 延时变量
?= # 延时变量, 如果是第1次定义才起效, 如果在前面该变量已定义则忽略这句
\+= # 附加, 它是即时变量还是延时变量取决于前面的定义
?=: 如果这个变量在前面已经被定义了，这句话就会不会起效果，

实例：

A := $(C)
B = $(C)
C = abc

#D = 111
D ?= bbb

all:
	@echo A = $(A)
	@echo B = $(B)
	@echo D = $(D)

C += 123

执行：

make

结果：

A =
B = abc 123
D = bbb

分析：

A := $©：

A为即使变量，在定义时即确定，由于刚开始C的值为空，所以A的值也为空。

B = $©：
B为延时变量，只有使用到时它的值才确定，当执行make时，会解析Makefile里面的所用变量，所以先解析C= abc,然后解析C += 123，此时，C = abc 123，当执行：@echo B = $(B) B的值为 abc 123。
D ?= bbb：

D变量在前面没有定义，所以D的值为bbb，如果在前面添加D =111，最后D的值为111。

我们还可以通过命令行存入变量的值例如：

执行：make D=123456 里面的 D ?= bbb 这句话就不起作用了。

结果：

A =
B = abc 123
D = 123456

Makefile函数

makefile里面可以包含很多函数，这些函数都是make本身实现的，下面我们来几个常用的函数。引用一个函数用“$”。

foreach函数

函数foreach语法如下：

$(foreach var,list,text)

前两个参数，‘var’和‘list’，将首先扩展，注意最后一个参数 ‘text’ 此时不扩展；接着，对每一个 ‘list’ 扩展产生的字，将用来为 ‘var’ 扩展后命名的变量赋值；然后 ‘text’ 引用该变量扩展；因此它每次扩展都不相同。结果是由空格隔开的 ‘text’。在 ‘list’ 中多次扩展的字组成的新的 ‘list’。‘text’ 多次扩展的字串联起来，字与字之间由空格隔开，如此就产生了函数 foreach 的返回值。

实例：

A = a b c
B = $(foreach f, &(A), $(f).o)

all:
	@echo B = $(B)

结果：

B = a.o b.o c.o

filter/filter-out函数

函数filter/filter-out语法如下：

$(filter pattern...,text)     # 在text中取出符合patten格式的值
$(filter-out pattern...,text) # 在text中取出不符合patten格式的值

实例：

C = a b c d/

D = $(filter %/, $(C))
E = $(filter-out %/, $(C))

all:
        @echo D = $(D)
        @echo E = $(E)

结果：

D = d/
E = a b c

Wildcard函数

函数Wildcard语法如下：

$(wildcard pattern) # pattern定义了文件名的格式, wildcard取出其中存在的文件。

这个函数 wildcard 会以 pattern 这个格式，去寻找存在的文件，返回存在文件的名字。

实例：

在该目录下创建三个文件：a.c b.c c.c

files = $(wildcard *.c)

all:
        @echo files = $(files)

结果：

files = a.c b.c c.c

我们也可以用wildcard函数来判断，真实存在的文件

实例：

files2 = a.c b.c c.c d.c e.c  abc
files3 = $(wildcard $(files2))

all:
        @echo files3 = $(files3)

结果：

files3 = a.c b.c c.c

patsubst函数

函数 patsubst 语法如下：

$(patsubst pattern,replacement,\$(var))

patsubst 函数是从 var 变量里面取出每一个值，如果这个符合 pattern 格式，把它替换成 replacement 格式，

实例：

files2  = a.c b.c c.c d.c e.c abc

dep_files = $(patsubst %.c,%.d,$(files2))

all:
        @echo dep_files = $(dep_files)

结果：

dep_files = a.d b.d c.d d.d e.d abc

CFLAGS函数

以下是一些常见的 CFLAGS 设置示例：

优化级别：
- -O0：没有优化。
- -O1：启用基本优化。
- -O2：进一步优化。
- -O3：启用更多的优化选项，可能包括更激进的优化策略。
调试信息：
- -g：生成调试信息。
警告等级：
- -Wall：打开几乎所有的警告信息。
- -Wextra：打开额外的警告信息。
- -Werror：将所有警告当作错误处理。
代码标准：
- -std=c99：指定使用C99标准。
- -std=gnu99：指定使用C99标准，并允许GNU扩展。
包含路径：
- -I/path/to/include：添加头文件搜索路径。
宏定义：
- -DDEBUG：定义一个宏。
架构特定选项：
- -m32 或 -m64：指定生成32位或64位代码。
静态/动态库：
- -fPIC：生成位置无关代码，通常用于生成共享库。

实例：

# 定义编译器
CC=gcc

# 定义编译器标志，包括多个选项
CFLAGS=-Wall -Wextra -O2 -g -std=gnu99 -I/path/to/include -DDEBUG -m64

# 定义源文件
SOURCES=main.c utils.c

# 定义目标文件
OBJECTS=$(SOURCES:.c=.o)

# 默认目标
all: my_program

# 目标依赖于对象文件
my_program: $(OBJECTS)
	$(CC) -o $@ $^

# 编译源文件为对象文件
%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@

# 清理编译生成的文件
clean:
	rm -f my_program *.o