跟我一起学Makefile
makefile的用法
makefile的用法Makefile是一种用于自动化编译程序的工具，它可以根据源代码文件的依赖关系，自动编译出最终的可执行文件。
Makefile的使用可以大大提高程序的开发效率和可维护性，下面我们来详细了解一下Makefile的用法。
一、Makefile的基本语法Makefile的基本语法由一系列规则组成，每个规则由以下几部分组成：1. 目标(Target)：表示需要生成的文件名或者是一个伪目标，如clean。
2. 依赖(Prerequisites)：表示生成目标所依赖的文件或者是其他目标。
3. 命令(Command)：表示生成目标的具体命令。
例如，下面是一个简单的Makefile规则：```hello: main.o hello.ogcc -o hello main.o hello.omain.o: main.cgcc -c main.chello.o: hello.cgcc -c hello.c```这个Makefile规则表示需要生成一个名为hello的可执行文件，它依赖于main.o和hello.o两个目标文件。
生成hello文件的具体命令是gcc -o hello main.o hello.o。
同时，main.o和hello.o两个目标文件分别依赖于main.c和hello.c两个源代码文件，生成它们的具体命令是gcc -c main.c和gcc -c hello.c。
二、Makefile的常用命令1. make：执行Makefile文件，生成目标文件。
2. make clean：删除所有生成的目标文件。
3. make install：将生成的目标文件安装到指定的目录中。
4. make uninstall：卸载已经安装的目标文件。
5. make help：显示Makefile文件中定义的所有规则。
三、Makefile的高级用法1. 变量Makefile中可以定义变量，用于存储一些常用的参数或者路径。
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
手把手教你如何写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 语法学习有稍稍在Linux 下碰过程序设计的开发者应该会知道，make 是用来将程序代码、函式库、头文件及其它资源文件build 成最终成果（即：最终的应用程序）的超强力辅助工具。
当然了，并不是非得动用到make 才能build 程序，或许有什么程序设计魔人喜欢什么都自己手动进行；但利用make 及其参考档（输入档案）Makefile 将会让整个编译工作轻松许多。
若您曾经打包过Debian Package，那么应该会发现debuan/rule 这个档案的语法和Makefile 几乎是一模一样，所以学习Makefile 的语法对于Debian Package Maintainer 而言也是一门必要的功课。
Makefile语法：以下为Makefile 的基本语法，批注：以# 开头的即为批注。
变量宣告：（有人称之为宏）语法：MACRO = value注意到，在=前后必须加上空白，而变量名称为大小写相异。
利用MACRO = 来取消该变数。
在惯例上，Makefile 内部使用的变量名称使用小写；而使用者很可能从命令行自行另外指定数值的变量，像是CFLAGS，则是使用大写。
在Makefile 中，可利用$(MACRO) 或${MACRO} 来存取已定义的变量。
例：tragets = foo$(targets): common.hgcc -o $(targets) foo.c效果等同：foo: common.hgcc -o foo foo.c:=语法注意到，make 会将整个Makefile 展开后，再决定变数的值。
也就是说，变量的值将会是整个Mackfile 中最后被指定的值。
例：x = fooy = $(x) barx = xyz# y 的值为xyz bar在上例中，y 的值将会是xyz bar，而不是foo bar。
您可以利用:= 来避开这个问题。
:= 表示变量的值决定于它在Makefile 中的位置，而不是整个Makefile 展开后最终的值。
makefile 语法
makefile 语法makefile是一种常用的自动化构建工具，它可以帮助我们将源代码编译、链接、打包等一系列操作自动化完成。
在软件开发中，makefile 已经成为了不可或缺的工具之一。
本文将介绍 makefile的语法及其用法，希望能够帮助读者更好地理解和使用 makefile。
一、makefile 的基本语法makefile 的基本语法包括目标、依赖、命令三个要素。
下面我们来逐一介绍。
1. 目标目标是指要生成的文件，也就是 makefile 的最终输出。
目标通常是一个可执行文件、一个库文件或者一个归档文件。
在 makefile 中，目标通常以文件名的形式出现。
例如：```app: main.c func.c```这里的“app”就是目标。
2. 依赖依赖是指生成目标所需要的文件或者其他目标。
在 makefile 中，依赖通常以文件名的形式出现。
例如：```app: main.c func.c```这里的“main.c”和“func.c”就是依赖。
3. 命令命令是指生成目标所需要执行的命令。
在 makefile 中，命令通常以“TAB”键开头，并且必须与目标或者依赖之间有一个空格。
例如：```app: main.c func.cgcc main.c func.c -o app```这里的命令是“gcc main.c func.c -o app”。
二、makefile 的实例了解了 makefile 的基本语法后，我们来看一个简单的makefile 实例：```app: main.c func.cgcc main.c func.c -o app```这个 makefile 的作用是将“main.c”和“func.c”编译成一个可执行文件“app”。
如果我们在命令行中执行“make”命令，make 就会自动根据 makefile 中的规则来生成目标文件“app”。
三、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
makefile 速成
分享一篇前短时间总结的makefile速成，教你一天搞定makefile，略加实践掌握其最核心部分。
可以从下面的几个维度来学习和理解makefile：∙规则∙变量∙函数∙命令∙make的命令选项∙一个大型项目的makefile例子∙make –p的输出概览在正式介绍makefile的以上四个方面之前，首先一句话概括一下makefile 是什么：makefile是用来描述文件依赖关系，并告诉make命令如何根据这种依赖关系，调用shell完成目标文件建立的文件。
makefile的执行时通过两步来完成的，第一步是扫描文件中的依赖关系，并藉此建立依赖关系树，然后从最底层想上来执行。
1.规则（rule）Makefile从本质上说就是描述项目中文件依赖关系的文件。
这种依赖关系的描述就是规则。
Makefile的编写中的一切都是围绕规则来展开的，上面提到的四个方面：规则、变量、函数、命令都是为了规则能够方便快捷的发挥作用才引入的。
一个简单规则可以表述为：目标文件：依赖文件（不同文件以空格分隔）<tab>得到目标文件需要的命令规则的常见种类有：●∙Explicit Rule最简单的rule，明确指出了目标和依赖，以及如何有依赖得到目标。
举例：Hello.o:hello.cppg++ -c hello.cpp●∙Pattern Rule使用了wildcard（通配符）的规则。
makefile中的通配符是百分号%，相当于bash中的*，在描述规则的时候使用的都是%。
makefile中也可以看到通配符*，这个一般是出现在命令之中，命令是要放到shell中运行的，所以要使用*作为通配符。
举例：prog:*.cg++ -o prog $^●∙Suffix Rule顾名思义，是只使用后缀来描述的rule，描述的时候不使用pattern，举例：.c.o:$(COMPILE.C) $(OUTPUT_OPTION) $<这个suffix rule的作用和下面这个pattern rule的作用是完全一样的。
命令行Makefile和make命令讲解教程
命令行Makefile和make命令讲解教程.命令行Makefile和make命令讲解教程我们知道make是Linux下的一款程序自动维护工具，配合makefile的使用，就能够根据程序中模块的修改情况，自动判断应该对那些模块重新编译，从而保证软件是由最新的模块构成。
本文分为上下两部分，我们将紧紧围绕make在软件开发中的应用展开详细的介绍。
一、都是源文件太多惹得祸当我们在开发的程序中涉及众多源文件时，常常会引起一些问题。
首先，如果程序只有两三个源文件，那么修改代码后直接重新编译全部源文件就行了，但是如果程序的源文件较多，这种简单的处理方式就有问题了。
设想一下，如果我们只修改了一个源文件，却要重新编译所有源文件，那么这显然是在浪费时间。
其次，要是只重新编译那些受影响的文件的话，我们又该如何确定这些文件呢？比如我们使用了多个头文件，那么它们会被包含在各个源文件中，修改了某些头文件后，那些源文件受影响，哪些与此无关呢？如果采取拉网式大检查的话，可就费劲了。
由此可以看出，源文件多了可真是件让人头疼的事。
幸运的是，实用程序make可以帮我们解决这两个问题——当程序的源文件改变后，它能保证所有受影响的文件都将重新编译，而不受影响的文件则不予编译，这真是太好了。
二、Make程序的命令行选项和参数我们知道，make程序能够根据程序中各模块的修改情况，自动判断应对哪些模块重新编译，保证软件是由最新的模块构建的。
至于检查哪些模块，以及如何构建软件由makefile文件来决定。
虽然make可以在makefile中进行配置，除此之外我们还可以利用make程序的命令行选项对它进行即时配置。
Make命令参数的典型序列如下所示：make [-f makefile文件名][选项][宏定义][目标]Make命令本身的命令行选项较多，这里只介绍在开发程序时最为常用的三个，它们是：–k：如果使用该选项，即使make程序遇到错误也会继续向下运行；如果没有该选项，在遇到第一个错误时make程序马上就会停止，那么后面的错误情况就不得而知了。
详解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语法详解
makefile语法详解Makefile 是一种构建自动化工具，它用于管理源代码的编译顺序和依赖关系。
Makefile 使得程序员能够简化构建过程、自动处理依赖关系、并增强项目的可读性和可理解性。
Makefile 使用一些特定语法来实现这些功能，这篇文章将带领大家逐步学习 Makefile 的语法。
1. 行尾分隔符在 Makefile 中，行尾的分隔符是一个反斜杠（ \ ）。
这个符号可以将一行的内容分成多行，在下一行继续编写。
这样做不会改变命令的含义，但会使命令更易读。
2. 变量定义Makefile 中的变量可以定义用于存储字符串。
这些变量可以在整个 Makefile 中使用，方便地重用代码。
定义变量的语法是使用美元符号（ $）和括号（ ()）包含变量的名字。
例如：``` CFLAGS = -Wall -g CC = gcc ```在这个例子中，我们定义了两个变量，一个用于存储编译器选项（CFLAGS），另一个用于存储编译器名称（CC）。
3. 条件语句Makefile 支持条件语句来控制项目的编译方式。
条件语句的语法基于 ifeq、ifdef、ifndef、endif 等关键字。
例如，下面的代码段将根据目标平台指定编译器选项：``` ifndef PLATFORM $(error "You must define PLATFORM") endififeq ($(PLATFORM), WINDOWS) CFLAGS += -DWIN32 endif ```4. 函数Makefile 中的函数是一个有用的工具，可以实现在Makefile 中执行某些任务。
这些函数在规则和命令中使用，语法主要是通过 $() 实现的。
例如，$(wildcard) 函数，可以用于扩展通配符，例如：``` SOURCE_FILES = $(wildcard *.c) ```5. 模式规则Makefile 中的模式规则是一种将一类文件与另一类文件匹配的规则。
makefile入门【转】
makefile入门【转】makefile文件：在应用程序开发过程中，makefile文件包含了所有命令，宏定义，选项来编译工程，但是在wince的makefile文件中，它仅仅包含了一个文件：makefile.def. makefile.def中包含了sources文件需要用到的宏定义，并传递一些标志位给编译器和连接器使用，这些标志位都将直接作用到DDK编译环境，利用makefile.def 可以使PB驱动的建立单一化。
这也是PB的makefile与应用程序的makefile不同的原因了。
值得注意的是，一般不建议修改mekefile 和makefile.def文件。
1 makefile入门Windows CE的构建系统大量使用了Nmake工具和makfile。
在大多数微软的软件和驱动开发包中都会包含Nmake工具。
因此，这里有必要介绍一下makefile和Nmake工具。
1.1 makefile简介对于许多Windows下的程序员来说，makefile可能还是个陌生的名词。
因为Windows下的许多集成开发环境（例如：Microsoft Visual Studio和Borland C++ Builder等）可以帮助开发人员完成makefile需要完成的功能。
通常只需要在集成开发环境中按个按钮，工具就可自动帮助我们编译、链接整个项目。
想象如果没有了集成开发环境，那么就需要有另外一种方式来管理对项目的构建。
简单的来说，makefile负责帮助开发人员简化代码的编译、链接等构建工作。
对于只包含几个文件的简单的项目，开发人员完全可以通过手动控制编译器、链接器来完成对项目的构建。
但是想象一下对于一个拥有几百个、甚至几千个文件的大型项目，如果每次构建都是通过手动完成，那消耗的工作量和复杂程度是不可想象的。
在这种情况下，makefile就有了它的用武之地。
makefile关系到了整个工程的编译规则。
一个工程中的源文件不计数，其按类型、功能、模块分别放在若干个目录中，makefile定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作，因为makefile就像一个自动化脚本一样，其中也可以执行操作系统的命令。
跟我一起写Makefile（Linux）
跟我⼀起写Makefile（Linux）
1、昨天在 Linux 下⽤ touch 指令新建了⼀个 hello.c 并且使⽤ vim 编辑器写了代码，使⽤ gcc 指令编译最后运⾏成功了。
具体⽅式如下：
在Linux 根⽬录/ 下 root ⽂件下新建⼀个 learngit ⽂件夹（mkdir 指令），使⽤touch 指令创建⽂件 hello.c，使⽤vim 打开并编写以下代码
#include <stdio.h>
void main()
{
printf("Hello World\n");
}
接着使⽤指令： gcc hello.c，会发现在 learngit ⽂件下⽣成了 a.out ⽂件
接着使⽤ ./a.out 会发现会输出"Hello World",这⾥查了⼀下./ 表⽰当前⽬录，../表⽰上⼀⽬录。
2017年2⽉23⽇16:43:14。
# 根据Makefile 的过程1。
应该第⼀步：在所在的hello.c ⽂件路径下,新建⼀个⽂件名字为 Makefile”或“makefile”的⽂件。
# 根据Makefile 的过程2、3。
应该第⼆步：⽤ vim 打开 Makefile⽂件，第⼀⾏写代码 edit : hello.o
注意在 Makefile中不能随便出现 table，因为table代表接下来的信息是命令，命令⾏会被识别成红⾊如下截图！（注意截图中红⾊字体前⾯有⼀个 table 长度为4）
2017年2⽉25⽇18:42:42。
makefile基础实例讲解
makefile基础实例讲解Makefile基础实例讲解一、makefile简介定义：makefile定义了软件开发过程中，项目工程编译链、接接的方法和规则。
产生：由IDE自动生成或者开发者手动书写。
作用：Unix（MAC OS、Solars）和Linux（Red Hat、Ubuntu）系统下由make命令调用当前目录下的makefile文件执行，可实现项目工程的自动化编译。
二、语法规则target：prerequisitescommand其中，target为需要生成的目标，prerequisites为依赖项，command为make需要执行的命令（任意的Shell命令）。
注意：其中command前必须以tab键开始。
三、makefile内容Makefile里主要包含了五个东西：显式规则、隐晦规则、变量定义、文件指示和注释。
1．显式规则。
显式规则说明了，如何生成一个或多的的目标文件。
这是由Makefile的书写者明显指出，要生成的文件，文件的依赖文件，生成的命令。
2．隐晦规则。
由于我们的make有自动推导的功能，所以隐晦的规则可以让我们比较粗糙地简略地书写Makefile，这是由make所支持的。
3．变量的定义。
在Makefile中我们要定义一系列的变量，变量一般都是字符串，这个有点你C语言中的宏，当Makefile被执行时，其中的变量都会被扩展到相应的引用位置上。
4．文件指示。
其包括了三个部分，一个是在一个Makefile中引用另一个Makefile，就像C语言中的include一样；另一个是指根据某些情况指定Makefile中的有效部分，就像C 语言中的预编译#if一样；还有就是定义一个多行的命令。
有关这一部分的内容，请参考文末的参考资料。
5．注释。
Makefile中只有行注释，和UNIX的Shell脚本一样，其注释是用“#”字符，这个就像C/C++中的“//”一样。
如果你要在你的Makefile中使用“#”字符，可以用反斜框进行转义，如：“\#”。
makefile的使用
令，比如程序的打包，程序的备份，等等。
二、
三、make是如何工作的
在默认的方式下，也就是我们只输入make命令。那么，
1、make会在当前目录下找名字叫“Makefile”或“makefile”的文件。
e中指令的命令工具，一般来说，大多数的IDE都有这个命令，比如：Delphi的make，Visual
C++的nmake，Linux下GNU的make。可见，makefile都成为了一种在工程方面的编译方法。
现在讲述如何写makefile的文章比较少，这是我想写这篇文章的原因。当然，不同产商的ma
4、如果edit所依赖的.o文件也存在，那么make会在当前文件中找目标为.o文件的依赖
性，如果找到则再根据那一个规则生成.o文件。（这有点像一个堆栈的过程）
5、当然，你的C文件和H文件是存在的啦，于是make会生成 .o 文件，然后再用 .o 文
件生命make的终极任务，也就是执行文件edit了。
跟我一起写 Makefile分类:Linux下编程开发
什么是makefile？或许很多Winodws的程序员都不知道这个东西，因为那些Windows的IDE都
为你做了这个工作，但我觉得要作一个好的和professional的程序员，makefile还是要懂。
这就好像现在有这么多的HTML的编辑器，但如果你想成为一个专业人士，你还是要了解HTM
并链接目标程序。
只要我们的Makefile写得够好，所有的这一切，我们只用一个make命令就可以完成，make命
令会自动智能地根据当前的文件修改的情况来确定哪些文件需要重编译，从而自己编译所需
Makefile的学习笔记
Makefile的学习笔记Makefile的学习笔记1 MakefileGNU make的工作分为两个阶段。
在第一阶段，make读取makefile文件、内置变量及其值、隐含规则和具体规则、构造所有目标的依赖关系以及所有目标各自的依赖等。
在第二阶段，make决定需要重新构造的目标并使用必要的规则进行工作。
make工作第一阶段发生的扩展是立即扩展，直接把变量和函数扩展为makefile文件语句的一部分。
make工作第二阶段发生的扩展称为延时扩展。
1.1 make命令的使用make[option] [target]-Cdir ：在读入makefile之前，把路径切换到dir下。
如果同时使用几个‘-C’选项，则eachis interpreted relative to the previous one。
-d ：在正常处理后打印调试信息。
-e ：设置环境变量的优先权高于makefile文件变量的优先权。
-ffile ：将file设置为makefile文件。
-i ：忽略在执行重建文件命令时产生的所有错误。
-Idir ：指定搜寻makefile文件的路径。
如果同时使用几个‘-I’选项，则按照次序搜寻这些路径。
-k ：在出现错误后，尽可能的继续执行。
也就是说当一个目标创建失败后，所有依靠它的目标文件将不能重建，而这些目标的其它依赖则可继续处理。
-n ：打印要执行的命令，但却不执行它们。
-ofile ：即使文件file比它的依赖旧，也不重建该文件。
-p ：打印数据库，其中的数据来自读入makefile文件的结果；打印之后执行。
make –qp 打印数据库后不执行。
make –p –f/dev/null 打印预定义的规则和变量的数据库。
-q ：不打印也不执行命令。
如果所有目标都已经更新到最新，make的退出状态是0；如果一部分需要更新，退出状态是1；如果make遇到错误，退出状态是2。
-r ：禁止使用预定义的隐含规则，同时也清除了缺省的后缀列表和后缀规则。
跟我一起学makefile
Makefile学习教程: 跟我一起写Makefile o0 Makefile概述▪0.1 关于程序的编译和链接o 1 Makefile 介绍▪1.1 Makefile的规则▪1.2 一个示例▪1.3 make是如何工作的▪1.4 makefile中使用变量▪1.5 让make自动推导▪1.6 另类风格的makefile▪1.7 清空目标文件的规则o 2 Makefile 总述▪2.1 Makefile里有什么？▪2.2Makefile的文件名▪2.3 引用其它的Makefile▪2.4 环境变量MAKEFILES▪2.5 make的工作方式o 3 Makefile书写规则▪3.1 规则举例▪3.2 规则的语法▪3.3 在规则中使用通配符▪3.4 文件搜寻▪3.5 伪目标▪3.6 多目标▪3.7 静态模式▪3.8 自动生成依赖性o 4 Makefile 书写命令▪4.1 显示命令▪4.2 命令执行▪4.3 命令出错▪4.4 嵌套执行make▪4.5 定义命令包什么是makefile？或许很多Winodws的程序员都不知道这个东西，因为那些Windows的IDE都为你做了这个工作，但我觉得要作一个好的和professional 的程序员，makefile还是要懂。
这就好像现在有这么多的HTML的编辑器，但如果你想成为一个专业人士，你还是要了解HTML的标识的含义。
特别在Unix下的软件编译，你就不能不自己写makefile了，会不会写makefile，从一个侧面说明了一个人是否具备完成大型工程的能力。
因为，makefile关系到了整个工程的编译规则。
一个工程中的源文件不计数，其按类型、功能、模块分别放在若干个目录中，makefile定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作，因为makefile就像一个Shell脚本一样，其中也可以执行操作系统的命令。
makefile基础教程-makefile总述
makefile基础教程- makefile总述Makefile3.1 Makefile内容在一个完整的Makefile中，包含了5个东西：显式规则、隐含规则、变量定义、指示符和注释。
关于“规则”、“变量”和“Makefile指示符”将在后续的章节进行详细的讨论。
本章讨论的是一些基本概念。
, 显式规则：它描述了在何种情况下如何更新一个或者多个被称为目标的文件（Makefile的目标文件）。
书写Makefile时需要明确地给出目标文件、目标的依赖文件列表以及更新目标文件所需要的命令（有些规则没有命令，这样的规则只是纯粹的描述了文件之间的依赖关系）。
, 隐含规则：它是make根据一类目标文件（典型的是根据文件名的后缀）而自动推导出来的规则。
make根据目标文件的名，自动产生目标的依赖文件并使用默认的命令来对目标进行更新（建立一个规则）。
, 变量定义：使用一个字符或字符串代表一段文本串，当定义了一个变量以后，Makefile后续在需要使用此文本串的地方，通过引用这个变量来实现对文本串的使用。
第一章的例子中，我们就定义了一个变量“objects”来表示一个.o文件列表。
, Makefile指示符：指示符指明在make程序读取makefile文件过程中所要执行的一个动作。
其中包括：, 读取一个文件，读取给定文件名的文件，将其内容作为makefile文件的一部分。
, 决定（通常是根据一个变量的得值）处理或者忽略Makefile中的某一特定部分。
, 定义一个多行变量。
, 注释：Makefile中“#”字符后的内容被作为是注释内容（和shell脚本一样）处理。
如果此行的第一个非空字符为“#”，那么此行为注释行。
注释行的结尾如果存在反斜线（\），那么下一行也被作为注释行。
一般在书写Makefile时推荐将注释作为一个独立的行，而不要和Makefile的有效行放在一行中书写。
当在Makefile中需要使用字符“#”时，可以使用反斜线加“#”（\#）来实现（对特殊字符“#”的转义），其表示将“#”作为一字符而不是注释的开始标志。
C++学习进阶之Makefile基础用法详解
$(TARGET):$(TESTOBJ) $(LIB) $(CXX) $< -o $@ $(LDFLAGS) $(LDLIBS)
$(LIB):$(OBJS) $(CXX) -shared $^ -o $@
$(TESTOBJ) $(OBJS):%.o:%.cpp $(CXX) $(CXXFLAGS) $< -o $@
makefile 文件可改为：
TARGET = simpletest OBJS = simple.o simpletest.o
$(TARGET):$(OBJS) g++ $(OBJS) -o $(TARGET)
simple.o:simple.cpp simpletest.o:simpletest.cpp clean:
绝大多数的 IDE 开发环境都会为用户自动编写 Makefile。
Make 是怎么工作的？
Make 工作的原则就是：
一个目标文件当且仅当在其依赖文件（dependencies）的更改时间戳比该目标文件的创建时间戳新时，这个目标文件才需要 被重新编译。
Make 工具会遍历所有的依赖文件，并且把它们对应的目标文件进行更新。编译的命令和这些目标文件及它们对应的依赖文件 的关系则全部储存在 Makefile 中。
Makefile 中也指定了应该如何创建，创建出怎么样的目标文件和可执行文件等信息。
除此之外，你甚至还可以在 Makefile 中储存一些你想调用的系统终端的命令，像一个 Shell 脚本一样使用它。
作用：
Makefile 文件告诉 Make 怎样编译和连接成一个程序
可用命令 dnf install make 安装make功能
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
跟我一起写 Makefile作者：陈皓整理：祝冬华第一部分、概述 (6)第二部分、关于程序的编译和链接 (6)第三部分、Makefile 介绍 (7)一、Makefile的规则 (7)二、一个示例 (8)三、make是如何工作的 (9)四、makefile中使用变量 (10)五、让make自动推导 (11)六、另类风格的makefile (12)七、清空目标文件的规则 (13)第四部分、Makefile 总述 (13)一、Makefile里有什么？ (13)1、显式规则。
(14)2、隐晦规则。
(14)3、变量的定义。
(14)4、文件指示。
(14)5、注释。
(14)二、Makefile的文件名 (15)三、引用其它的Makefile (15)四、环境变量 MAKEFILES (16)五、make的工作方式 (16)第五部分、书写规则 (17)一、规则举例 (17)二、规则的语法 (17)三、在规则中使用通配符 (18)四、文件搜寻 (19)五、伪目标 (20)六、多目标 (22)七、静态模式 (22)八、自动生成依赖性 (24)第六部分书写命令 (25)一、显示命令 (26)二、命令执行 (26)三、命令出错 (27)四、嵌套执行make (28)五、定义命令包 (30)第七部分使用变量 (30)一、变量的基础 (31)二、变量中的变量 (32)三、变量高级用法 (34)四、追加变量值 (37)五、override 指示符 (37)六、多行变量 (38)八、目标变量 (39)九、模式变量 (40)第八部分使用条件判断 (40)一、示例 (40)二、语法 (42)第九部分使用函数 (43)一、函数的调用语法 (44)二、字符串处理函数 (44)1、subst (44)2、patsubst (45)3、strip (45)4、findstring (46)5、filter (46)6、filter-out (46)7、sort (47)8、word (47)9、wordlist (47)10、words (47)11、firstword (48)12、字符串函数实例 (48)三、文件名操作函数 (48)1、dir (48)2、notdir (48)3、suffix (49)4、basename (49)5、addsuffix (49)6、addprefix (49)7、join (50)四、foreach 函数 (50)五、if 函数 (50)六、call函数 (51)七、origin函数 (51)“undefined” (52)“default” (52)“file” (52)“command line” (52)“override” (52)“automatic” (52)八、shell函数 (53)九、控制make的函数 (53)1、error (53)2、warning (54)第十部分 make 的运行 (54)二、指定Makefile (54)三、指定目标 (55)“all” (56)“clean” (56)“install” (56)“print” (56)“tar” (56)“dist” (56)“TAGS” (56)“check”和“test” (56)四、检查规则 (57)五、make的参数 (57)第十一部分隐含规则 (61)一、使用隐含规则 (61)二、隐含规则一览 (62)1、编译C程序的隐含规则 (63)2、编译C++程序的隐含规则 (63)3、编译Pascal程序的隐含规则 (63)4、编译Fortran/Ratfor程序的隐含规则 (63)5、预处理Fortran/Ratfor程序的隐含规则 (63)6、编译Modula-2程序的隐含规则 (63)7、汇编和汇编预处理的隐含规则 (64)8、链接Object文件的隐含规则 (64)9、Yacc C程序时的隐含规则 (64)10、Lex C程序时的隐含规则 (64)11、Lex Ratfor程序时的隐含规则 (65)12、从C程序、Yacc文件或Lex文件创建Lint库的隐含规则 (65)三、隐含规则使用的变量 (65)1、关于命令的变量。
(65)2、关于命令参数的变量 (66)四、隐含规则链 (67)五、定义模式规则 (68)1、模式规则介绍 (68)2、模式规则示例 (69)3、自动化变量 (70)4、模式的匹配 (72)5、重载内建隐含规则 (72)六、老式风格的"后缀规则" (73)七、隐含规则搜索算法 (74)第十二部分使用make更新函数库文件 (75)一、函数库文件的成员 (75)二、函数库成员的隐含规则 (75)三、函数库文件的后缀规则 (76)第十三部分后序 (77)第一部分、概述什么是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中。