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命令，包括编译、链接、拷贝等操作。

Make命令完全详解教程无论是在Linux还是在Unix环境中，make都是一个非常重要的编译命令。

不管是自己进行项目开发还是安装应用软件，我们都经常要用到make或make install。

利用make工具，我们可以将大型的开发项目分解成为多个更易于管理的模块，对于一个包括几百个源文件的应用程序，使用make和makefile工具就可以简洁明快地理顺各个源文件之间纷繁复杂的相互关系。

而且如此多的源文件，如果每次都要键入gcc命令进行编译的话，那对程序员来说简直就是一场灾难。

而make工具则可自动完成编译工作，并且可以只对程序员在上次编译后修改过的部分进行编译。

因此，有效的利用make和makefile工具可以大大提高项目开发的效率。

同时掌握make和makefile之后，您也不会再面对着Linux下的应用软件手足无措了。

一、Make程序的命令行选项和参数Make命令参数的典型序列如下所示：make [-f makefile文件名][选项][宏定义][目标]这里用[]括起来的表示是可选的。

命令行选项由破折号“–”指明，后面跟选项，如也可以每个选项使用一个破折号，如甚至混合使用也行，如Make命令本身的命令行选项较多，这里只介绍在开发程序时最为常用的三个，它们是：–k：如果使用该选项，即使make程序遇到错误也会继续向下运行；如果没有该选项，在遇到第一个错误时make程序马上就会停止，那么后面的错误情况就不得而知了。

我们可以利用这个选项来查出所有有编译问题的源文件。

–n：该选项使make程序进入非执行模式，也就是说将原来应该执行的命令输出，而不是执行。

–f ：指定作为makefile的文件的名称。

如果不用该选项，那么make程序首先在当前目录查找名为makefile的文件，如果没有找到，它就会转而查找名为Makefile的文件。

如果您在Linux下使用GNU Make的话，它会首先查找GNUmakefile，之后再搜索makefile和Makefile。

makefile make install 用法举例Makefile是一种用于自动化编译和构建软件的工具，它可以根据不同的构建目标（如编译、安装等）自动生成相应的构建指令。

在Makefile中，可以使用make命令来执行构建任务，其中make install是一种常用的构建指令，用于安装软件包。

一、Makefile的创建在创建Makefile之前，需要了解项目的基本结构和依赖关系，并根据需求定义不同的构建目标。

Makefile通常包含多个规则，每个规则定义了一个特定的构建目标及其对应的构建指令。

以下是一个简单的Makefile示例，用于编译一个C语言程序：```makefileCC=gccCFLAGS=-Wall -gSRC=main.c utils.cOBJ=$(SRC:.c=.o)all: $(SRC) Makefile $(OBJ)$(CC) $(CFLAGS) $(OBJ) -o program%.o: %.c$(CC) $(CFLAGS) -c $< -o $@clean:rm -f $(OBJ) $(EXE) *.o core* *~ .depend```在这个示例中，我们定义了两个规则：all规则和%.o规则。

all规则用于定义编译和链接指令，而%.o规则用于定义编译指令。

在执行make命令时，Makefile会根据当前目录下的Makefile和源文件自动生成相应的构建指令。

二、make install的使用make install是Makefile中常用的一种构建指令，用于将软件包安装到目标系统中。

使用make install命令时，需要指定安装的目标目录和安装选项。

下面是一个简单的示例：假设我们有一个名为myapp的软件包，将其安装到/usr/local/目录下：```bashmake install prefix=/usr/local/```在这个示例中，我们使用make install命令将myapp软件包安装到/usr/local/目录下。

linux vscode makefile语法在Linux 系统中，如果您想使用VSCode 编写Makefile 相关的项目，可以参考以下步骤进行安装和配置：1. 首先，确保已经正确安装了Visual Studio Code。

如果尚未安装，可以参考[1] 中的教程进行安装。

2. 安装Makefile 插件。

