makefile的使用

合集下载

make file语法

make file语法
makefile是一种用于自动化编译和构建软件的工具，其语法如下：
1. 注释：以“#”开头，直到行末为止。

2. 变量：使用“ = ”或“ := ”定义变量，例如：
CC = gcc
CFLAGS := -Wall -g
3. 目标：每个目标都由一个或多个依赖项和一个或多个命令组成，例如：
main: main.o func.o
$(CC) $(CFLAGS) -o main main.o func.o
4. 依赖项：使用空格分隔多个依赖项，例如：
main: main.o func.o
5. 命令：使用tab缩进定义目标的命令，例如：
main: main.o func.o
$(CC) $(CFLAGS) -o main main.o func.o
6. 伪目标：以“.PHONY”开头，用于定义伪目标，例如：
.PHONY: clean
clean:
rm -f *.o main
7. 自动变量：在命令中使用自动变量，例如：
main: main.o func.o
$(CC) $(CFLAGS) -o $@ $^
其中，“$@”表示目标，“$^”表示所有依赖项。

以上就是make file的基本语法，可以通过结合实际的例子来更好地理解和应用。

makefile中使用cp命令

使用cp命令在makefile中复制文件1. 简介在软件开发过程中，我们经常需要将文件从一个目录复制到另一个目录，以便进行编译、测试或部署等操作。

在Linux和Unix系统中，cp命令是用于复制文件和目录的常用工具之一。

在makefile中使用cp命令可以方便地实现文件的复制操作。

本文将介绍如何在makefile中使用cp命令进行文件复制，并提供一些常见的应用场景和示例。

2. makefile基础知识在开始介绍如何使用cp命令之前，我们需要了解一些基本的makefile知识。

2.1 makefile是什么？makefile是一个用于管理项目构建的脚本文件。

它包含了一系列规则，每个规则定义了一个或多个目标（target）以及生成该目标所需的依赖项（dependencies）和执行动作（actions）。

2.2 makefile规则结构每条makefile规则由以下几部分组成：target: dependenciesactions•target: 目标，即要生成的文件或执行的动作。

•dependencies: 依赖项，即生成目标所需的其他文件或目标。

•actions: 执行动作，即生成目标时要执行的命令。

2.3 makefile变量makefile中可以定义变量来存储一些常用的值，例如文件路径、编译器选项等。

使用变量可以使makefile更加灵活和易于维护。

定义变量的语法为：variable_name = value使用变量的语法为：$(variable_name)3. 在makefile中使用cp命令进行文件复制在makefile中使用cp命令进行文件复制非常简单。

只需要在规则的actions部分调用cp命令，并指定源文件和目标文件即可。

下面是一个示例，演示了如何在makefile中使用cp命令将一个源文件复制到目标目录：target: dependenciescp source_file target_directory/•target: 目标，即要生成的文件或执行的动作。

makefile debug编译

makefile debug编译摘要：1.Makefile的作用2.Makefile的调试编译3.编译过程中可能遇到的问题及解决方法正文：Makefile是程序员在开发过程中经常使用的一个工具，它可以帮助我们自动化编译、链接和安装程序。

当我们编写Makefile时，有可能会遇到一些问题，需要进行调试。

本文将详细介绍Makefile的调试编译过程以及可能遇到的问题及解决方法。

首先，我们需要了解Makefile的作用。

Makefile是一个包含编译、链接和安装指令的文本文件，它告诉计算机如何将源代码编译成可执行文件。

通过Makefile，我们可以轻松地管理复杂的编译过程，减少编译时间，提高开发效率。

在进行Makefile的调试编译之前，我们需要确保已经正确地编写Makefile。

通常，Makefile应包含以下几个部分：1.变量定义：定义一些全局变量，如编译器、编译选项等。

2.目标规则：定义要编译的目标文件以及生成目标文件的规则。

3.依赖规则：定义目标文件之间的依赖关系。

4.命令规则：定义如何编译源文件以生成目标文件。

在编写好Makefile之后，我们就可以开始调试编译过程了。

