MAKEfile教程
makefile中使用cp命令
makefile中使用cp命令介绍在编写软件项目时，为了方便管理和构建代码，我们通常会使用makefile来自动化构建过程。
makefile是一种用于描述代码构建规则的文件，其中可以包含各种命令和指令。
其中，cp命令是makefile中常用的一个命令，用于复制文件或目录。
cp命令的基本用法cp命令的基本语法如下：cp [选项] 源文件目标文件其中，选项可以用来指定一些复制的行为，例如是否覆盖目标文件、是否保留源文件的属性等。
源文件是要复制的文件或目录，目标文件是复制后的文件或目录的名称。
cp命令的常见选项cp命令有许多选项可以用来控制复制的行为，下面是一些常见的选项： - -r：递归地复制目录及其内容。
- -f：强制复制，即使目标文件已经存在也进行复制。
- -i：交互式复制，如果目标文件已经存在，会询问是否覆盖。
- -p：保留源文件的属性，包括权限、时间戳等。
- -u：只复制更新的文件，即只复制源文件比目标文件新的文件。
- -v：显示详细的复制过程。
使用cp命令复制文件在makefile中使用cp命令复制文件可以方便地将源文件复制到目标文件中。
下面是一个简单的示例：all:cp source_file.txt target_file.txt上述示例中，我们使用了makefile的规则，其中all是规则的目标，cpsource_file.txt target_file.txt是规则的命令。
当我们运行make命令时，makefile会根据规则执行相应的命令，从而完成文件的复制。
使用cp命令复制目录除了复制文件，cp命令还可以复制目录及其内容。
在makefile中，我们可以使用cp命令的-r选项来递归地复制目录。
下面是一个示例：all:cp -r source_directory target_directory上述示例中，我们使用了-r选项来递归地复制source_directory目录及其内容到target_directory目录中。
makefile -d 用法
makefile -d 用法Makefile 文件用于构建和管理项目，指导make 工具完成自动化编译、链接和部署等工作。
下面是一个示例的Makefile 文件的用法：1. 定义变量：CC = gccCFLAGS = -Wall -Werror可以通过定义变量来设置编译器和编译选项，方便后续的使用。
2. 定义目标和规则：all: targettarget: dependencies(CC) (CFLAGS) -o target dependency_files`all` 是Makefile 的默认目标，当直接运行make 命令时，会执行all 目标下的规则。
`target` 是需要生成的目标文件，例如可执行程序等。
`dependencies` 是生成`target` 所依赖的文件，也可以是其他目标。
`(CC) (CFLAGS)` 是编译器和编译选项。
`-o target` 指定生成的目标文件名。
`dependency_files` 是`target` 的依赖文件，即需要编译的源文件。
3. 添加其他规则：例如，可以添加clean 规则用于清理生成的文件：clean:rm -f target其中`clean` 是目标名，`rm -f target` 是执行的命令，用于删除生成的`target` 文件。
4. 执行make 命令：在终端中执行`make` 命令即可根据Makefile 文件中的规则自动编译、链接和生成目标文件。
以上是Makefile 文件的一些基本用法，根据具体需求可以添加其他规则和变量。
详细使用方式可以参考GNU make 的官方文档。
c语言makefile编写实例
c语言makefile编写实例Makefile是用来管理程序编译的工具，可以方便地管理程序的编译过程。
使用Makefile可以大大简化程序的编译过程，提高程序的可维护性。
Makefile的语法比较简单，主要由目标、依赖和命令三部分组成。
下面我们以一个简单的C程序为例，来介绍如何使用Makefile进行编译。
假设我们有一个名为hello.c的程序，代码如下：```c#include <stdio.h>int main(){printf("Hello, world!\n");return 0;}```我们需要使用gcc编译器将其编译成可执行文件。
下面是一个简单的Makefile：```makefilehello: hello.cgcc -o hello hello.c```这个Makefile很简单，它定义了一个名为hello的目标，该目标依赖于hello.c文件，并使用gcc命令将其编译成可执行文件。
如果我们在终端中输入make命令，Makefile会自动执行编译过程：```$ makegcc -o hello hello.c```Makefile还可以定义多个目标，每个目标可以有多个依赖和多个命令。
下面是一个稍微复杂一些的Makefile：```makefileCC=gccCFLAGS=-Wall -gall: hello goodbyehello: hello.o$(CC) $(CFLAGS) -o hello hello.ogoodbye: goodbye.o$(CC) $(CFLAGS) -o goodbye goodbye.ohello.o: hello.c$(CC) $(CFLAGS) -c hello.cgoodbye.o: goodbye.c$(CC) $(CFLAGS) -c goodbye.cclean:rm -f *.o hello goodbye```这个Makefile定义了两个目标：all和clean。
vscode makefile语法
vscode makefile语法Visual Studio Code (VSCode) 支持多种编程语言的语法高亮和智能代码补全，包括 Makefile。
在 VSCode 中，你可以使用以下步骤来配置 Makefile 的语法高亮和智能代码补全：1. 打开 VSCode。
2. 在左侧的资源管理器中，找到并打开你的 Makefile 文件。
3. 点击顶部菜单栏中的 "查看"，然后选择 "命令面板"。
4. 在命令面板中输入 "Color Theme"，然后选择一个你喜欢的颜色主题。
5. 确保你的 Makefile 文件已经保存，然后按下 `F5` 键，VSCode 将自动检测 Makefile 的语法并启用语法高亮。
6. 在编写 Makefile 时，VSCode 会自动提供智能代码补全功能。
你可以按下 `Ctrl+Space` 键来触发代码补全提示。
如果你想要更深入地自定义 VSCode 的 Makefile 语法高亮和智能代码补全功能，你可以参考以下步骤：1. 打开 VSCode 的设置。
你可以按下 `Ctrl+,` 键来打开设置，或者在左侧的资源管理器中右键点击一个文件或文件夹，然后选择 "Open Settings"。
2. 在设置中，搜索 "Files: Language Mode"。
3. 在 "Files: Language Mode" 设置中，选择 "Editor Config" 或 "File Association"。
如果你选择了 "Editor Config"，VSCode 将使用 Editor Config 文件来决定如何解析和显示 Makefile 文件。
如果你选择了 "File Association"，VSCode 将使用文件关联来决定如何解析和显示 Makefile 文件。
makefile make install 用法举例
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语法在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 中的命令和目标。
python makefile 用法
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是一个非常有用的编译工具，可以帮助我们自动化地构建程序，提高编译效率。
makefile编译流程
makefile编译流程Makefile是一种用于自动化编译的工具，它可以根据源代码文件的依赖关系自动编译出目标文件。
Makefile的编写需要遵循一定的规则和语法，下面将介绍Makefile的编译流程。
1. 编写Makefile文件Makefile文件是一个文本文件，其中包含了编译的规则和依赖关系。
在编写Makefile文件时，需要遵循一定的语法规则，如使用TAB键缩进、使用变量和函数等。
2. 执行make命令在Makefile文件所在的目录下执行make命令，make会自动读取Makefile文件，并根据其中的规则和依赖关系进行编译。
如果Makefile文件中没有指定目标，则默认编译第一个目标。
3. 分析依赖关系在执行make命令时，make会先分析Makefile文件中的依赖关系，确定哪些文件需要重新编译。
如果某个源文件被修改了，那么与之相关的目标文件也需要重新编译。
4. 编译源文件在确定需要重新编译的文件后，make会依次编译每个源文件，生成对应的目标文件。
编译过程中，make会根据Makefile文件中的规则和命令进行编译。
5. 链接目标文件在所有的源文件都编译完成后，make会将所有的目标文件链接起来，生成最终的可执行文件。
链接过程中，make会根据Makefile文件中的规则和命令进行链接。
6. 完成编译当所有的源文件都编译完成并链接成功后，make会输出编译成功的信息，并生成最终的可执行文件。
如果编译过程中出现错误，make会输出错误信息并停止编译。
总之，Makefile编译流程是一个自动化的过程，它可以大大提高编译的效率和准确性。
在编写Makefile文件时，需要注意语法规则和依赖关系，以确保编译过程的正确性。
【重要】调用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 gcc编译
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经典教程(最掌握这部分足够---因为汇集全部精华)!!!!!!!!!!
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.在当前目录下创建一个名为hello的子目录。hello这个目录用于存放hello.c这个程序及相关文件。新建一个源程序文件hello.c
#include <stdio.h>
int main(int argc, char** argv)
{
printf("Welcome to use autoconf and automake\n");
通过以上步骤，在源代码所在目录下自动生成了Makefile文件。
configure.in文件
autoconf提用来产生"configure"文件的工具。"configure"是一个Shell脚本，它可以自动设定一些编译参数使程序能够在不同平台上进行编译。autoconf读取configure.in文件然后产生，"configure"这个Shell脚本。
如何使用产生的Makefile文件
执行configure脚本文件所产生的Makefile文件有几个预定的选项可供使用。
l make all:产生设定的目标，即生成所有的可执行文件。使用make也可以达到此目的。
l make clean:删除之前编译时生成的可执行文件及目标文件(形如*.o的中间文件)。
configure.in文件的内容是一系列GNU m4的宏，这些宏经autoconf理后会变成检查系统特性的Shell脚本。configure.in文件中宏的顺序并没有特别的规定，但是每一个configure.in文件必须以宏AC_INIT开头，以宏AC_OUTPUT结束。一般可先用autoscan这个工具扫描原始文件以产生一个configure.scan文件，再对configure.scan作些修改，从而生成configure.in文件
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 基础教程（重制版）
6.3 命令出错......................................................................................................... 29 6.4 嵌套执行 make（级联） ............................................................................... 30 6.5 定义命令包..................................................................................................... 33 第 7 章 Makefile 中变量的使用 ............................................ 34 7.1 变量的基础..................................................................................................... 34 7.2 变量中的变量................................................................................................. 35 7.3 变量的高级用法............................................................................................. 37 7.4 追加变量值..................................................................................................... 40 7.5 override 指示符 .............................................................................................. 41 7.6 多行变量......................................................................................................... 41 7.7 环境变量......................................................................................................... 42 7.8 目标变量......................................................................................................... 42 7.9 模式变量......................................................................................................... 43 第 8 章 Makefile 中的条件判断 ............................................ 44 8.1 Makefile 中的条件判断语句的示例 ............................................................. 44 8.2 Makefile 中的条件表达式的语法 ................................................................. 45 第 9 章 Makefile 中函数的使用 ............................................ 47 9.1 函数调用的语法............................................................................................. 47 9.2 字符串处理函数............................................................................................. 48 9.3 文件名操作函数............................................................................................. 52 9.4 foreach 函数.................................................................................................... 54 9.5 if 函数 ............................................................................................................. 55 9.6 call 函数 .......................................................................................................... 55 9.7 origin 函数 ...................................................................................................... 56 9.8 shell 函数 ........................................................................................................ 57 9.9 控制 make 命令的函数 .................................................................................. 58 9.10 wildcard 函数................................................................................................ 58 第 10 章 make 的运行原理 ................................................ 60 10.1 make 的退出码 ............................................................................................. 60
qtcreator通过makefile编译项目
qtcreator通过makefile编译项目一、引言Qt Creator是一款流行的跨平台集成开发环境，广泛应用于开发Qt应用程序。
在Qt Creator中，通过Makefile进行项目编译是一种常见的做法。
通过Makefile，开发者可以更好地控制编译过程，提高编译效率。
本篇文档将详细介绍如何使用Qt Creator和Makefile来编译项目。
二、准备工作1. 确保已安装Qt Creator并配置好Qt环境。
2. 准备一个包含Makefile的项目文件，确保Makefile结构正确。
3. 确保项目中包含了必要的源代码文件。
三、编译流程1. 打开Qt Creator，选择你要编译的项目。
2. 在项目窗口中，展开"Projects"菜单，选择"Run"->"Build"或"Rebuild"。
4. 如果编译过程中出现错误，可以通过调试窗口查看错误信息，并针对性地进行修改和重新编译。
四、Makefile结构Makefile是用来定义编译规则的文件，它描述了如何将源文件编译成可执行文件。
一个基本的Makefile结构如下：```arduino# Makefile for myprojectTARGET := myproject # 目标文件或可执行文件的名字.CFLAGS := -Wall # 编译参数.CXXFLAGS := $(CFLAGS) # 如果有C++源文件的话.SOURCES := main.cpp # 源文件列表.OBJECTS := $(SOURCES:.cpp=.o) # 将源文件扩展名改为.o进行编译.all: $(TARGET)$(TARGET): $(OBJECTS)$(Q)g++ -o $(TARGET) $(OBJECTS)```上述Makefile中，各个部分的意义如下：* `TARGET`：目标文件或可执行文件的名称。
windows下makefile教程
windows下的makefile教程先说几句废话以前看书时经常遇到makefile，nmake这几个名词，然后随之而来的就是一大段莫名其妙的代码，把我看得云里雾里的。
在图书馆和google上搜了半天，也只能找到一些零零星星的资料，把我一直郁闷得不行。
最近因缘巧合，被我搞到了一份传说中的MASM6手册，终于揭开了NMAKE的庐山真面目。
想到那些可能正遭受着同样苦难的同志以及那些看到E文就头晕的兄弟，所以就写了这篇文章。
假如大家觉得有帮助的话，记得回复一下，当作鼓励！如果觉得很白痴,也请扔几个鸡蛋.本文是总结加翻译，对于一些关键词以及一些不是很确定的句子，保留了英文原版，然后再在括号里给出自己的理解以作参考。
由于水平有限，加上使用NMAKE的经验尚浅，有不对的地方大家记得要指正唷。
MASM6手册在AOGO（好像是）可以download，在我的BLOG上有到那的链接。
关于NMAKEMicrosoft Program Maintenance Utility，外号NMAKE，顾名思义，是用来管理程序的工具。
其实说白了，就是一个解释程序。
它处理一种叫做makefile的文件（以mak为后缀），解释里面的语句并执行相应的指令。
我们编写makefile文件，按照规定的语法描述文件之间的依赖关系，以及与该依赖关系相关联的一系列操作。
然后在调用NMAKE时，它会检查所有相关的文件，如果目标文件（target file，下文简称target，即依赖于其它文件的文件）的time stamp （就是文件最后一次被修改的时间，一个32位数，表示距离1980年以来经过的时间，以2秒为单位）小于依赖文件（dependent file，下文简称dependent，即被依赖的文件）的time stamp，NMAKE就执行与该依赖关系相关联的操作。
请看下面这个例子：foo.exe : first.obj second.objlink first.obj,second.obj第一行定义了依赖关系，称为dependency line；第二行给出了与该依赖关系相关联的操作，称为command line。
cmakeqmakemakefile动态和静态库教程
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中。
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。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
概述——什么是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++的编译的知识，相关于这方面的内容，还请各位查看相关的编译器的文档。
这里所默认的编译器是UNIX下的GCC和CC。
关于程序的编译和链接——————————在此，我想多说关于程序编译的一些规范和方法，一般来说，无论是C、C++、还是pas，首先要把源文件编译成中间代码文件，在Windows下也就是 .obj 文件，UNIX下是 .o 文件，即Object File，这个动作叫做编译（compile）。
然后再把大量的Object File合成执行文件，这个动作叫作链接（link）。
编译时，编译器需要的是语法的正确，函数与变量的声明的正确。
对于后者，通常是你需要告诉编译器头文件的所在位置（头文件中应该只是声明，而定义应该放在C/C++文件中），只要所有的语法正确，编译器就可以编译出中间目标文件。
一般来说，每个源文件都应该对应于一个中间目标文件（O文件或是OBJ文件）。
链接时，主要是链接函数和全局变量，所以，我们可以使用这些中间目标文件（O文件或是OBJ 文件）来链接我们的应用程序。
链接器并不管函数所在的源文件，只管函数的中间目标文件（Object File），在大多数时候，由于源文件太多，编译生成的中间目标文件太多，而在链接时需要明显地指出中间目标文件名，这对于编译很不方便，所以，我们要给中间目标文件打个包，在Windows下这种包叫―库文件‖（Library File)，也就是 .lib 文件，在UNIX下，是Archive File，也就是 .a 文件。
总结一下，源文件首先会生成中间目标文件，再由中间目标文件生成执行文件。
在编译时，编译器只检测程序语法，和函数、变量是否被声明。
如果函数未被声明，编译器会给出一个警告，但可以生成Object File。
而在链接程序时，链接器会在所有的Object File中找寻函数的实现，如果找不到，那到就会报链接错误码（Linker Error），在VC下，这种错误一般是：Link 2001错误，意思说是说，链接器未能找到函数的实现。
你需要指定函数的Object File.好，言归正传，GNU的make有许多的内容，闲言少叙，还是让我们开始吧。
Makefile 介绍———————make命令执行时，需要一个Makefile 文件，以告诉make命令需要怎么样的去编译和链接程序。
首先，我们用一个示例来说明Makefile的书写规则。
以便给大家一个感兴认识。
这个示例来源于GNU的make使用手册，在这个示例中，我们的工程有8个C文件，和3个头文件，我们要写一个Makefile来告诉make命令如何编译和链接这几个文件。
我们的规则是：1）如果这个工程没有编译过，那么我们的所有C文件都要编译并被链接。
2）如果这个工程的某几个C文件被修改，那么我们只编译被修改的C文件，并链接目标程序。
3）如果这个工程的头文件被改变了，那么我们需要编译引用了这几个头文件的C文件，并链接目标程序。
只要我们的Makefile写得够好，所有的这一切，我们只用一个make命令就可以完成，make 命令会自动智能地根据当前的文件修改的情况来确定哪些文件需要重编译，从而自己编译所需要的文件和链接目标程序。
一、Makefile的规则在讲述这个Makefile之前，还是让我们先来粗略地看一看Makefile的规则。
target ... : prerequisites ...command...target也就是一个目标文件，可以是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‖的文件中，然后在该目录下直接输入命令―make‖就可以生成执行文件edit。
如果要删除执行文件和所有的中间目标文件，那么，只要简单地执行一下―make clean‖就可以了。
在这个makefile中，目标文件（target）包含：执行文件edit和中间目标文件（*.o），依赖文件（prerequisites）就是冒号后面的那些 .c 文件和 .h文件。
每一个 .o 文件都有一组依赖文件，而这些 .o 文件又是执行文件edit 的依赖文件。
依赖关系的实质上就是说明了目标文件是由哪些文件生成的，换言之，目标文件是哪些文件更新的。
在定义好依赖关系后，后续的那一行定义了如何生成目标文件的操作系统命令，一定要以一个Tab键作为开头。
记住，make并不管命令是怎么工作的，他只管执行所定义的命令。
make 会比较targets文件和prerequisites文件的修改日期，如果prerequisites文件的日期要比targets文件的日期要新，或者target不存在的话，那么，make就会执行后续定义的命令。
这里要说明一点的是，clean不是一个文件，它只不过是一个动作名字，有点像C语言中的lable 一样，其冒号后什么也没有，那么，make就不会自动去找文件的依赖性，也就不会自动执行其后所定义的命令。
要执行其后的命令，就要在make命令后明显得指出这个lable的名字。
这样的方法非常有用，我们可以在一个makefile中定义不用的编译或是和编译无关的命令，比如程序的打包，程序的备份，等等。
三、make是如何工作的在默认的方式下，也就是我们只输入make命令。
那么，1、make会在当前目录下找名字叫―Makefile‖或―makefile‖的文件。
2、如果找到，它会找文件中的第一个目标文件（target），在上面的例子中，他会找到―edit‖这个文件，并把这个文件作为最终的目标文件。
3、如果edit文件不存在，或是edit所依赖的后面的 .o 文件的文件修改时间要比edit这个文件新，那么，他就会执行后面所定义的命令来生成edit这个文件。
4、如果edit所依赖的.o文件也存在，那么make会在当前文件中找目标为.o文件的依赖性，如果找到则再根据那一个规则生成.o文件。
（这有点像一个堆栈的过程）5、当然，你的C文件和H文件是存在的啦，于是make会生成 .o 文件，然后再用 .o 文件生命make的终极任务，也就是执行文件edit了。