打开VSCode，转到“扩展”选项卡（快捷键：Ctrl+Shift+X），搜索“Makefile”，找到名为“Makefile Support”的插件，点击“安装”。

3. 创建一个新的Makefile 项目。

在VSCode 中，创建一个新的文件夹，然后在该文件夹中打开终端（快捷键：Ctrl+`）。

4. 编写Makefile 语法。

在项目根目录下创建一个名为“Makefile”的文件，然后编写相应的Makefile 语法。

以下是一个简单的示例：```make# 设置变量MY_PROJECT_NAME = MyProjectMY_PROJECT_VERSION = 1.0# 设置目标all: build# 构建目标build:echo "Building $MY_PROJECT_NAME $MY_PROJECT_VERSION"# 在这里添加您的构建命令，例如：cmake、make等# 清理目标clean:echo "Cleaning $MY_PROJECT_NAME"# 在这里添加您的清理命令，例如：rm -rf build/# 默认执行构建目标default: build```5. 保存Makefile 文件并按F5 键运行项目。

VSCode 将会自动使用内置的终端执行Makefile 中的命令。

6. 如果需要使用GPU 加速构建，可以在Makefile 中添加相应的NVIDIA CUDA 或者AMD OpenCL 命令。

例如，如果您使用的是NVIDIA GPU，可以添加以下命令：```makebuild_gpu:echo "Building $MY_PROJECT_NAME $MY_PROJECT_VERSION using GPU"# 在这里添加您的GPU 构建命令，例如：nvcc、cuda编译器等```7. 按照项目需求修改Makefile 中的命令和目标。

Makefile文件解析在我写教程之前，我先感谢一下libnds的开发人员以及维护人员。

他们给我们提供了十分方便的开发库libnds，让我们能够更加快捷简单的开发NDS程序。

下面我们进入正题。

注：以下绿色为文件的原注释，紫色是我后来添加的注释方便大家理解。

#---------------------------------------------------------------------------------.SUFFIXES:#---------------------------------------------------------------------------------ifeq ($(strip $(DEVKITARM)),)$(error "Please set DEVKITARM in your environment. export DEVKITARM=<path to>devkitARM")endifinclude $(DEVKITARM)/ds_rules#---------------------------------------------------------------------------------# TARGET 输出名称# BUILD 生成文件夹名称，对象文件以及中间文件将会被放在这个文件夹中。

# SOURCES 包含源文件的目录列表# INCLUDES 包含外部头文件的目录列表# DATA 包含二进制数据的目录列表# GRAPHICS 用grit处理文件的目录列表# AUDIO 包含用mmutil来处理的文件的文件目录# SOUNDBANK_NAME maxmod生成的soundbank的名称#MUSIC 外部音频文件目录## 所有的文件必须在与项目相关的能够找到makefile文件的文件目录下。

#---------------------------------------------------------------------------------TARGET := $(notdir $(CURDIR))BUILD := buildSOURCES := sourceINCLUDES := includeMUSIC := maxmod_data#---------------------------------------------------------------------------------# 以上部分相当于编程语言中的宏定义部分，通过:=给宏定义的变量名成进行赋值# 在以下的代码中有使用到这些宏定义。

python makefile 用法在使用Python编写程序时，我们通常需要编译和运行代码，这就需要用到makefile。

makefile是一种可以自动化地构建程序的工具，它可以根据代码修改的情况自动判断哪些文件需要重新编译，从而提高程序的编译效率。

使用makefile的基本步骤如下：1. 创建一个名为makefile的文件，通常放在程序的根目录下。

2. 在makefile中定义一些变量，如编译器、编译选项等。

3. 定义一些规则，如编译规则、目标规则等。

4. 运行make命令，根据makefile的规则进行编译和链接。

下面是一个简单的makefile示例：```# 定义编译器和编译选项CC=gccCFLAGS=-Wall -g# 定义编译规则%.o: %.c$(CC) $(CFLAGS) -c $< -o $@# 定义目标规则main: main.o sub.o$(CC) $(CFLAGS) main.o sub.o -o main# 清除中间文件clean:rm -f *.o main```在这个示例中，我们定义了两个变量CC和CFLAGS，分别表示编译器和编译选项。