调试编译的主要目的是找到Makefile中可能存在的问题，例如语法错误、编译选项错误等。

我们可以通过以下方法进行调试：1.检查Makefile的语法：确保Makefile的语法正确，没有遗漏的括号、引号等。

2.检查变量定义：确保变量的赋值正确，没有拼写错误。

3.检查目标规则和依赖规则：确保目标文件和依赖文件的正确性，没有错误的文件名或路径。

4.检查命令规则：确保编译命令的正确性，没有错误的编译选项或参数。

如果在调试过程中遇到问题，我们可以尝试以下解决方法：1.查看Makefile的错误提示：Makefile在编译过程中遇到问题会给出错误提示，我们可以根据提示找到问题所在。

2.使用调试工具：例如GDB，可以帮助我们调试编译后的程序，找到程序中的问题。

Makefile变量使用条件及判断使用

Makefile变量使用条件及判断使用使用变量————在Makefile中的定义的变量，就像是C/C++语言中的宏一样，他代表了一个文本字串，在Makefile中执行的时候其会自动原模原样地展开在所使用的地方。

其与C/C++所不同的是，你可以在Makefile中改变其值。

在Makefile中，变量可以使用在“目标”，“依赖目标”，“命令”或是Makefile的其它部分中。

变量的命名字可以包含字符、数字，下划线（可以是数字开头），但不应该含有“:”、“#”、“=”或是空字符（空格、回车等）。

变量是大小写敏感的，“foo”、“Foo”和“FOO”是三个不同的变量名。

传统的Makefile的变量名是全大写的命名方式，但我推荐使用大小写搭配的变量名，如：MakeFlags。

这样可以避免和系统的变量冲突，而发生意外的事情。

有一些变量是很奇怪字串，如“$<”、“$@”等，这些是自动化变量，我会在后面介绍。

一、变量的基础变量在声明时需要给予初值，而在使用时，需要给在变量名前加上“$”符号，但最好用小括号“（）”或是大括号“{}”把变量给包括起来。

如果你要使用真实的“$”字符，那么你需要用“$$”来表示。

变量可以使用在许多地方，如规则中的“目标”、“依赖”、“命令”以及新的变量中。

先看一个例子：objects = program.o foo.o utils.oprogram : $(objects)cc -o program $(objects)$(objects) : defs.h变量会在使用它的地方精确地展开，就像C/C++中的宏一样，例如：foo = cprog.o : prog.$(foo)$(foo)$(foo) -$(foo) prog.$(foo)展开后得到：prog.o : prog.ccc -c prog.c当然，千万不要在你的Makefile中这样干，这里只是举个例子来表明Makefile中的变量在使用处展开的真实样子。

goland makefile 使用

goland makefile 使用Goland是一款非常强大的集成开发环境（IDE），专门针对Go语言开发。

它提供了一系列的功能和工具，能够帮助开发者更高效地进行Go语言项目的开发和调试。

而Makefile，则是一种用来自动化构建和编译程序的工具。

在使用Goland进行Go语言开发时，我们可以结合使用Makefile 来简化一些繁琐的操作，提高开发效率。

下面我将介绍一些在Goland中使用Makefile的方法和技巧。

我们需要创建一个名为Makefile的文件，并将其放置在项目根目录下。

Makefile是一个文本文件，其中包含一系列的规则（rules），每个规则都定义了一组命令，用于构建和编译程序。

在Makefile文件中，我们可以定义一些常用的操作和命令，比如编译程序、运行测试、清理临时文件等。

下面是一个简单的示例：```Makefile# 编译程序build:go build -o myapp# 运行测试test:go test ./...# 清理临时文件clean:rm -f myapp# 安装依赖deps:go mod download```在上面的示例中，我们定义了四个规则，分别用于编译程序、运行测试、清理临时文件和安装依赖。

其中，`build`规则使用`go build`命令来编译程序，`test`规则使用`go test`命令来运行测试，`clean`规则使用`rm -f`命令来删除生成的可执行文件，`deps`规则使用`go mod download`命令来安装依赖。

