LINUX编程 Makefile中的变量详解应用
make makefile 的参数
make makefile 的参数make是一个常用的构建工具，用于自动化编译和构建软件项目。
makefile是make工具的配置文件，用于描述项目的构建规则和依赖关系。
本文将介绍makefile的参数，包括常用的参数及其用法。
一、常用参数及其用法1. -f 文件名：指定makefile的文件名，默认为"makefile"或"Makefile"。
通过该参数，可以使用其他名称的makefile文件。
2. -C 目录：指定make命令的工作目录。
在执行make命令时，会切换到指定的目录，并在该目录下查找makefile文件进行构建。
3. -n：显示执行make命令时的操作，但不实际执行。
通过该参数，可以预览make命令的执行过程，检查构建规则是否正确。
4. -p：显示make命令的内置变量和规则。
通过该参数，可以查看make命令的内部工作机制，了解makefile文件的编写规则和使用方法。
5. -B：强制重新构建目标文件。
通过该参数，可以忽略文件的时间戳，强制重新执行构建规则，生成新的目标文件。
6. -j 并发数：指定make命令的并发执行数。
通过该参数，可以提高构建速度，同时执行多个任务。
7. -s：静默模式，不显示执行的命令。
通过该参数，可以减少输出信息，使构建过程更加清晰。
二、makefile的构建规则makefile由一系列构建规则组成，每个规则定义了目标文件、依赖文件和构建命令。
make命令根据构建规则，自动判断需要更新的文件，并执行相应的构建命令。
构建规则的基本格式如下：目标文件: 依赖文件构建命令其中，目标文件是要生成的文件，依赖文件是目标文件依赖的文件，构建命令是生成目标文件的命令。
构建规则中的目标文件和依赖文件可以是文件名，也可以是变量。
通过使用变量，可以提高makefile的可维护性和灵活性。
构建命令可以是任意的Shell命令，包括编译、链接、拷贝等操作。
makefile中make指令传入的参数
makefile中make指令传入的参数Makefile中make指令传入的参数是指在执行make命令时，可以通过命令行传入的参数。
这些参数可以用于控制程序的编译、运行等行为，使得程序更加灵活和可配置。
在Makefile中，我们可以通过在命令行中输入make和参数来执行相应的操作。
参数可以是任意的字符串，可以用于指定编译选项、目标文件、源文件等等。
下面我将结合一些实际的例子，来详细讲解一下如何使用make指令传入的参数。
我们需要在Makefile中定义一些变量，用于存储传入的参数。
可以通过在命令行中使用“变量名=参数值”的方式来传入参数。
例如，我们可以定义一个变量CC，用于存储编译器的路径：```CC = gcc```在命令行中执行make命令时，可以通过“make CC=/usr/local/bin/gcc”来传入参数，将编译器的路径设置为“/usr/local/bin/gcc”。
接下来，我们可以在Makefile中使用这些参数。
例如，我们可以使用$(CC)来表示编译器的路径：```$(CC) -o target source.c```在执行make命令时，make会将$(CC)替换为实际的参数值，然后执行相应的命令。
这样，我们就可以通过命令行传入不同的编译器路径，来编译源文件。
除了编译器的路径，还可以通过命令行传入其他的参数。
例如，我们可以定义一个变量CFLAGS，用于存储编译选项：```CFLAGS = -Wall -O2```在命令行中执行make命令时，可以通过“make CFLAGS=-g”来传入参数，将编译选项设置为“-g”。
然后，我们可以在Makefile中使用这些参数。
例如，我们可以在编译命令中加入$(CFLAGS)：```$(CC) $(CFLAGS) -o target source.c```在执行make命令时，make会将$(CFLAGS)替换为实际的参数值，然后执行相应的命令。
Makefile中的几个常见的符号及其含义
Makefile中的⼏个常见的符号及其含义= 是最基本的赋值:= 是覆盖之前的值= 是如果没有被赋值过就赋予等号后⾯的值+= 是添加等号后⾯的值“=”和“:=”的区别：1、“=”make会将整个makefile展开后，再决定变量的值。
也就是说，变量的值将会是整个makefile中最后被指定的值。
看例⼦： x = fooy = $(x) barx = xyz在上例中，y的值将会是 xyz bar ，⽽不是 foo bar 。
2、“:=”“:=”表⽰变量的值决定于它在makefile中的位置，⽽不是整个makefile展开后的最终值。
x := fooy := $(x) barx := xyz在上例中，y的值将会是 foo bar ，⽽不是 xyz bar 了。
'@' 符号的使⽤通常makefile会将其执⾏的命令⾏在执⾏前输出到屏幕上。
如果将‘@’添加到命令⾏前，这个命令将不被make回显出来。
例如：@echo --compiling module----; // 屏幕输出 --compiling module----echo --compiling module----; // 没有@ 屏幕输出echo --compiling module----' - ' 符号的使⽤通常删除，创建⽂件如果碰到⽂件不存在或者已经创建，那么希望忽略掉这个错误，继续执⾏，就可以在命令前⾯添加 -， -rm dir；-mkdir aaadir；ref:https:///u012989012/article/details/80572043。
makefile 中文手册 第六章 _ Makefile中的变量
第六章：Makefile中的变量在Makefile中，变量是一个名字（像是C语言中的宏），代表一个文本字符串（变量的值）。
在Makefile的目标、依赖、命令中引用变量的地方，变量会被它的值所取代（与C语言中宏引用的方式相同，因此其他版本的make也把变量称之为“宏”）。
在Makefile中变量有以下几个特征：1.Makefile中变量和函数的展开（除规则命令行中的变量和函数以外），是在make读取makefile文件时进行的，这里的变量包括了使用“=”定义和使用指示符“define”定义的。
2.变量可以用来代表一个文件名列表、编译选项列表、程序运行的选项参数列表、搜索源文件的目录列表、编译输出的目录列表和所有我们能够想到的事物。
3.变量名是不包括“:”、“#”、“=”、前置空白和尾空白的任何字符串。
需要注意的是，尽管在GNUmake中没有对变量的命名有其它的限制，但定义一个包含除字母、数字和下划线以外的变量的做法也是不可取的，因为除字母、数字和下划线以外的其它字符可能会在make的后续版本中被赋予特殊含义，并且这样命名的变量对于一些shell来说是不能被作为环境变量来使用的。
4.变量名是大小写敏感的。
变量“foo”、“Foo”和“FOO”指的是三个不同的变量。
Makefile传统做法是变量名是全采用大写的方式。
推荐的做法是在对于内部定义定义的一般变量（例如：目标文件列表objects）使用小写方式，而对于一些参数列表（例如：编译选项CFLAGS）采用大写方式，但这并不是要求的。
但需要强调一点：对于一个工程，所有Makefile中的变量命名应保持一种风格，否则会显得你是一个蹩脚的程序员（就像代码的变量命名风格一样）。
5.另外有一些变量名只包含了一个或者很少的几个特殊的字符（符号）。
称它们为自动化变量。
像“$<”、“$@”、“$?”、“$*”等。
6.1变量的引用当我们定义了一个变量之后，就可以在Makefile的很多地方使用这个变量。
make makefile 的参数
make makefile 的参数make命令是一款非常强大的工具，可以帮助我们自动化构建项目，特别是在大型项目中，make命令可以极大地提高开发效率。
makefile是make命令的配置文件，可以用来指定构建项目的规则和依赖关系，下面我们将介绍makefile的参数以及其用法。
1. -f-f参数可以用来指定makefile文件的名称，如果不指定，则默认使用当前目录下的makefile文件或Makefile文件。
例如，我们可以使用以下命令来指定makefile文件的名称：make -f mymakefile2. -C-C参数可以用来指定make命令的工作目录，即make命令将在指定目录下执行构建操作。
例如，我们可以使用以下命令来指定工作目录：make -C /path/to/project3. -n-n参数可以用来显示make命令将要执行的动作，但并不真正执行。
这个参数在调试makefile文件时非常有用，可以帮助我们检查makefile文件的正确性。
例如，我们可以使用以下命令来显示make 命令将要执行的动作：make -n4. -B-B参数可以用来强制执行make命令，即使目标文件已经是最新的了。
这个参数通常在我们需要重新构建项目时使用。
例如，我们可以使用以下命令来强制执行make命令：make -B5. -j-j参数可以用来指定make命令并行执行的任务数，可以加快构建速度。
这个参数通常在大型项目中使用，可以充分利用计算机的多核处理能力。
例如，我们可以使用以下命令来指定make命令并行执行的任务数：make -j46. --debug--debug参数可以用来打开make命令的调试模式，可以帮助我们更好地理解make命令的执行过程。
例如，我们可以使用以下命令来打开make命令的调试模式：make --debug7. --version--version参数可以用来显示make命令的版本信息。
makefile循环语句
makefile循环语句（原创版）目录1.Makefile 简介2.Makefile 循环语句的作用3.Makefile 循环语句的语法4.Makefile 循环语句的示例5.Makefile 循环语句的注意事项正文1.Makefile 简介Makefile 是一种构建脚本，用于自动构建和编译源代码。
它最初用于 Unix 系统，但现在已经广泛应用于各种操作系统，如 Linux、macOS 等。
Makefile 可以根据源代码的变化自动重新编译目标文件，从而提高了开发效率。
2.Makefile 循环语句的作用在 Makefile 中，循环语句用于处理一系列相似的任务。
通过使用循环语句，可以避免重复编写相同的代码，使 Makefile 更加简洁和易于维护。
3.Makefile 循环语句的语法Makefile 循环语句的基本语法如下：```循环名：for 变量名 in 列表; do# 循环体内容done```其中，循环名是一个标识符，用于表示循环的开始和结束。
变量名是要迭代的变量，列表是一个包含多个元素的列表，用空格分隔。
循环体内容是循环执行的任务。
4.Makefile 循环语句的示例以下是一个 Makefile 循环语句的示例：```all:for src in src1 src2 src3; doobj := $(src).o$(CC) $(CFLAGS) -c $src -o $objdone```在这个示例中，循环名为“all”，变量名为“src”，列表为“src1 src2 src3”。
循环体内容是使用 C 编译器编译源代码文件并生成目标文件。
5.Makefile 循环语句的注意事项在使用 Makefile 循环语句时，需要注意以下几点：- 循环名应该具有唯一性，避免重复定义。
- 列表中的元素应该使用空格分隔，而不是逗号或其他分隔符。
- 在循环体内，可以使用自动变量（如$@、$%等）来表示当前迭代的变量。
makefile基本使用方法
makefile基本使用方法makefile是一种用来管理和自动化构建程序的工具。
它可以根据源代码文件的依赖关系和编译规则来自动构建目标文件和可执行文件。
makefile的基本使用方法如下：1. 创建makefile文件：在项目的根目录下创建一个名为makefile 的文件。
2. 定义变量：在makefile中，可以使用变量来存储一些常用的参数和路径，以便于后续的使用。
例如，可以定义一个名为CC的变量来指定编译器的名称，如：CC=gcc。
3. 编写规则：在makefile中，可以使用规则来指定如何编译源代码文件和生成目标文件。
一个规则由两部分组成：目标和依赖。
目标是要生成的文件，依赖是生成目标文件所需要的源代码文件。
例如，可以编写以下规则：```target: dependency1 dependency2command1command2```其中，target是目标文件，dependency1和dependency2是依赖的源代码文件，command1和command2是生成目标文件所需要执行的命令。
4. 编写默认规则：在makefile中，可以使用一个默认规则来指定如何生成最终的可执行文件。
默认规则的目标通常是可执行文件，依赖是所有的源代码文件。
例如，可以编写以下默认规则：```all: target1 target2```其中，target1和target2是生成的目标文件。
5. 编写clean规则：在makefile中，可以使用clean规则来清理生成的目标文件和可执行文件。
例如，可以编写以下clean规则： ```clean:rm -f target1 target2```其中，target1和target2是要清理的目标文件。
6. 运行make命令：在命令行中，使用make命令来执行makefile 文件。
make命令会自动根据规则和依赖关系来编译源代码文件和生成目标文件。
例如，可以运行以下命令：``````make命令会根据makefile文件中的规则和依赖关系来编译源代码文件并生成目标文件和可执行文件。
linux下makefile文件中比较大小的语法
linux下makefile文件中比较大小的语法在Linux下，Makefile是一种常用的构建工具，用于自动化编译和构建软件项目。
在Makefile中，我们经常需要比较文件的大小来判断是否需要重新编译或执行某些操作。
本文将介绍在Linux下Makefile 文件中比较大小的语法。
在Makefile中，我们可以使用shell命令来执行系统命令。
比较文件大小的常用命令是`stat`和`du`。
`stat`命令用于获取文件的详细信息，包括文件大小，而`du`命令用于计算文件或目录的大小。
首先，我们可以使用`stat`命令获取文件的大小，并将结果保存到一个变量中。
下面是一个示例：```file_size := $(shell stat -c %s file.txt)```上述命令将获取文件`file.txt`的大小，并将结果保存到变量`file_size`中。
`-c %s`选项用于指定输出文件大小的格式。
接下来，我们可以使用条件语句来比较文件大小。
常用的条件语句有`ifeq`和`ifneq`。
下面是一个示例：```ifeq ($(file_size), 0)@echo "文件为空"else@echo "文件大小为$(file_size)字节"endif```上述代码将判断文件大小是否为0，如果是，则输出"文件为空"，否则输出"文件大小为$(file_size)字节"。
`@echo`命令用于输出信息，`$(file_size)`表示变量的值。
除了使用`stat`命令获取文件大小外，我们还可以使用`du`命令计算文件或目录的大小。
下面是一个示例：```file_size := $(shell du -b file.txt | cut -f1)```上述命令将使用`du`命令计算文件`file.txt`的大小，并使用`cut`命令提取文件大小。
【重要】调用makefile(多目录嵌套调用、变量使用)
obj2 = main2.o lib.o
all : edit1 edit2
edit1 : $(obj1)
gcc -o./main1/edit1 ./main1/main1.o lib.o
main1.o : main1.c
$(MAKE) -C./main1
gcc -csub2.c
都很简单对吧，就一条正常的编译命令，最后是根目录下的makefile：
VPATH=./sub1 ./sub2
obj=main.o sub1.o sub2.o
edit : $(obj)
gcc -oedit main.o ./sub1/sub1.o ./sub2/sub2.o
$(MAKE) -C$(s1)
lib.o : lib.c
gcc -clib.c
edit2 : $(ob2)/main2.o lib.o
main2.o : $(s2)/main2.c
$(MAKE) -C$(s2)
main1.c和main2.c里都有主函数，需要调用lib.c里的求和函数，只是所传递的参数值不同。要求通过根目录下的makefile嵌套调用子目录下的makefile来编译，最后链接生成可执行文件edit1和edit2，最后执行edit1和edit2应该能得到两个不同的值（也就是lib.c所求得的和）。
好了，我就不贴三个源文件的C代码了，大家自己写用来测试，我就直接贴makefile的编写了。
首先是子目录sub1下的makefile：
sub1.o : sub1.c
gcc-c sub1.c
接下来是子目录sub2下的makefile：
Makefile使用总结
Makefile使⽤总结1. Makefile 简介Makefile 是和 make 命令⼀起配合使⽤的.很多⼤型项⽬的编译都是通过 Makefile 来组织的, 如果没有 Makefile, 那很多项⽬中各种库和代码之间的依赖关系不知会多复杂. Makefile的组织流程的能⼒如此之强, 不仅可以⽤来编译项⽬, 还可以⽤来组织我们平时的⼀些⽇常操作. 这个需要⼤家发挥⾃⼰的想象⼒.本篇博客是基于⽽整理的, 有些删减, 追加了⼀些⽰例.⾮常感谢 gunguymadman_cu 提供如此详尽的Makefile介绍, 这正是我⼀直寻找的Makefile中⽂⽂档.1.1 Makefile 主要的 5个部分 (显⽰规则, 隐晦规则, 变量定义, ⽂件指⽰, 注释)Makefile基本格式如下:target ... : prerequisites ...command......其中,target - ⽬标⽂件, 可以是 Object File, 也可以是可执⾏⽂件prerequisites - ⽣成 target 所需要的⽂件或者⽬标command - make需要执⾏的命令 (任意的shell命令), Makefile中的命令必须以 [tab] 开头1. 显⽰规则 :: 说明如何⽣成⼀个或多个⽬标⽂件(包括⽣成的⽂件, ⽂件的依赖⽂件, ⽣成的命令)2. 隐晦规则 :: make的⾃动推导功能所执⾏的规则3. 变量定义 :: Makefile中定义的变量4. ⽂件指⽰ :: Makefile中引⽤其他Makefile; 指定Makefile中有效部分; 定义⼀个多⾏命令5. 注释 :: Makefile只有⾏注释 "#", 如果要使⽤或者输出"#"字符, 需要进⾏转义, "\#"1.2 GNU make 的⼯作⽅式1. 读⼊主Makefile (主Makefile中可以引⽤其他Makefile)2. 读⼊被include的其他Makefile3. 初始化⽂件中的变量4. 推导隐晦规则, 并分析所有规则5. 为所有的⽬标⽂件创建依赖关系链6. 根据依赖关系, 决定哪些⽬标要重新⽣成7. 执⾏⽣成命令2. Makefile 初级语法2.1 Makefile 规则2.1.1 规则语法规则主要有2部分: 依赖关系和⽣成⽬标的⽅法.语法有以下2种:target ... : prerequisites ...command...或者target ... : prerequisites ; commandcommand...*注* command太长, 可以⽤ "\" 作为换⾏符2.1.2 规则中的通配符* :: 表⽰任意⼀个或多个字符:: 表⽰任意⼀个字符[...] :: ex. [abcd] 表⽰a,b,c,d中任意⼀个字符, [^abcd]表⽰除a,b,c,d以外的字符, [0-9]表⽰ 0~9中任意⼀个数字~ :: 表⽰⽤户的home⽬录2.1.3 路径搜索当⼀个Makefile中涉及到⼤量源⽂件时(这些源⽂件和Makefile极有可能不在同⼀个⽬录中),这时, 最好将源⽂件的路径明确在Makefile中, 便于编译时查找. Makefile中有个特殊的变量VPATH就是完成这个功能的.指定了VPATH之后, 如果当前⽬录中没有找到相应⽂件或依赖的⽂件, Makefile 回到VPATH指定的路径中再去查找.. VPATH使⽤⽅法:vpath <directories> :: 当前⽬录中找不到⽂件时, 就从<directories>中搜索vpath <pattern> <directories> :: 符合<pattern>格式的⽂件, 就从<directories>中搜索vpath <pattern> :: 清除符合<pattern>格式的⽂件搜索路径vpath :: 清除所有已经设置好的⽂件路径# ⽰例1 - 当前⽬录中找不到⽂件时, 按顺序从 src⽬录 ../parent-dir⽬录中查找⽂件VPATH src:../parent-dir# ⽰例2 - .h结尾的⽂件都从 ./header ⽬录中查找VPATH %.h ./header# ⽰例3 - 清除⽰例2中设置的规则VPATH %.h# ⽰例4 - 清除所有VPATH的设置VPATH2.2 Makefile 中的变量2.2.1 变量定义 ( = or := )OBJS = programA.o programB.oOBJS-ADD = $(OBJS) programC.o# 或者OBJS := programA.o programB.oOBJS-ADD := $(OBJS) programC.o其中 = 和 := 的区别在于, := 只能使⽤前⾯定义好的变量, = 可以使⽤后⾯定义的变量测试 =# Makefile内容OBJS2 = $(OBJS1) programC.oOBJS1 = programA.o programB.oall:@echo $(OBJS2)# bash中执⾏make, 可以看出虽然 OBJS1 是在 OBJS2 之后定义的, 但在 OBJS2中可以提前使⽤$ makeprogramA.o programB.o programC.o测试 :=# Makefile内容OBJS2 := $(OBJS1) programC.oOBJS1 := programA.o programB.oall:@echo $(OBJS2)# bash中执⾏make, 可以看出 OBJS2 中的 $(OBJS1) 为空$ makeprogramC.o2.2.2 变量替换# Makefile内容SRCS := programA.c programB.c programC.cOBJS := $(SRCS:%.c=%.o)all:@echo "SRCS: " $(SRCS)@echo "OBJS: " $(OBJS)# bash中运⾏make$ makeSRCS: programA.c programB.c programC.cOBJS: programA.o programB.o programC.o2.2.3 变量追加值 +=# Makefile内容SRCS := programA.c programB.c programC.cSRCS += programD.call:@echo "SRCS: " $(SRCS)# bash中运⾏make$ makeSRCS: programA.c programB.c programC.c programD.c2.2.4 变量覆盖 override作⽤是使 Makefile中定义的变量能够覆盖 make 命令参数中指定的变量语法:override <variable> = <value>override <variable> := <value>override <variable> += <value>下⾯通过⼀个例⼦体会 override 的作⽤：# Makefile内容 (没有⽤override)SRCS := programA.c programB.c programC.call:@echo "SRCS: " $(SRCS)# bash中运⾏make$ make SRCS=nothingSRCS: nothing################################################## Makefile内容 (⽤override)override SRCS := programA.c programB.c programC.call:@echo "SRCS: " $(SRCS)# bash中运⾏make$ make SRCS=nothingSRCS: programA.c programB.c programC.c2.2.5 ⽬标变量作⽤是使变量的作⽤域仅限于这个⽬标(target), ⽽不像之前例⼦中定义的变量, 对整个Makefile都有效.语法:<target ...> :: <variable-assignment><target ...> :: override <variable-assignment> (override作⽤参见变量覆盖的介绍)⽰例:# Makefile 内容SRCS := programA.c programB.c programC.ctarget1: TARGET1-SRCS := programD.ctarget1:@echo "SRCS: " $(SRCS)@echo "SRCS: " $(TARGET1-SRCS)target2:@echo "SRCS: " $(SRCS)@echo "SRCS: " $(TARGET1-SRCS)# bash中执⾏make$ make target1SRCS: programA.c programB.c programC.cSRCS: programD.c$ make target2 <-- target2中显⽰不了 $(TARGET1-SRCS)SRCS: programA.c programB.c programC.cSRCS:2.3 Makefile 命令前缀Makefile 中书写shell命令时可以加2种前缀 @ 和 -, 或者不⽤前缀.3种格式的shell命令区别如下:不⽤前缀 :: 输出执⾏的命令以及命令执⾏的结果, 出错的话停⽌执⾏前缀 @ :: 只输出命令执⾏的结果, 出错的话停⽌执⾏前缀 - :: 命令执⾏有错的话, 忽略错误, 继续执⾏⽰例:# Makefile 内容 (不⽤前缀)all:echo"没有前缀"cat this_file_not_existecho"错误之后的命令" <-- 这条命令不会被执⾏# bash中执⾏make$ makeecho"没有前缀" <-- 命令本⾝显⽰出来没有前缀 <-- 命令执⾏结果显⽰出来cat this_file_not_existcat: this_file_not_exist: No such file or directorymake: *** [all] Error 1############################################################ Makefile 内容 (前缀 @)all:@echo "没有前缀"@cat this_file_not_exist@echo "错误之后的命令" <-- 这条命令不会被执⾏# bash中执⾏make$ make没有前缀 <-- 只有命令执⾏的结果, 不显⽰命令本⾝cat: this_file_not_exist: No such file or directorymake: *** [all] Error 1############################################################ Makefile 内容 (前缀 -)all:-echo"没有前缀"-cat this_file_not_exist-echo"错误之后的命令" <-- 这条命令会被执⾏# bash中执⾏make$ makeecho"没有前缀" <-- 命令本⾝显⽰出来没有前缀 <-- 命令执⾏结果显⽰出来cat this_file_not_existcat: this_file_not_exist: No such file or directorymake: [all] Error 1 (ignored)echo"错误之后的命令" <-- 出错之后的命令也会显⽰错误之后的命令 <-- 出错之后的命令也会执⾏2.4 伪⽬标伪⽬标并不是⼀个"⽬标(target)", 不像真正的⽬标那样会⽣成⼀个⽬标⽂件.典型的伪⽬标是 Makefile 中⽤来清理编译过程中中间⽂件的 clean 伪⽬标, ⼀般格式如下: .PHONY: clean <-- 这句没有也⾏, 但是最好加上clean:-rm -f *.o2.5 引⽤其他的 Makefile语法: include <filename> (filename 可以包含通配符和路径)⽰例:# Makefile 内容all:@echo "主 Makefile begin"@make other-all@echo "主 Makefile end"include ./other/Makefile# ./other/Makefile 内容other-all:@echo "other makefile begin"@echo "other makefile end"# bash中执⾏make$ lltotal 20K-rw-r--r-- 1 wangyubin wangyubin 125 Sep 2316:13 Makefile-rw-r--r-- 1 wangyubin wangyubin 11K Sep 2316:15 <-- 这个⽂件不⽤管drwxr-xr-x 2 wangyubin wangyubin 4.0K Sep 2316:11 other$ ll other/total 4.0K-rw-r--r-- 1 wangyubin wangyubin 71 Sep 2316:11 Makefile$ make主 Makefile beginmake[1]: Entering directory `/path/to/test/makefile'other makefile beginother makefile endmake[1]: Leaving directory `/path/to/test/makefile'主 Makefile end2.6 查看C⽂件的依赖关系写 Makefile 的时候, 需要确定每个⽬标的依赖关系.GNU提供⼀个机制可以查看C代码⽂件依赖那些⽂件, 这样我们在写 Makefile ⽬标的时候就不⽤打开C源码来看其依赖那些⽂件了.⽐如, 下⾯命令显⽰内核源码中 virt/kvm/kvm_main.c 中的依赖关系$ cd virt/kvm/$ gcc -MM kvm_main.ckvm_main.o: kvm_main.c iodev.h coalesced_mmio.h async_pf.h <-- 这句就可以加到 Makefile 中作为编译 kvm_main.o 的依赖关系2.7 make 退出码Makefile的退出码有以下3种：0 :: 表⽰成功执⾏1 :: 表⽰make命令出现了错误2 :: 使⽤了 "-q" 选项, 并且make使得⼀些⽬标不需要更新2.8 指定 Makefile，指定特定⽬标默认执⾏ make 命令时, GNU make在当前⽬录下依次搜索下⾯3个⽂件 "GNUmakefile", "makefile", "Makefile",找到对应⽂件之后, 就开始执⾏此⽂件中的第⼀个⽬标(target). 如果找不到这3个⽂件就报错.⾮默认情况下, 可以在 make 命令中指定特定的 Makefile 和特定的⽬标.⽰例：# Makefile⽂件名改为 MyMake, 内容target1:@echo "target [1] begin"@echo "target [1] end"target2:@echo "target [2] begin"@echo "target [2] end"# bash 中执⾏make$ lsMakefile$ mv Makefile MyMake$ lsMyMake$ make <-- 找不到默认的 Makefilemake: *** No targets specified and no makefile found. Stop.$ make -f MyMake <-- 指定特定的Makefiletarget [1] begintarget [1] end$ make -f MyMake target2 <-- 指定特定的⽬标(target)target [2] begintarget [2] end2.9 make 参数介绍make 的参数有很多, 可以通过 make -h 去查看, 下⾯只介绍⼏个我认为⽐较有⽤的.参数含义--debug[=<options>]输出make的调试信息, options 可以是 a, b, v-j --jobs同时运⾏的命令的个数, 也就是多线程执⾏ Makefile-r --no-builtin-rules禁⽌使⽤任何隐含规则-R --no-builtin-variabes禁⽌使⽤任何作⽤于变量上的隐含规则-B --always-make假设所有⽬标都有更新, 即强制重编译2.10 Makefile 隐含规则这⾥只列⼀个和编译C相关的.编译C时，<n>.o 的⽬标会⾃动推导为 <n>.c# Makefile 中main : main.ogcc -o main main.o#会⾃动变为:main : main.ogcc -o main main.omain.o: main.c <-- main.o 这个⽬标是隐含⽣成的gcc -c main.c2.11 隐含规则中的命令变量和命令参数变量2.11.1 命令变量, 书写Makefile可以直接写 shell时⽤这些变量.下⾯只列出⼀些C相关的变量名含义RM rm -fAR arCC ccCXX g++⽰例:# Makefile 内容all:@echo $(RM)@echo $(AR)@echo $(CC)@echo $(CXX)# bash 中执⾏make, 显⽰各个变量的值$ makerm -farccg++2.11.2 命令参数变量变量名含义ARFLAGS AR命令的参数CFLAGS C语⾔编译器的参数CXXFLAGS C++语⾔编译器的参数⽰例: 下⾯以 CFLAGS 为例演⽰# test.c 内容#include <stdio.h>int main(int argc, char *argv[]){printf ("Hello Makefile\n");return 0;}# Makefile 内容test: test.o$(CC) -o test test.o# bash 中⽤make来测试$ lltotal 24K-rw-r--r-- 1 wangyubin wangyubin 69 Sep 2317:31 Makefile-rw-r--r-- 1 wangyubin wangyubin 14K Sep 2319:51 <-- 请忽略这个⽂件-rw-r--r-- 1 wangyubin wangyubin 392 Sep 2317:31 test.c$ makecc -c -o test.o test.ccc -o test test.o <-- 这个是⾃动推导的$ rm -f test test.o$ make CFLAGS=-Wall <-- 命令中加的编译器参数⾃动追加⼊下⾯的编译中了cc -Wall -c -o test.o test.ccc -o test test.o2.12 ⾃动变量Makefile 中很多时候通过⾃动变量来简化书写, 各个⾃动变量的含义如下:⾃动变量含义$@⽬标集合$%当⽬标是函数库⽂件时, 表⽰其中的⽬标⽂件名$<第⼀个依赖⽬标. 如果依赖⽬标是多个, 逐个表⽰依赖⽬标$?⽐⽬标新的依赖⽬标的集合$^所有依赖⽬标的集合, 会去除重复的依赖⽬标$+所有依赖⽬标的集合, 不会去除重复的依赖⽬标$*这个是GNU make特有的, 其它的make不⼀定⽀持3. Makefile ⾼级语法3.1 嵌套Makefile在 Makefile 初级语法中已经提到过引⽤其它 Makefile的⽅法. 这⾥有另⼀种写法, 并且可以向引⽤的其它 Makefile 传递参数.⽰例: (不传递参数, 只是调⽤⼦⽂件夹 other 中的Makefile)# Makefile 内容all:@echo "主 Makefile begin"@cd ./other && make@echo "主 Makefile end"# ./other/Makefile 内容other-all:@echo "other makefile begin"@echo "other makefile end"# bash中执⾏make$ lltotal 28K-rw-r--r-- 1 wangyubin wangyubin 104 Sep 2320:43 Makefile-rw-r--r-- 1 wangyubin wangyubin 17K Sep 2320:44 <-- 这个⽂件不⽤管drwxr-xr-x 2 wangyubin wangyubin 4.0K Sep 2320:42 other$ ll other/total 4.0K-rw-r--r-- 1 wangyubin wangyubin 71 Sep 2316:11 Makefile$ make主 Makefile beginmake[1]: Entering directory `/path/to/test/makefile/other'other makefile beginother makefile endmake[1]: Leaving directory `/path/to/test/makefile/other'主 Makefile end⽰例: (⽤export传递参数)# Makefile 内容export VALUE1 := export.c <-- ⽤了 export, 此变量能够传递到 ./other/Makefile 中VALUE2 := no-export.c <-- 此变量不能传递到 ./other/Makefile 中all:@echo "主 Makefile begin"@cd ./other && make@echo "主 Makefile end"# ./other/Makefile 内容other-all:@echo "other makefile begin"@echo "VALUE1: " $(VALUE1)@echo "VALUE2: " $(VALUE2)@echo "other makefile end"# bash中执⾏make$ make主 Makefile beginmake[1]: Entering directory `/path/to/test/makefile/other'other makefile beginVALUE1: export.c <-- VALUE1 传递成功VALUE2: <-- VALUE2 传递失败other makefile endmake[1]: Leaving directory `/path/to/test/makefile/other'主 Makefile end*补充* export 语法格式如下:export variable = valueexport variable := valueexport variable += value3.2 定义命令包命令包有点像是个函数, 将连续的相同的命令合成⼀条, 减少 Makefile 中的代码量, 便于以后维护.语法:define <command-name>command...endef⽰例:# Makefile 内容define run-hello-makefile@echo -n "Hello"@echo " Makefile!"@echo "这⾥可以执⾏多条 Shell 命令!"endefall:$(run-hello-makefile)# bash 中运⾏make$ makeHello Makefile!这⾥可以执⾏多条 Shell 命令!3.3 条件判断条件判断的关键字主要有 ifeq ifneq ifdef ifndef语法:<conditional-directive><text-if-true>endif# 或者<conditional-directive><text-if-true>else<text-if-false>endif⽰例: ifeq的例⼦, ifneq和ifeq的使⽤⽅法类似, 就是取反# Makefile 内容all:ifeq ("aa", "bb")@echo "equal"else@echo "not equal"endif# bash 中执⾏make$ makenot equal⽰例: ifdef的例⼦, ifndef和ifdef的使⽤⽅法类似, 就是取反# Makefile 内容SRCS := program.call:ifdef SRCS@echo $(SRCS)else@echo "no SRCS"# bash 中执⾏make$ makeprogram.c3.4 Makefile 中的函数Makefile 中⾃带了⼀些函数, 利⽤这些函数可以简化 Makefile 的编写.函数调⽤语法如下:$(<function> <arguments>)# 或者${<function> <arguments>}<function> 是函数名<arguments> 是函数参数3.4.1 字符串函数字符串替换函数: $(subst <from>,<to>,<text>)功能: 把字符串<text> 中的 <from> 替换为 <to>返回: 替换过的字符串# Makefile 内容all:@echo $(subst t,e,maktfilt) <-- 将t替换为e# bash 中执⾏make$ makemakefile模式字符串替换函数: $(patsubst <pattern>,<replacement>,<text>)功能: 查找<text>中的单词(单词以"空格", "tab", "换⾏"来分割) 是否符合 <pattern>, 符合的话, ⽤ <replacement> 替代.返回: 替换过的字符串# Makefile 内容all:@echo $(patsubst %.c,%.o,programA.c programB.c)# bash 中执⾏make$ makeprogramA.o programB.o去空格函数: $(strip <string>)功能: 去掉 <string> 字符串中开头和结尾的空字符返回: 被去掉空格的字符串值# Makefile 内容VAL := " aa bb cc "all:@echo "去除空格前: " $(VAL)@echo "去除空格后: " $(strip $(VAL))# bash 中执⾏make去除空格前: aa bb cc去除空格后: aa bb cc查找字符串函数: $(findstring <find>,<in>)功能: 在字符串 <in> 中查找 <find> 字符串返回: 如果找到, 返回 <find> 字符串, 否则返回空字符串# Makefile 内容VAL := " aa bb cc "all:@echo $(findstring aa,$(VAL))@echo $(findstring ab,$(VAL))# bash 中执⾏make$ makeaa过滤函数: $(filter <pattern...>,<text>)功能: 以 <pattern> 模式过滤字符串 <text>, *保留* 符合模式 <pattern> 的单词, 可以有多个模式返回: 符合模式 <pattern> 的字符串# Makefile 内容all:@echo $(filter %.o %.a,program.c program.o program.a)# bash 中执⾏make$ makeprogram.o program.a反过滤函数: $(filter-out <pattern...>,<text>)功能: 以 <pattern> 模式过滤字符串 <text>, *去除* 符合模式 <pattern> 的单词, 可以有多个模式返回: 不符合模式 <pattern> 的字符串# Makefile 内容all:@echo $(filter-out %.o %.a,program.c program.o program.a)# bash 中执⾏make$ makeprogram.c排序函数: $(sort <list>)功能: 给字符串 <list> 中的单词排序 (升序)返回: 排序后的字符串# Makefile 内容all:@echo $(sort bac abc acb cab)# bash 中执⾏make$ makeabc acb bac cab取单词函数: $(word <n>,<text>)功能: 取字符串 <text> 中的第<n>个单词 (n从1开始)返回: <text> 中的第<n>个单词, 如果<n> ⽐ <text> 中单词个数要⼤, 则返回空字符串# Makefile 内容all:@echo $(word 1,aa bb cc dd)@echo $(word 5,aa bb cc dd)@echo $(word 4,aa bb cc dd)# bash 中执⾏make$ makeaadd取单词串函数: $(wordlist <s>,<e>,<text>)功能: 从字符串<text>中取从<s>开始到<e>的单词串. <s>和<e>是⼀个数字.返回: 从<s>到<e>的字符串# Makefile 内容all:@echo $(wordlist 1,3,aa bb cc dd)@echo $(word 5,6,aa bb cc dd)@echo $(word 2,5,aa bb cc dd)# bash 中执⾏make$ makeaa bb ccbb单词个数统计函数: $(words <text>)功能: 统计字符串 <text> 中单词的个数返回: 单词个数# Makefile 内容all:@echo $(words aa bb cc dd)@echo $(words aabbccdd)@echo $(words )# bash 中执⾏make$ make41⾸单词函数: $(firstword <text>)功能: 取字符串 <text> 中的第⼀个单词返回: 字符串 <text> 中的第⼀个单词# Makefile 内容all:@echo $(firstword aa bb cc dd)@echo $(firstword aabbccdd)@echo $(firstword )# bash 中执⾏make$ makeaaaabbccdd3.4.2 ⽂件名函数取⽬录函数: $(dir <names...>)功能: 从⽂件名序列 <names> 中取出⽬录部分返回: ⽂件名序列 <names> 中的⽬录部分# Makefile 内容all:@echo $(dir /home/a.c ./bb.c ../c.c d.c)# bash 中执⾏make$ make/home/ ./ ../ ./取⽂件函数: $(notdir <names...>)功能: 从⽂件名序列 <names> 中取出⾮⽬录部分返回: ⽂件名序列 <names> 中的⾮⽬录部分# Makefile 内容all:@echo $(notdir /home/a.c ./bb.c ../c.c d.c)# bash 中执⾏make$ makea.c bb.cc.cd.c取后缀函数: $(suffix <names...>)功能: 从⽂件名序列 <names> 中取出各个⽂件名的后缀返回: ⽂件名序列 <names> 中各个⽂件名的后缀, 没有后缀则返回空字符串# Makefile 内容all:@echo $(suffix /home/a.c ./b.o ../c.a d)# bash 中执⾏make$ make.c .o .a取前缀函数: $(basename <names...>)功能: 从⽂件名序列 <names> 中取出各个⽂件名的前缀返回: ⽂件名序列 <names> 中各个⽂件名的前缀, 没有前缀则返回空字符串# Makefile 内容all:@echo $(basename /home/a.c ./b.o ../c.a /home/.d .e)# bash 中执⾏make$ make/home/a ./b ../c /home/加后缀函数: $(addsuffix <suffix>,<names...>)功能: 把后缀 <suffix> 加到 <names> 中的每个单词后⾯返回: 加过后缀的⽂件名序列# Makefile 内容all:@echo $(addsuffix .c,/home/a b ./c.o ../d.c)# bash 中执⾏make$ make/home/a.c b.c ./c.o.c ../d.c.c加前缀函数: $(addprefix <prefix>,<names...>)功能: 把前缀 <prefix> 加到 <names> 中的每个单词前⾯返回: 加过前缀的⽂件名序列# Makefile 内容all:@echo $(addprefix test_,/home/a.c b.c ./d.c)# bash 中执⾏make$ maketest_/home/a.c test_b.c test_./d.c连接函数: $(join <list1>,<list2>)功能: <list2> 中对应的单词加到 <list1> 后⾯返回: 连接后的字符串# Makefile 内容all:@echo $(join a b c d,1234)@echo $(join a b c d,12345)@echo $(join a b c d e,1234)# bash 中执⾏make$ makea1 b2 c3 d4a1 b2 c3 d4 5a1 b2 c3 d4 e3.4.3 foreach语法:$(foreach <var>,<list>,<text>)⽰例:# Makefile 内容targets := a b c dobjects := $(foreach i,$(targets),$(i).o)all:@echo $(targets)@echo $(objects)# bash 中执⾏make$ makea b c da.ob.oc.od.o3.4.4 if这⾥的if是个函数, 和前⾯的条件判断不⼀样, 前⾯的条件判断属于Makefile的关键字语法:$(if <condition>,<then-part>)$(if <condition>,<then-part>,<else-part>)⽰例:# Makefile 内容val := aobjects := $(if $(val),$(val).o,nothing)no-objects := $(if $(no-val),$(val).o,nothing)all:@echo $(objects)@echo $(no-objects)# bash 中执⾏make$ makea.onothing3.4.5 call - 创建新的参数化函数语法:$(call <expression>,<parm1>,<parm2>,<parm3>...)⽰例:# Makefile 内容log = "====debug====" $(1) "====end===="all:@echo $(call log,"正在 Make")# bash 中执⾏make$ make====debug==== 正在 Make ====end====3.4.6 origin - 判断变量的来源语法:$(origin <variable>)返回值有如下类型:类型含义undefined<variable> 没有定义过default<variable> 是个默认的定义, ⽐如 CC 变量environment<variable> 是个环境变量, 并且 make时没有使⽤ -e 参数file<variable> 定义在Makefile中command line<variable> 定义在命令⾏中override<variable> 被 override 重新定义过automatic<variable> 是⾃动化变量⽰例:# Makefile 内容val-in-file := test-fileoverride val-override := test-overrideall:@echo $(origin not-define) # not-define 没有定义@echo $(origin CC) # CC 是Makefile默认定义的变量@echo $(origin PATH) # PATH 是 bash 环境变量@echo $(origin val-in-file) # 此Makefile中定义的变量@echo $(origin val-in-cmd) # 这个变量会加在make的参数中@echo $(origin val-override) # 此Makefile中定义的override变量@echo $(origin @) # ⾃动变量, 具体前⾯的介绍# bash 中执⾏make$ make val-in-cmd=val-cmdundefineddefaultenvironmentfilecommand lineoverrideautomatic3.4.7 shell语法:$(shell <shell command>)它的作⽤就是执⾏⼀个shell命令, 并将shell命令的结果作为函数的返回.作⽤和 `<shell command>` ⼀样, ` 是反引号3.4.8 make 控制函数产⽣⼀个致命错误: $(error <text ...>)功能: 输出错误信息, 停⽌Makefile的运⾏# Makefile 内容all:$(error there is an error!)@echo "这⾥不会执⾏!"# bash 中执⾏make$ makeMakefile:2: *** there is an error!. Stop.输出警告: $(warning <text ...>)功能: 输出警告信息, Makefile继续运⾏# Makefile 内容all:$(warning there is an warning!)@echo "这⾥会执⾏!"# bash 中执⾏make$ makeMakefile:2: there is an warning!这⾥会执⾏!3.5 Makefile中⼀些GNU约定俗成的伪⽬标如果有过在Linux上, 从源码安装软件的经历的话, 就会对 make clean, make install ⽐较熟悉.像 clean, install 这些伪⽬标, ⼴为⼈知, 不⽤解释就⼤家知道是什么意思了.下⾯列举⼀些常⽤的伪⽬标, 如果在⾃⼰项⽬的Makefile合理使⽤这些伪⽬标的话, 可以让我们⾃⼰的Makefile看起来更专业, 呵呵 :)伪⽬标含义all所有⽬标的⽬标，其功能⼀般是编译所有的⽬标clean删除所有被make创建的⽂件install安装已编译好的程序，其实就是把⽬标可执⾏⽂件拷贝到指定的⽬录中去print列出改变过的源⽂件tar把源程序打包备份. 也就是⼀个tar⽂件dist创建⼀个压缩⽂件, ⼀般是把tar⽂件压成Z⽂件. 或是gz⽂件TAGS更新所有的⽬标, 以备完整地重编译使⽤check 或 test⼀般⽤来测试makefile的流程。
makefile 运算
makefile 运算
在Makefile中，可以使用一些内置的操作符和函数进行一些运算。
下面是一些常用的运算方式：1. 变量运算：- 赋值运算：使用`=` 或`:=` 进行变量赋值。
- 字符串拼接：使用`(var1)(var2)` 进行字符串拼接。
2. 算术运算：- 加法：`(shell expr (var1) + (var2))`，使用`expr`命令进行加法运算。
- 减法：`(shell expr (var1) - (var2))`，使用`expr`命令进行减法运算。
- 乘法：`(shell expr (var1) \* (var2))`，使用`expr`命令进行乘法运算。
- 除法：`(shell expr (var1) / (var2))`，使用`expr`命令进行除法运算。
3. 逻辑运算：- 比较运算：可以使用内置的条件函数`ifeq`、`ifneq`、`ifdef` 和`ifndef` 进行比较运算，返回一个条件判断结果作为变量的值。
- 逻辑运算符：可以使用逻辑运算符`&&` 和` ` 进行逻辑运算。
4. 条件判断：- 条件判断语句：使用`ifeq`、`ifneq`、`ifdef` 和`ifndef` 来进行条件判断。
- 条件赋值：可以使用条件判断来动态赋值变量。
这些是在Makefile中常用的一些运算方式，可以根据具体的需求和场景来选择合适的运算方式。
makefile 命令行参数
-C选项可以指定Makefile所在的路径。如果我们在当前路径下执行make命令，但是Makefile文件不在当前路径下，那么就需要使用-C选项来指定Makefile所在的路径。例如：
make -C /path/to/Makefile
3. -f选项
-f选项可以指定要使用的Makefile文件名。如果我们有多个Makefile文件，那么就可以使用-f选项来指定要使用哪个Makefile文件。例如：
makefile 命令行参数
Makefile是一种用来管理代码编译的工具，它可以自动化执行编译任务，帮助程序员更高效地管理代码。在Makefile中，可以定义一系列规则来指定如何编译代码。在使用Makefile时，我们可以通过命令行参数来控制编译过程的行为。本文将详细介绍makefile命令行参数的使用方法。项
-j选项可以指定并行编译时所使用的线程数。如果我们有多个CPU核心，并且要编译大型项目，那么就可以使用-j选项来加速编译过程。例如：
make -j4
5. --dry-run选项
--dry-run选项可以模拟执行make命令，并输出将要执行的命令列表，但是并不会真正地执行这些命令。这个功能非常实用，因为我们可以预先查看将要执行的命令，确保它们是正确的。例如：
这样做的好处是，我们可以在不修改Makefile的情况下，通过命令行参数来控制编译过程的行为。
四、总结
本文介绍了Makefile命令行参数的用法，包括make命令、-C选项、-f选项、-j选项、--dry-run选项和--print-data-base选项。同时，本文还介绍了一些Makefile常用技巧，包括使用变量来存储编译选项、使用通配符来自动生成目标文件列表和使用命令行参数来控制编译过程。希望本文能够对大家理解和学习Makefile有所帮助。
makefile四则运算
makefile四则运算标题：深入理解Makefile中的四则运算在软件开发过程中，Makefile是一个非常重要的工具，它主要用于自动化编译和链接程序。
而在Makefile中，我们可以使用一些特殊的语法进行数学运算，包括四则运算（加、减、乘、除）。
本文将详细解析Makefile 中的四则运算，帮助你更好地理解和使用这一功能。
一、Makefile中的变量与赋值在开始四则运算之前，我们首先需要了解Makefile中的变量和赋值。
在Makefile中，我们可以使用"="或者":="来为变量赋值。
其中"="表示延迟赋值，会在需要时才进行计算；而":="表示立即赋值，会在定义时就进行计算。
例如：VAR1 = 10VAR2 := 20在这段代码中，VAR1被赋值为10，VAR2被赋值为20。
二、Makefile中的四则运算在Makefile中，我们可以使用"(shell expr ...)"命令来进行四则运算。
这个命令会执行shell命令expr，并将结果返回。
以下是一些基本的四则运算示例：1. 加法：makefileSUM := (shell expr (VAR1) + (VAR2))在这个例子中，SUM会被赋值为VAR1和VAR2的和，即30。
2. 减法：makefileDIFF := (shell expr (VAR1) - (VAR2))在这个例子中，DIFF会被赋值为VAR1和VAR2的差，即-10。
3. 乘法：makefilePRODUCT := (shell expr (VAR1) \* (VAR2))注意，由于"*"在Makefile中有特殊含义，所以我们需要使用"\*"来表示乘法。
在这个例子中，PRODUCT会被赋值为VAR1和VAR2的乘积，即200。
linux makefile include用法
在 Linux 中，Makefile 是一种文本文件，用于定义项目的构建规则和依赖关系。
include是 Makefile 中的一个关键字，用于引入其他 Makefile 文件。
这对于将构建规则拆分为多个文件以提高可维护性非常有用。
以下是关于include在 Linux Makefile 中的用法的详细解释：include的基本语法：•include后面可以跟一个或多个文件名，用空格分隔。
•这些文件名可以包含通配符，例如*.mk。
示例：假设有两个 Makefile 文件，分别是main.mk和extra.mk。
main.mkextra.mk在上述例子中，main.mk包含了extra.mk。
这样，main.mk中的规则就可以使用extra.mk中定义的规则和变量。
使用场景和注意事项：1.模块化项目：–include用于将项目的不同部分拆分为独立的 Makefile，使得项目结构更加清晰和易于维护。
2.变量和规则共享：–通过include，可以在不同的 Makefile 文件中共享变量和规则，避免代码重复。
3.条件包含：–可以根据条件来选择是否包含某个 Makefile，例如基于不同的操作系统或构建类型。
1.文件名通配符：–include后面可以使用通配符，方便引入符合某个模式的多个文件。
注意事项：•文件名可以是相对路径或绝对路径。
•文件名中可以包含变量，这样可以动态地选择引入的文件。
•在引入文件时，Makefile 会在当前目录和系统的默认搜索路径中查找文件。
通过合理使用include，可以更好地组织和管理项目的构建规则，提高 Makefile 的可读性和可维护性。
makefile export用法
Makefile export用法在软件开发过程中，Makefile是一种非常重要的工具，它可以帮助开发人员自动化构建和管理项目。
其中，export命令是Makefile中一个非常有用的功能，它可以将变量导出给子进程使用。
在本篇文章中，我们将深入探讨Makefile中export命令的用法，包括其作用、语法和实际应用。
1. 作用和用法在Makefile中，export命令用于将变量导出给子进程使用。
这意味着在Makefile的规则中，可以使用export命令将某个变量导出，以便在子进程中使用。
这样可以在子进程中方便地获取父进程中的变量，从而实现更加灵活和高效的构建过程。
export命令的语法非常简单，只需在Makefile中写入“export 变量名”，即可将指定的变量导出给子进程使用。
例如：```export CC = gcc```2. 实际应用在实际的项目中，export命令通常用于将一些全局变量导出给子进程使用。
我们可以在Makefile中定义一些编译器或信息器的选项，并使用export命令将其导出，以便在编译或信息过程中使用。
这样可以避免在每个规则中都重新定义相同的选项，提高了代码的重用性和可维护性。
另外，export命令也可以用于在子进程中调用其他脚本或工具时传递参数。
我们可以在Makefile中定义一些参数，并使用export命令将其导出给子进程。
这样可以在不同的规则中方便地传递参数，避免了重复的代码和参数传递过程。
3. 个人观点在我看来，export命令在Makefile中的作用非常重要。
它可以帮助我们更加灵活和高效地管理变量，提高了代码的重用性和可维护性。
在实际的项目中，合理地使用export命令可以简化编译和信息过程，提高了项目的构建速度和质量。
我认为掌握export命令的用法对于编写高质量的Makefile非常重要。
总结通过本文的介绍，我们详细地了解了Makefile中export命令的作用、语法和实际应用。
makefile if用法
makefile if用法Makefile 是一种常用的构建工具，用于自动化构建软件项目。
在Makefile 中，if 语句能够根据条件来选择不同的命令或变量赋值。
本文将逐步介绍Makefile 中if 语句的用法，包括条件判断、变量赋值、嵌套使用等方面的内容。
首先，我们需要了解Makefile 中if 语句的基本语法。
if 语句可以写在任何位置，但通常我们将其放在文件的顶部，用于设置全局变量或选择不同的命令。
if 语句的基本结构如下：ifeq (条件,值)# 条件成立时执行的命令或变量赋值else# 条件不成立时执行的命令或变量赋值endif在这个基本结构中，ifeq 为条件判断语句，它用于判断条件是否等于某个值。
若条件成立，则执行if 代码块内的命令或进行变量赋值，否则执行else 代码块内的命令或变量赋值。
endif 表示if 语句的结束。
接下来，我们来看一些具体的示例，以帮助理解if 语句的用法。
1. 条件判断：在Makefile 中，我们可以使用各种条件进行判断。
以下是一些常用的判断方式：- 变量是否为空：ifeq ((VAR),)# VAR 为空时执行的命令或变量赋值else# VAR 不为空时执行的命令或变量赋值endif- 变量是否等于某个值：ifeq ((VAR),某个值)# VAR 等于某个值时执行的命令或变量赋值else# VAR 不等于某个值时执行的命令或变量赋值endif- 多个条件判断：ifeq ((VAR),某个值)# VAR 等于某个值时执行的命令或变量赋值else ifeq ((VAR),另一个值)# VAR 等于另一个值时执行的命令或变量赋值else# VAR 既不等于某个值，也不等于另一个值时执行的命令或变量赋值endif2. 变量赋值：在if 语句中，我们可以根据条件选择不同的变量赋值，使得程序更具有灵活性。
以下示例展示了如何根据条件选择不同的变量赋值：ifeq ((OS),Linux)# OS 等于Linux 时，执行以下变量赋值CC = gccelse# OS 不等于Linux 时，执行以下变量赋值CC = clangendif根据上述示例，当操作系统为Linux 时，CC 的值将被赋为gcc，否则为clang。
makefile文件中ldflags参数的用法
makefile文件中ldflags参数的用法在Makefile文件中，`LDFLAGS`是一个用于传递链接器选项的变量。
它用于指定链接时所需的库文件、库路径和其他链接器选项。
`LDFLAGS`变量的用法如下：1. 指定库文件：LDFLAGS = -l<library_name>例如，要链接`libfoo.so`库文件，可以使用`LDFLAGS = -lfoo`。
2. 指定库路径：LDFLAGS = -L<path_to_library>例如，要指定`/usr/local/lib`作为库文件的路径，可以使用`LDFLAGS = -L/usr/local/lib`。
3. 指定多个库文件和库路径：LDFLAGS = -l<library_name1> -l<library_name2> -L<path_to_library1> -L<path_to_library2>例如，要链接`libfoo.so`和`libbar.so`两个库文件，并指定`/usr/local/lib`和`/usr/lib`作为库路径，可以使用`LDFLAGS = -lfoo -lbar -L/usr/local/lib -L/usr/lib`。
4. 指定其他链接器选项：LDFLAGS = <linker_option1> <linker_option2>例如，要指定链接器标志`-static`，可以使用`LDFLAGS = -static`。
需要注意的是，`LDFLAGS`变量的值会被传递给链接器来进行链接操作。
在Makefile文件中，链接器通常使用`$(LDFLAGS)`来引用`LDFLAGS`变量的值。
例如：$(CC) $(LDFLAGS) -o output_file input_file1input_file2其中，`$(CC)`表示C编译器，`-o output_file`指定输出文件名，`input_file1 input_file2`表示输入文件。
linux中环境变量的设置和makefile文件的编辑
linux中环境变量的设置和makefile文件的编辑环境变量8.1 查看环境变量显示所有的环境变量设置?$ env$ echo $ENV_VARIABLE 显示指定环境变量的设置例：$ echo $PATH/bin:/etc:/usr/bin:/tcb/bin8.2 设定环境变量$ ENV_VARIABLE=XXX;export ENV_VARIABLE例：$ 将环境变量PATH设定为原PATH值+$INFORMIXDIR/bin?PATH=$PATH:$INFORMIXDIR/bin;export PATH8.3 取消环境变量设置$ unset $ENV_VARIABLE例：$ set GZJ=gzj;export 设置环境变量GZJ?GZJ$ echo $GZJ显示环境变量值?gzj$ unset $GZJ 取消环境变量GZJ的设置$ echo $GZJ已取消?一makefile规则makefile是一个make的规则描述脚本文件，包括四种类型行：目标行、命令行、宏定义行和make伪指令行（如“include”）。
makefile文件中注释以“#”开头。
当一行写不下时，可以用续行符“\”转入下一行。
1.1 目标行目标行告诉make建立什么。
它由一个目标名表后面跟冒号“:”，再跟一个依赖性表组成。
例：example: depfile deptarget该目标行指出目标example与depfile和deptarget有依赖关系，如果depfile或deptarget有修改，则重新生成目标。
example1 example2 example3: deptarget1 deptarget2 depfile该目标行指出目标名表中的example1、example2、example3这三个各自独立的目标是用相同的依赖列表和规则生成的。
clean:空的依赖列表说明目标clean没有其他依赖关系。
目标行后续的以Tab 开始的行是指出目标的生成规则，该T ab字符不能以空格代替。
Makefile编写规则（一）通配符和变量
Makefile编写规则（⼀）通配符和变量Makefile编写规则（⼀）通配符和变量Makefile 有⾃⼰的书写格式、关键字、函数。
我们在本⽂中着重介绍⼀下Makefile的书写格式。
如通配符，变量的定义，条件判断等等。
Makefile通配符Makefile 是可以使⽤ shell 命令的，所以 shell ⽀持的通配符在 Makefile 中也是同样适⽤的。
shell 中使⽤的通配符有："*"，"?"，"[...]"1、* 匹配0个或者是任意个字符2、？匹配任意⼀个字符3、[ ] 指定匹配的字符放在 "[]" 中⽰例1.PHONY:cleanclean:rm -rf *.o test这是在 Makefile 中经常使⽤的规则语句。
这个实例可以说明通配符可以使⽤在规则的命令当中，表⽰的是任意的以 .o 结尾的⽂件。
⽰例2test:*.cgcc -o $@ $这个实例可以说明我们的通配符不仅可以使⽤在规则的命令中，还可以使⽤在规则中。
⽤来表⽰⽣所有的以 .c 结尾的⽂件。
但是如果我们的通配符使⽤在依赖的规则中的话⼀定要注意这个问题：不能通过引⽤变量的⽅式来使⽤，如下所⽰。
OBJ=*.ctest:$(OBJ)gcc -o $@ $^执⾏这个命令的时候会出现错误，提⽰我们没有 "*.c" ⽂件，实例中我们相要表⽰的是当前⽬录下所有的 ".c" ⽂件，但是我们在使⽤的时候并没有展开，⽽是直接识别成了⼀个⽂件。
⽂件名是 "*.c"。
如果我们就是相要通过引⽤变量的话，我们要使⽤⼀个函数 "wildcard"，这个函数在我们引⽤变量的时候，会帮我们展开。
我们把上⾯的代码修改⼀下就可以使⽤了。
OBJ=$(wildcard *.c)test:$(OBJ)gcc -o $@ $^我们再去使⽤的时候就可以了。
Makefile第二讲：打印出内容和使用变量
Makefile第⼆讲：打印出内容和使⽤变量摘要 `@echo "开始⽣成最终执⾏⽂件，请稍候..."`这⼀句便是将⼀条信息输出到终端，为何前边有个`@`符号呢？有了这个符号该命令本⾝就不会输出到终端（不理解，⾃⼰去掉或者加上`@`符号试试），实验证明，字符串可以不加引号。
看到`OBJS = main.o`了吗？这就是变量的定义，变量定义遵循⼀般语⾔的变量命名规则，可以是`_`和`$`开头，变量的值⽆论是字符串还是什么，都可以不要引号；有⼀种情况必须不要引号，就像上例这种，具体的....⾃⼰尝试吧。
main.cpp#include <iostream>using namespace std;int main() {cout <<"Hello makefile";return 0;}makefile（还是中的代码，稍作修改）OBJS = main.otest:$(OBJS)@echo "开始⽣成最终执⾏⽂件，请稍候..."g++ main.o -o testmain.o:main.cppg++ -c main.cpp -o main.oclean:rm main.o test"开始⽣成最终执⾏⽂件，请稍候..."这⼀句便是将⼀条信息输出到终端，为何前边有个@符号呢？有了这个符号该命令本⾝就不会输出到终端（不理解，⾃⼰去掉或者加上@符号试试），实验证明，字符串可以不加引号。
看到OBJS = main.o了吗？这就是变量的定义，变量定义遵循⼀般语⾔的变量命名规则，可以是_和$开头，变量的值⽆论是字符串还是什么，都可以不要引号；有⼀种情况必须不要引号，就像上例这种，具体的….⾃⼰尝试吧。
$(OBJS)这是对变量的调⽤。
还可以把shell命令的返回值作赋给变量，例如将当前⽬录的路径赋值给变量：CURRENT_DIR = $(shell pwd)。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
第六章：Makefile中的变量--------------------------------------------------------------------------------在Makefile中，变量就是一个名字（像是C语言中的宏），代表一个文本字符串（变量的值）。
在Makefile的目标、依赖、命令中引用一个变量的地方，变量会被它的值所取代（与C语言中宏引用的方式相同，因此其他版本的make也把变量称之为“宏”）。
在Makefile中变量的特征有以下几点：1. Makefile中变量和函数的展开（除规则的命令行以外），是在make读取makefile文件时进行的，这里的变量包括了使用“=”定义和使用指示符“define”定义的。
2. 变量可以用来代表一个文件名列表、编译选项列表、程序运行的选项参数列表、搜索源文件的目录列表、编译输出的目录列表和所有我们能够想到的事物。
3. 变量名是不包括“:”、“#”、“=”、前置空白和尾空白的任何字符串。
需要注意的是，尽管在GNU make中没有对变量的命名有其它的限制，但定义一个包含除字母、数字和下划线以外的变量的做法也是不可取的，因为除字母、数字和下划线以外的其它字符可能会在以后的make版本中被赋予特殊含义，并且这样命名的变量对于一些shell来说不能作为环境变量使用。
4. 变量名是大小写敏感的。
变量“foo”、“Foo”和“FOO”指的是三个不同的变量。
Makefile 传统做法是变量名是全采用大写的方式。
推荐的做法是在对于内部定义定义的一般变量（例如：目标文件列表objects）使用小写方式，而对于一些参数列表（例如：编译选项CFLAGS）采用大写方式，这并不是要求的。
但需要强调一点：对于一个工程，所有Makefile中的变量命名应保持一种风格，否则会显得你是一个蹩脚的程序员（就像代码的变量命名风格一样）。
5. 另外有一些变量名只包含了一个或者很少的几个特殊的字符（符号）。
称它们为自动化变量。
像“$<”、“$@”、“$?”、“$*”等。
6.1 变量的引用当我们定义了一个变量之后，就可以在Makefile的很多地方使用这个变量。
变量的引用方式是：使用“$（VARIABLE_NAME）”或者“${ VARIABLE_NAME }”来引用一个变量的定义。
例如：“$(foo) ”或者“${foo}”就是取变量“foo”的值。
美元符号“$”在Makefile中有特殊的含义，所有在命令或者文件名中使用“$”时需要用两个美元符号“$$”来表示。
对一个变量的引用可以在Makefile的任何上下文中，目标、依赖、命令、绝大多数指示符和新变量的赋值中。
这里有一个例子，其中变量保存了所有.o文件的列表：objects = program.o foo.o utils.oprogram : $(objects)cc -o program $(objects)$(objects) : defs.h变量引用的展开过程是严格的文本替换过程，就是说变量值的字符串被精确的展开在此变量被引用的地方。
因此规则：foo = cprog.o : prog.$(foo)$(foo) $(foo) -$(foo) prog.$(foo)被展开后就是：prog.c : prog.ccc -c prog.c通过这个例子我们可以看到变量的展开过程完全和c语言中的宏展开的过程一样，是一个严格的文本替换过程。
上例中在变量“foo”被展开过程中，其值中的前导空格会被忽略。
这里举这个例子的目的是为了让我们更清楚地了解变量的展开方式，而不是建议大家按照这样的方式来书写Makefile。
在实际书写时，千万不要使用这种方式。
否则将会给你带来很多不必要的麻烦。
注意：Makefile中在对一些简单变量的应用，我们也可以不使用“（）”和“{}”来标记变量名，而直接使用“$x”的格式来实现，此种用法仅限于变量名为单字符的情况。
另外自动化变量也使用这种格式。
对于一般多字符变量的引用必须使用括号了标记，否则make将把变量名的首字母作为作为引用（“$ PATH”在Makefile中实际上是“$(P)ATH”）。
这一点和shell中变量的引用方式不同。
shell中变量的引用可以是“${xx}”或者“$xx”格式。
但在Makefile中多字符变量名的引用只能是“$(xx)”或者“${xx}”格式。
一般在我们书写Makefile时，各部分变量引用的格式我们建议如下：1. make变量（Makefile中定义的或者是make的环境变量）的引用使用“$(VAR)”格式，无论“VAR”是单字符变量名还是多字符变量名。
2. 出现在规则命令行中shell变量（一般为执行命令过程中的临时变量，它不属于Makefile 变量，而是一个shell变量）引用使用shell的“$tmp”格式。
3. 对出现在命令行中的make变量我们同样使用“$(CMDVAR)” 格式来引用。
例如：# sample Makefile……SUBDIRS := src foo.PHONY : subdirSubdir :@for dir in $(SUBDIRS); do \$(MAKE) –C $$dir || exit 1; \done……6.2 两种变量定义（赋值）GNU make中，一个变量的定义有两种方式（或者称为风格）。
我们把这两种方式定义的变量可以看作变量的两种不同风格。
变量的这两种不同的风格的区别在于：1. 定义方式；2. 展开时机。
下边我们分别对这两种不同的风格进行详细地讨论。
6.2.1 递归展开式变量第一种风格的变量就是递归方式扩展的变量。
这一类型的变量的定义是通过“=”或者使用指示符“define”定义的变量。
对这种变量的引用，在引用的地方是严格的文本替换过程，此变量值的字符串原模原样的出现在引用它的地方。
如果此变量定义中存在对其他变量的引用，这些被引用的变量会在它被展开的同时被展开。
就是说在变量定义时，变量值中对其他变量的引用不会被替换展开。
而是，变量在引用它的地方进行替换展开的同时，它所引用的其它变量才会被替换展开。
语言的描述可能比较晦涩，让我们来看一个例子：foo = $(bar)bar = $(ugh)ugh = Huh?all:;echo $(foo)执行“make”将会打印出“Huh?”。
整个变量的替换过程时这样的：首先“$(foo)”被替换为“$(bar)”，接下来“$(bar)”被替换为“$(ugh)”，最后“$(ugh)”被替换为“Hug?”。
整个替换的过程是在执行“echo $(foo)”是进行的。
这种类型的变量是其它版本的make所支持的类型。
我们可以把这种类型的变量称为“递归展开”式变量。
此类型的变量存有它的优点同时也存在其缺点。
其优点是：这种类型变量的定义时，可以引用其它的之前没有定义的变量（可能在后续部分定义，或者是通过make的命令行选项传递的变量）。
看一个这样的例子：CFLAGS = $(include_dirs) -Oinclude_dirs = -Ifoo -Ibar“CFLAGS”会在命令中被展开为“-Ifoo -Ibar -O”。
我们可以看到在“CFLAGS”定义中使用到了之后定义的变量“include_dirs”。
其缺点是：1. 使用此风格的变量定义，可能会由于出现变量的递归定义而导致make陷入到无限的变量展开过程中，最终使make执行失败。
例如，接上边的例子，我们给这个变量追加值：CFLAGS = $(CFLAGS) –O它将会导致make进入对变量“CFLAGS”的无限展过程中去（这种定义就是变量的递归定义）。
因为一旦后续同样存在对“CLFAGS”定义的追加，展开过程将是套嵌的、不能终止的（在发生这种情况时，make会提示错误信息并结束）。
一般在书写Makefile时，使用这种追加变量值的方法也很少使用（也不是我们推荐的方式）。
我们可以来看另外一个例子：x = $(y)y = $(x) $(z)这种情况下同样会导致make陷入到无限的变量展开过程中。
因此我们在使用这种风格的变量，当一个变量定义需要引用其它的变量时需要特别的注意，防止变量的展开进入无限的循环。
当出现这样的错误时，首先检查你的Makefile中变量是否出现了递归定义。
这是它的一个缺点。
2. 第二个缺点：这种风格变量的定义中如果使引用了某一个函数，那么函数总会在其被引用的地方被执行。
这是因为这种风格变量的定义中，对函数引用的替换展开发生在展开它自身的时候，而不是在定义它的时候。
这样所带来的问题是，可能可能会使make的执行效率降低，同时对某些变量和函数的引用出现问题。
特别是当变量定义中引用了“shell”和“wildcard”函数的情况，可能出现不可控制或者难以预料的错误，因为我们无法确定它在何时会被展开。
6.2.2 直接展开式变量为了避免“递归展开式”变量存在的问题和不方便。
在GNU make中可以使用另外一种风格的变量，我们将它称为“直接展开”式。
这种风格的变量使用“:=”来定义变量。
在使用“:=”定义变量时，变量值中对另外变量的引用或者函数的引用在定义时被展开（对变量进行替换）。
所以在变量被定义以后就是一个实际所需要定义的文本串，其中不再包含任何对其它变量的引用。
因此x := fooy := $(x) barx := later就等价于：y := foo barx := later需要注意的是：此风格变量在定义时就完成了对所引用的变量的展开，因此它不能实现对其后定义变量的引用。
例如：CFLAGS := $(include_dirs) -Oinclude_dirs := -Ifoo -Ibar由于在变量“include_dirs”的定义出现在“CFLAGS”定义之后。
因此在“CFLAGS”的定义中，“include_dirs”的值为空。
“CFLAGS”的值为“-O”而不是“-Ifoo -Ibar -O”。
这一点也是直接展开式和递归展开式变量的不同点。
注意这里的两个变量都是“直接展开”式的。
大家不妨试试将其中某一个变量使用递归展开式定义后看一下又会出现什么样的结果。
下边让我们来看一个复杂一点的例子。
分析一下直接展开式变量定义（:=）的用法，这里也用到了make的shell函数和变量“MAKELEVEL”（此变量在make的递归调用时代表make的调用深度）。
其中包括了make的函数、条件表达式和一个系统变量“MAKELEVEL”的使用：ifeq (0,${MAKELEVEL})cur-dir := $(shell pwd)whoami := $(shell whoami)host-type := $(shell arch)MAKE := ${MAKE} host-type=${host-type} whoami=${whoami}endif第一行是一个条件判断，说明如果是顶层Makefile，就定义下列变量。