接着定义了一个编译规则，表示将.c文件编译成.o文件的过程。

其中，$<表示依赖文件（即输入文件），$@表示目标文件（即输出文件）。

最后定义了一个目标规则，表示将main.o和sub.o链接成可执行文件main。

最后，我们定义了一个清除中间文件的规则，可以通过运行make clean来清除中间文件。

可以通过运行make命令来编译和链接程序。

例如，如果你有一个名为main.c和sub.c的源文件，并想将它们编译成可执行文件main，可以在终端中输入以下命令：```$ make main```这将根据makefile中定义的规则自动编译和链接程序，并生成可执行文件main。

总之，makefile是一个非常有用的编译工具，可以帮助我们自动化地构建程序，提高编译效率。

MakefileMake的基本规则：Target [属性] 分隔符 [依赖文件] [;命令行 ]{Tab 命令行}注：命令行间可以加入任意多个空行，但空行也要以tab开头。

Cat –v -t -e Makefile会使Makefile文件中tab以^]显示，行尾以$显示。

注：命令过长，用\来连接多行成一行。

注释以#开头，如果#要用作字符符号，―#‖。

分隔符：：：目标有多个规则。

哪条规则中的依赖文件比目标新，执行哪条规则。

如果多条规则的依赖文件都比目标新，多条规则都执行。

由于后面的规则可能覆盖前面规则的执行结构，所以规则顺序不同，执行结构也不同。

：^把本规则依赖文件和目标文件已有的依赖文件合起来，生成目标新的依赖文件列表。

：-清除目标已有依赖文件，把本规则依赖文件作为目标依赖文件列表。

：！对每个更新过的依赖文件都执行一次命令菜单。

：|内部规则专用。

如：file.o ：file.cfile.o ：^ filef.c现依赖文件为file.c filef.cfile.o ：- filef.c现依赖文件为 filef.c令行属性：- 若本命令的执行错误，忽略掉，继续向下执行。

（不加该标志，make会停止）+ 始终执行本命令，即使make参数使用了-n-q-t。

（前提是本规则中依赖文件新与目标文件，命令行需要执行）@ 本命令行不在标准输出显示。

Target属性：指定多个目标文件属性：属性属性…… ：目标目标……规则中指定单个目标属性：目标属性：[依赖文件] ……·IGNORE 类似与命令行属性-·SILENT 类似与命令行属性@·PRECIOUS 保留中间文件·LIBRARY 目标是一个库。

如果make发现目标是lib(member)或lib((entry))形式，会自动给名为lib的目标加上该属性。

·LIBRARYM 目标是库的一个成员。

如果make发现目标是lib（member）形式，会自动给lib目标加上·LIBRARY，被member目标加上·LIBRARYM。

手把手教你如何写Makefile陈皓 2005.04.01一、Makefile的规则在讲述这个Makefile之前，还是让我们先来粗略地看一看Makefile的规则。

target ... : prerequisites ...commandtarget也就是一个目标文件，可以是Object File，也可以是执行文件。

还可以是一个标签（Label），对于标签这种特性，在后续的“伪目标”章节中会有叙述。

prerequisites就是，要生成那个target所需要的文件或是目标。

command也就是make需要执行的命令。

（任意的Shell命令）这是一个文件的依赖关系，也就是说，target这一个或多个的目标文件依赖于prerequisites 中的文件，其生成规则定义在command中。

说白一点就是说，prerequisites中如果有一个以上的文件比target文件要新的话，command所定义的命令就会被执行。

这就是Makefile的规则。

也就是Makefile中最核心的内容。

说到底，Makefile的东西就是这样一点，好像我的这篇文档也该结束了。

呵呵。

还不尽然，这是Makefile的主线和核心，但要写好一个Makefile还不够，我会以后面一点一点地结合我的工作经验给你慢慢到来。