在Goland中，我们可以通过终端或者Goland的内置终端来执行Makefile中定义的规则。

首先，我们需要打开终端，然后进入到项目的根目录下。

接下来，我们可以使用`make`命令来执行Makefile 中的规则。

比如，如果我们想要编译程序，只需要在终端中执行`make build`命令即可。

如果我们想要运行测试，只需要执行`make test`命令即可。

makefile -d 用法

makefile -d 用法摘要：1.Makefile 简介2.makefile -d 用法详解a.参数含义b.使用方法c.实例演示3.makefile -d 在实际项目中的应用4.总结正文：Makefile 是一个项目管理工具，主要用于自动化构建和编译软件项目。

在Makefile 中，我们可以定义一系列的规则，用于描述软件项目各文件的依赖关系以及编译命令等。

今天，我们将详细了解一下makefile -d 的用法。

1.Makefile 简介首先，让我们简要了解一下Makefile 的基本概念。

Makefile 是一个包含一系列命令和规则的文本文件，通常位于项目的根目录下。

它告诉make 命令如何自动构建、编译和链接项目。

2.makefile -d 用法详解接下来，我们将详细解释makefile -d 的参数含义、使用方法和实例演示。

a.参数含义-d 选项是makefile 的调试模式，它会在执行规则之前输出规则的详细信息，便于开发者调试和理解Makefile 的执行过程。

b.使用方法要使用makefile -d 选项，只需在调用make 命令时添加-d 参数即可，如下所示：```make -d```c.实例演示下面，我们通过一个简单的实例来演示如何使用makefile -d。