内容还多着呢。

：）二、一个示例正如前面所说的，如果一个工程有3个头文件，和8个C文件，我们为了完成前面所述的那三个规则，我们的Makefile应该是下面的这个样子的。

edit : main.o kbd.o command.o display.o \insert.o search.o files.o utils.occ -o edit main.o kbd.o command.o display.o \insert.o search.o files.o utils.omain.o : main.c defs.hcc -c main.ckbd.o : kbd.c defs.h command.hcc -c kbd.ccommand.o : command.c defs.h command.hcc -c command.cdisplay.o : display.c defs.h buffer.hcc -c display.cinsert.o : insert.c defs.h buffer.hcc -c insert.csearch.o : search.c defs.h buffer.hcc -c search.cfiles.o : files.c defs.h buffer.h command.hcc -c files.cutils.o : utils.c defs.hcc -c utils.cclean :rm edit main.o kbd.o command.o display.o \insert.o search.o files.o utils.o反斜杠（\）是换行符的意思。

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的规则本章我们将讨论Makefile的一个重要内容，规则。

熟悉规则对于书写Makefile至关重要。

Makefile中，规则描述了在何种情况下使用什么命令来重建一个特定的文件，此文件被称为规则“目标”（通常规则中的目标只有一个）。

规则中出目标之外的罗列的其它文件称为“目标”的依赖，而规则的命令是用来更新或者创建此规则的目标。

除了makefile的“终极目标”所在的规则以外，其它规则的顺序在makefile文件中没有意义。

“终极目标”就是当没有使用make 命令行指定具体目标时，make默认的更新的哪一个目标。

它是makefile文件中第一个规则的目标。

如果在makefile中第一个规则有多个目标的话，那么多个目标中的第一个将会被作为make的“终极目标”。

有两种情况的例外：1. 目标名以点号“.”开始的并且其后不存在斜线“/”（“./”被认为是当前目录；“../”被认为是上一级目录）；2. 模式规则的目标。

当这两种目标所在的规则是Makefile的第一个规则时，它们并不会被作为“终极目标”。

“终极目标”是执行make的唯一目的，其所在的规则作为第一个被执行的规则。

而其它的规则是在完成重建“终极目标”的过程中被连带出来的。

所以这些目标所在规则在Makefile中的顺序无关紧要。

因此，我们书写的makefile的第一个规则应该就是重建整个程序或者多个程序的依赖关系和执行命令的描述。

4.1 一个例子我们来看一个规则的例子：foo.o : foo.c defs.h # module for twiddling the frobscc -c -g foo.c这是一个典型的规则。

看到这个例子，大家应该能够说出这个规则的各个部分之间的关系。

不过我们还是要把这个例子拿出来讨论。

目的是让我们更加明确地理解Makefile的规则。

本例第一行中，文件“foo.o”是规则需要重建的文件，而“foo.c”和“defs.h”是重建“foo.o”所要使用的文件。

makefile gcc编译
Makefile 是一个用来组织代码编译的工具，而 GCC 是一个常用的 C 和 C++ 编译器。

在 Makefile 中使用 GCC 进行编译可以通过以下步骤完成：
1. 创建一个名为 "Makefile" 的文本文件，并确保它位于你的项目根目录下。

2. 在 Makefile 中定义你的编译规则。

例如，假设你有一个名为 "main.c" 的源文件需要编译成可执行文件 "app"，你可以这样编写 Makefile：
make.
app: main.c.
gcc -o app main.c.
在这个例子中，我们定义了一个名为 "app" 的目标，它依赖于"main.c" 这个源文件。

当你运行 "make" 命令时，Make 工具会根
据这个规则来执行编译。

3. 打开终端，进入到包含 Makefile 的项目目录下。

4. 运行命令 "make"。

Make 工具会读取 Makefile 文件，并执行其中定义的编译规则。

在这个例子中，它会使用 GCC 编译器来编译 "main.c" 并生成可执行文件 "app"。

需要注意的是，Makefile 可以包含更复杂的规则和变量定义，以及支持多个源文件的编译。

你可以根据你的项目需求来进一步扩展和定制 Makefile 文件。

总之，通过合理编写 Makefile 并结合使用 GCC 编译器，你可以高效地组织和管理你的代码编译过程。

Makefile经典教程0 Makefile概述什么是makefile？或许很多Winodws的程序员都不知道这个东西，因为那些Windows的IDE都为你做了这个工作，但我觉得要作一个好的和professional的程序员，makefile还是要懂。

这就好像现在有这么多的HTML的编辑器，但如果你想成为一个专业人士，你还是要了解HTML的标识的含义。

特别在Unix下的软件编译，你就不能不自己写makefile了，会不会写makefile，从一个侧面说明了一个人是否具备完成大型工程的能力。

因为，makefile关系到了整个工程的编译规则。

一个工程中的源文件不计数，其按类型、功能、模块分别放在若干个目录中，makefile定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作，因为makefile就像一个Shell脚本一样，其中也可以执行操作系统的命令。

makefile带来的好处就是——“自动化编译”，一旦写好，只需要一个make命令，整个工程完全自动编译，极大的提高了软件开发的效率。

make是一个命令工具，是一个解释makefile中指令的命令工具，一般来说，大多数的IDE都有这个命令，比如：Delphi的make，Visual C++的nmake，Linux下GNU的make。

可见，makefile都成为了一种在工程方面的编译方法。

现在讲述如何写makefile的文章比较少，这是我想写这篇文章的原因。

当然，不同产商的make各不相同，也有不同的语法，但其本质都是在“文件依赖性”上做文章，这里，我仅对GNU的make进行讲述，我的环境是RedHat Linux 8.0，make的版本是3.80。

必竟，这个make是应用最为广泛的，也是用得最多的。

而且其还是最遵循于IEEE 1003.2-1992 标准的（POSIX.2）。

在这篇文档中，将以C/C++的源码作为我们基础，所以必然涉及一些关于C/C++的编译的知识，相关于这方面的内容，还请各位查看相关的编译器的文档。

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的流程。

C语⾔Make命令教程make只是⼀个根据指定的Shell命令进⾏构建的⼯具在linux和unix中，有⼀个强⼤的使⽤程序，叫make，可以⽤它来管理多模块程序的编译和链接，直⾄⽣成可执⾏⽂件make使⽤程序读取⼀个说明⽂件，称为Makefile，Makefile⽂件中描述了整个软件⼯程的编译规则和各个⽂件之间的依赖关系；Makefile就像是⼀个Shell脚本⼀样，其中可以执⾏操作系统的命令，它带来的好处就是我们能够实现“⾃动化编译”，⼀旦写好，只要⼀个make命令，整个软件功能就完全⾃动编译，极⼤的提⾼了软件开发的效率；make是⼀个命令⼯具，是⼀个解释Makefile中指令的命令⼯具，⼀般来说⼤多数IDE都有这个命令使⽤make可以是重新编译的次数达到最⼩化；格式Makefile⽂件由⼀系列规则（rules）构成。

每条规则的形式如下。

<target> : <prerequisites>[tab] <commands>target⼀个⽬标（target）就构成⼀条规则。

⽬标通常是⽂件名，指明Make命令所要构建的对象，⽬标可以是⼀个⽂件名，也可以是多个⽂件名，之间⽤空格分隔。

伪⽬标除了⽂件名，⽬标还可以是某个操作的名字，这称为"伪⽬标"（phony target）clean:rm *.oclean不是⽂件名，⽽是操作的名字，属于“伪⽬标”，作⽤是删除对象⽂件$ make clean注：如果当前⽬录中，正好有⼀个⽂件叫做clean，那么此命令不会执⾏。

因为make发现clean⽂件已经存在，就没有必要重新构建了。

就不会执⾏rm命令。

为了避免这种情况，可以声明clean是“伪⽬标”。