假设我们有一个名为`example.mk`的Makefile，其内容如下：```all: main.occ main.o -o mainmain.o: main.ccc main.c -o main.o```现在，我们使用make -d 命令来执行Makefile：```make -d```执行结果如下：```make: Entering directory `."main.mk:3: recipe for target "all"main.mk:3: cc main.o -o mainmake: Leaving directory `."```从输出结果中，我们可以看到makefile -d 选项输出了规则的详细信息。

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条件语嵌套使用-回复问题的具体步骤如下：第一步：什么是makefile？在开始讨论makefile条件语嵌套的使用之前，我们先了解一下什么是makefile。

Makefile是一个包含一系列规则和命令的文本文件，它描述了源文件之间的依赖关系，以及如何编译和链接这些源文件。

通过makefile，我们可以在一个命令中一次性构建复杂的项目，而不需要手动编译每个源文件。

第二步：条件语的基本概念在makefile中，条件语可以根据一定的条件执行不同的命令或者规则。

条件语的基本语法如下：ifeq (参数1, 参数2)# 参数1和参数2相等时执行的命令或规则else# 参数1和参数2不相等时执行的命令或规则endif通过if语句中的参数1和参数2的比较，可以决定不同条件下的执行逻辑。

第三步：条件语嵌套的基本概念与其他编程语言类似，makefile也支持条件语的嵌套使用。

通过条件语的嵌套，我们可以实现更加复杂的逻辑判断和命令执行。

例如，我们可以通过以下的方式嵌套使用if语句：ifeq (参数1, 参数2)# 参数1和参数2相等时执行的命令或规则ifeq (参数3, 参数4)# 参数3和参数4相等时执行的命令或规则else# 参数3和参数4不相等时执行的命令或规则endifelse# 参数1和参数2不相等时执行的命令或规则endif通过条件语嵌套，我们可以实现更加复杂的逻辑判断和流程控制。

第四步：条件语嵌套的实际应用接下来，我们来看一些实际的例子，以更好地理解条件语嵌套的使用。

假设我们有一个项目，该项目可以在不同的操作系统上编译和运行。

我们可以通过条件语嵌套来实现根据操作系统的不同选择不同的编译命令。

首先，我们可以定义一个变量来表示当前操作系统的类型：OS := (shell uname -s)然后，我们可以使用条件语嵌套来根据操作系统的类型选择不同的编译命令：ifeq (参数1, 参数2)# 参数1和参数2相等时执行的命令或规则ifeq ((OS), Linux)# 在Linux系统上执行的命令或规则else ifeq ((OS), Windows)# 在Windows系统上执行的命令或规则else ifeq ((OS), Darwin)# 在Darwin (MacOS)系统上执行的命令或规则else# 其他操作系统上执行的命令或规则endifelse# 参数1和参数2不相等时执行的命令或规则endif通过以上的例子，我们可以看到，通过条件语嵌套，我们可以根据不同的操作系统类型选择不同的编译命令，从而实现在不同操作系统上的构建和运行。

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文件中的规则和依赖关系来编译源代码文件并生成目标文件和可执行文件。

makefile中使用cp命令

makefile中使用cp命令摘要：1.Makefile 简介2.CP 命令的作用3.Makefile 中CP 命令的语法4.CP 命令的实例应用5.CP 命令的注意事项正文：1.Makefile 简介Makefile 是一种用于自动构建和编译源代码的文本文件，通常用于编写软件项目。

它包含了一系列的规则和指令，用于描述如何编译、链接和构建软件项目。

Makefile 的主要目的是自动化构建过程，以提高开发效率。

2.CP 命令的作用在Makefile 中，CP 命令用于复制文件或目录。

它可以将一个文件或目录从一个位置复制到另一个位置，这对于构建过程中需要用到的资源文件、库文件等非常有用。

3.Makefile 中CP 命令的语法在Makefile 中，CP 命令的语法如下：```cp <source> <destination>```其中，`<source>`是要复制的文件或目录，`<destination>`是目标位置。

4.CP 命令的实例应用例如，假设我们有一个名为`src`的目录，其中包含了名为`main.c`的源代码文件。

现在，我们需要将这个文件复制到名为`build`的目录中，以便进行编译。

可以使用以下Makefile 规则来实现这个需求：```cp src/main.c build/```这条规则表示，将`src`目录下的`main.c`文件复制到`build`目录下。

5.CP 命令的注意事项在使用CP 命令时，需要注意以下几点：- 目标位置必须存在，否则复制操作无法完成。

- 如果要复制的文件或目录不存在，需要确保源位置正确，并检查路径是否正确。

- 在Makefile 中，可以多个CP 命令一起使用，以实现批量复制文件或目录。

总之，在Makefile 中使用CP 命令可以方便地实现文件或目录的复制操作，从而提高构建过程的自动化程度。

makefile ifeq 参数

makefile ifeq 参数【原创实用版】目录1.Makefile 简介2.ifeq 参数的作用3.Makefile 中的参数使用方法4.ifeq 参数的实际应用示例正文1.Makefile 简介Makefile 是一种构建脚本，主要用于自动构建和编译软件项目。

它通常包含一系列的规则和指令，用于描述项目的编译、链接和安装过程。

Makefile 的应用领域非常广泛，涵盖了各种编程语言和操作系统平台。

2.ifeq 参数的作用Makefile 中的 ifeq 参数是一种条件判断语句，用于根据特定条件来决定是否执行其后面的命令。

这种条件判断可以帮助我们根据不同的环境或配置来灵活地调整构建过程，从而提高构建脚本的可维护性和可扩展性。

3.Makefile 中的参数使用方法在 Makefile 中使用 ifeq 参数的方法非常简单。

首先，我们需要在需要判断条件的地方插入 ifeq 关键字，然后跟上要判断的条件和相应的操作。

基本的语法结构如下：```ifeq (条件)(如果条件为真，执行的操作)else(如果条件为假，执行的操作)endif```例如，我们可以使用 ifeq 参数来判断当前系统是否支持某项功能，然后根据判断结果来决定是否包含该功能的编译选项。

4.ifeq 参数的实际应用示例假设我们有一个名为“myproject”的软件项目，它需要根据不同的操作系统来选择合适的编译器和链接器选项。

我们可以使用 ifeq 参数来实现这个功能。

以下是一个简单的示例：```makefileall: mainmain: main.o$(CC) $(CFLAGS) -o $@ $^%.o: %.c$(CC) $(CFLAGS) -c $< -o $@ifeq ($(OS), Windows)CC = clCFLAGS = /W4elseCC = gccCFLAGS = -W4endif```在这个示例中，我们首先定义了一个名为“$(OS)”的变量，用于存储当前系统的名称。

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 命令行参数

2. -C选项
-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中，路径的书写主要有两种方式：绝对路径和相对路径。

1. 绝对路径：从文件系统的根目录开始的路径。

例如`/home/user/`就是一个绝对路径。

在Makefile中，绝对路径通常是从构建系统的根目录开始的。

2. 相对路径：相对于当前工作目录的路径。

在Makefile中，通常使用`./`表示当前目录，`../`表示上级目录。

选择使用绝对路径还是相对路径取决于你
的项目结构和开发者的偏好。

一般来说，推荐使用相对路径，因为它们更灵活，可以适应不同的项目目录结构。

在书写路径时，还有一些规范和最佳实践需要遵循：
1. 文件名：文件名应该简洁明了，不要使用空格或其他特殊字符。

避免使用长文件名或难以理解的文件名。

2. 目录分隔符：在Linux系统中，路径的分隔符是反斜杠(`\`)。

当路径包含多个目录时，需要使用两个反斜杠(`\\` 或 `/`)。

在Makefile中，推荐使用
正斜杠(`/`)，因为它在所有平台上都是通用的。

3. 自动更新：在Makefile中，可以使用`$(wildcard)`函数来匹配目录中的
文件。

例如，`$(wildcard source/.c)`将匹配source目录下的所有C源文件。

4. 构建系统根目录：在Makefile中，通常使用构建系统的根目录作为路径的起点。

这可以通过变量来实现，例如`ROOT := /path/to/build`。

makefile 语法

makefile 语法Makefile是一种常用的构建工具，用于自动化构建和管理软件项目。

它是一种文本文件，包含一系列规则，用于指定如何编译、链接和构建源代码。

本文将介绍 Makefile 的语法和使用方法。

一、Makefile 的基本语法Makefile 文件由一系列规则组成，每个规则由一个目标和一个或多个依赖项组成。

目标是要生成的文件名，依赖项是生成目标所需要的文件或命令。

当目标文件不存在或依赖项的时间戳比目标文件的时间戳更晚时，Makefile 将自动执行规则中的命令，生成目标文件。

一个简单的 Makefile 示例：```hello: main.cgcc -o hello main.c```这个 Makefile 包含了一个规则，目标是 hello，依赖项是main.c。

当 main.c 文件的时间戳比 hello 文件的时间戳更晚时，Makefile 将执行 gcc 命令编译 main.c 文件，并生成可执行文件hello。

Makefile 的规则语法如下：```target: dependenciescommand1command2...```其中，target 是规则的目标，dependencies 是规则的依赖项，command1、command2 等是要执行的命令。

命令必须以一个制表符或多个空格开头，否则 Makefile 将无法识别。

二、Makefile 的变量Makefile 中可以定义变量，用于存储常用的值或命令。

变量以$ 符号开头，可以在规则中使用。

变量的定义语法如下：```VARNAME = value```或者```VARNAME := value```其中，等号和冒号加等号的区别在于，等号定义的变量是递归展开的，而冒号加等号定义的变量是简单展开的。

递归展开的变量可以包含其他变量的引用，而简单展开的变量只能包含直接的值。

示例：```CC = gccCFLAGS = -Wall -O2hello: main.c$(CC) $(CFLAGS) -o hello main.c```这个 Makefile 中定义了两个变量 CC 和 CFLAGS，用于存储编译器和编译选项。

详解Makefile函数的语法与使用

详解Makefile函数的语法与使⽤使⽤函数:在Makefile中可以使⽤函数来处理变量，从⽽让我们的命令或是规则更为的灵活和具有智能。

make所⽀持的函数也不算很多，不过已经⾜够我们的操作了。

函数调⽤后，函数的返回值可以当做变量来使⽤。

⼀、函数的调⽤语法函数调⽤，很像变量的使⽤，也是以“$”来标识的，其语法如下：$(<function> <arguments> )或是${<function> <arguments>}这⾥，<function>就是函数名，make⽀持的函数不多。

<arguments>是函数的参数，参数间以逗号“,”分隔，⽽函数名和参数之间以“空格”分隔。

函数调⽤以“”开头，以圆括号或花括号把函数名和参数括起。

感觉很像⼀个变量，是不是？函数中的参数可以使⽤变量，为了风格的统⼀，函数和变量的括号最好⼀样，如使⽤“(subst a,b,(x))”这样的形式，⽽不是“(subst a,b,${x})”的形式。

因为统⼀会更清楚，也会减少⼀些不必要的⿇烦。

还是来看⼀个⽰例：comma:= ,empty:=space:= (empty) (empty)foo:= a b cbar:= (subst (space),(comma),(foo))在这个⽰例中，(comma)的值是⼀个逗号。

(space)使⽤了(empty)定义了⼀个空格，(foo)的值是“a b c”，(bar)的定义⽤，调⽤了函数“subst”，这是⼀个替换函数，这个函数有三个参数，第⼀个参数是被替换字串，第⼆个参数是替换字串，第三个参数是替换操作作⽤的字串。

这个函数也就是把(foo)中的空格替换成逗号，所以$(bar)的值是“a,b,c”。

⼆、字符串处理函数$(subst <from>,<to>,<text> )名称：字符串替换函数——subst。

使用makefile编译多个文件（.c,.cpp,.h等）

使⽤makefile编译多个⽂件（.c,.cpp,.h等）有时候我们要⼀次运⾏多个⽂件，这时候我们可以使⽤Makefile◊make是什么？ make是⼀个命令⼯具，是⼀个解释makefile中指令的命令⼯具。

它可以简化编译过程⾥⾯所下达的指令，当执⾏make 时，make 会在当前的⽬录下搜寻 Makefile (or makefile) 这个⽂本⽂件，执⾏对应的操作。

make 会⾃动的判别原始码是否经过变动了，⽽⾃动更新执⾏档。

◊为什么要使⽤make？假设，现在⼀个项⽬⾥⾯包含了100个程序⽂件，如果要对这个项⽬进⾏编译，那么光是编译指令就有100条。

如果要重新进⾏编译，那么就⼜得像之前⼀样重新来⼀遍。

这样重复且繁琐的⼯作实在是让我们很不爽啊。

所以，⽤make来进⾏操作，间接调⽤gcc岂不是很⽅便？如果我们更动过某些原始码档案，则 make 也可以主动的判断哪⼀个原始码与相关的⽬标⽂件档案有更新过，并仅更新该档案。

这样可以减少重新编译所需要的时间，也会更加⽅便。

◊makefile⼜是⼲什么的？ makefile其实就是⼀个⽂档，⾥⾯定义了⼀系列的规则指定哪些⽂件需要先编译，哪些⽂件需要后编译，哪些⽂件需要重新编译，它记录了原始码如何编译的详细信息！ makefile⼀旦写好，只需要⼀个make命令，整个⼯程完全⾃动编译，极⼤的提⾼了软件开发的效率。

先看⼀下makefile的规则：⽬标（target)：⽬标⽂件1 ⽬标⽂件2 <Tab>gcc -o 欲建⽴的执⾏⽂件⽬标⽂件1 ⽬标⽂件2先举⼀个运⾏多个c语⾔⽂件。

⾸先下⾯是⼀个完整的 c语⾔⽂件，实现了统计⽤户输⼊的字符串中⼤⼩写字母的个数#include<unistd.h>#include<sys/types.h>#include<sys/wait.h>void test(){char str[50]={0};scanf("%s",str);int m=0;int n=0;pid_t p=fork();if(p<0){printf("fork failed");}if(p == 0){for(int i=0;i<sizeof(str);i++){if( str[i]<='Z'&& str[i]>='A'){m++;}}printf("⼤写字母⼀共有");printf("%d",m);printf("个");}if(p>0){for(int i=0;i<sizeof(str);i++){if(str[i]>='a' && str[i]<='z'){n++;}}printf("⼩写字母⼀共有");printf("%d",n);printf("个");}}int main(){test();return 0;}此时我们可以把该⽂件拆成三份，⼀份是.h⽂件，⽤来放头⽂件等信息，另外两个是.c⽂件，⼀个⽤来放main⽅法，⼀个放声明的函数，如下三图则在终端进⾏⼀下操作成功运⾏多个⽂件下⾯介绍运⾏cpp⽂件，⼤致步骤相同。

makefile pushd用法

makefile pushd用法摘要：1.makefile 概述2.pushd 用法简介3.makefile 与pushd 结合使用实例4.总结正文：1.makefile 概述Makefile 是一种用于自动化构建和编译软件的脚本文件，常见于Unix 和类Unix 系统中。

它通常包含一系列的规则和指令，用于描述如何编译源代码、链接目标文件、创建可执行文件等。

Makefile 的编写可以大大简化软件开发过程中的重复性工作，提高开发效率。

2.pushd 用法简介`pushd`是一个Shell 命令，用于将当前工作目录切换到指定的目录。

在Makefile 中，`pushd`命令可以用于改变执行特定规则时的工作目录，这对于处理多目录结构的项目尤为重要。

`pushd`的基本语法如下：```pushd <目录>```其中，`<目录>`是要切换到的目录。

在Makefile 中，可以使用`popd`命令将工作目录切换回之前的目录。

3.makefile 与pushd 结合使用实例假设我们有一个简单的多目录结构项目，其结构如下：```project/├──src/│└── main.c└──build/└── main.o```我们需要编写一个Makefile，使得在编译`main.c`时，工作目录位于`src`目录，以便正确链接目标文件和可执行文件。

可以使用以下Makefile：```makefileall: mainmain: main.ot@mkdir -p buildtcd srctgcc main.c -o build/main.otpopdclean:trm -rf build```在这个Makefile 中，我们使用`pushd`命令将工作目录切换到`src`目录，然后编译`main.c`。

编译完成后，我们使用`popd`命令将工作目录切换回上级目录。

在执行`make`命令时，会自动调用`all`规则，完成编译和链接操作。

makefile打印函数

makefile打印函数使用makefile打印函数是一种常见的编程技巧，可以帮助程序员更好地组织和管理代码。

在本文中，我们将探讨如何使用makefile打印函数，并介绍一些与之相关的概念和用法。

让我们来了解一下makefile是什么。

makefile是一种文本文件，其中包含了一系列规则和指令，用于告诉计算机如何编译和构建代码。

它通常用于大型项目的管理，可以自动化编译过程，提高开发效率。

在makefile中，可以使用函数来执行一些特定的操作。

函数是一种预定义的指令，可以接受参数并返回结果。

使用函数可以将一些常见的操作封装起来，提高代码的可读性和可维护性。

在makefile中，打印函数是一种常用的函数，用于在控制台上输出一些信息。

它可以用来调试代码、输出变量的值等。

在makefile中，有几个常用的打印函数，包括echo、warning和error。

让我们来看一下echo函数。

echo函数可以用来在控制台上输出一些文字。

在makefile中，可以使用echo函数来输出一些提示信息，或者打印变量的值。

例如，我们可以使用以下的语法来使用echo函数：```$(echo Hello, world!)```这条规则会在控制台上输出"Hello, world!"。

除了echo函数，makefile中还有warning和error函数。

warning 函数用于输出警告信息，而error函数用于输出错误信息。

这两个函数可以用于在编译过程中检测到一些问题时，及时地给出提示。

例如，我们可以使用warning函数来输出一个警告信息：```$(warning This is a warning message)```这条规则会在控制台上输出一个警告信息。

类似地，我们可以使用error函数来输出一个错误信息：```$(error This is an error message)```这条规则会在控制台上输出一个错误信息，并停止继续执行makefile。