.PHONY: cleanclean:rm *.o temp声明clean是伪⽬标之后，make就不会去检车是否存在⼀个叫做clean的⽂件，⽽是每次运⾏都执⾏对应的命令。

使⽤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⽂件，⼤致步骤相同。

cmakeqmakemakefile动态和静态库教程makefileMakefile经典教程(掌握这些⾜够)规则：makefile的基本规则就是:1. target 设定编译的target和各种的依赖⽂件已经如何从⽂件⽣成target的命令target : prerequisites ...commandtarget: 可以是object file，也可以是可执⾏⽂件，也可以是标签labelprerequisites: ⽣成target需要的⽂件或者其它的target; make 命令会检查这些依赖和上⼀次make相⽐是否有了改动，来决定这个target是否要重新更新。

command : 任何的shell命令,command⼀定要⽤Tab键开头。

对于command，GNU的make定义了⼀些隐含的规则，因此有的时候也可以不需要提供command，只提供target和依赖，GNU Make会⾃动调⽤隐含的规则(command)：GNU的make很强⼤，它可以⾃动推导⽂件以及⽂件依赖关系后⾯的命令，于是我们就没必要去在每⼀个[.o]⽂件后都写上类似的命令，因为，我们的make会⾃动识别，并⾃⼰推导命令。

⽐如：a.o : a.c不需要提供command，make会⾃动使⽤gcc来⽣成以上就是最核⼼的makefile的规则。

2. 常⽤的语法(1) \ 反斜杠：换⾏符合a.c \b.c(2) 变量定义objects = a.o b.o c.o在使⽤的时候: $(objects)来调⽤这个变量(3) .PHONY : label.PHONYb表⽰后⾯的是⼀个伪⽬标，、(4) 注释 : #(5) make 命令会在当前⽬录下⾃动找: GNUmakefile, makefile, Makefile⽂件进⾏编译，如果要指定可以使⽤ “ make -f xxx”或者 make --file xxx(6) include : include可以把其他的makefile包括到当前的makefile中。

文章标题：深入剖析CMake生成Makefile的流程与原理1. CMake介绍CMake是一个跨评台的自动化构建工具，可用于管理软件构建过程中的编译、信息、测试和安装等任务。

它采用了一种称为“CMakeLists.txt”的文本配置文件来描述项目的构建过程，然后根据这些描述生成不同评台下的构建脚本，如Makefile。

2. CMake生成Makefile的流程（1）项目目录结构：需要在项目目录下创建一个CMakeLists.txt文件，描述项目的组织结构和构建过程。

（2）配置CMake：运行cmake命令，指定项目的路径和生成的构建系统，如Unix的Makefile、Windows的Visual Studio项目等。

（3）生成Makefile：CMake解析CMakeLists.txt文件，生成相应的Makefile文件。

（4）编译项目：运行生成的Makefile文件，执行编译、信息等操作。

3. CMake生成Makefile的原理（1） CMakeLists.txt文件：该文件描述了项目的结构、依赖关系、编译选项等信息，CMake根据这些信息生成Makefile。

（2） CMake内部算法：CMake利用内部的算法来解析CMakeLists.txt文件，生成对应评台的构建脚本。

4. 个人观点和理解CMake的优势在于其跨评台性和灵活性，能够简化项目的构建过程，提高开发效率。

而CMake生成Makefile的过程则是其核心功能之一，可以帮助开发人员快速、高效地进行项目构建和管理。

总结与回顾本文深入剖析了CMake生成Makefile的流程与原理，介绍了CMake的基本概念和使用方法。

通过本文的阐述，读者可以更全面地了解CMake在软件构建中的作用和重要性，以及其生成Makefile的内部工作机制，希望能对读者有所帮助。

通过本文的了解，你是否对CMake生成Makefile的流程有了更深入的认识呢？让我们一起来探索和学习吧！CMake作为一个跨评台的自动化构建工具，其生成Makefile的流程和原理是非常重要的，了解这些内容有助于开发人员更好地使用和理解CMake，提高项目构建的效率和质量。