Makefile简介

GNU Makefile简介

1.基本 makefile 结构

GNU Make的主要工作是读进一个文本文件：makefile。这个文件里主要是有关哪些文件（‘target’目的文件）是从哪些别的文件（‘dependencies’依靠文件）中产生的，用什么命令来进行这个产生过程。有了这些信息，make会检查硬盘上的文件，如果目的文件的时间戳（该文件生成或被改动时的时间）比至少它的一个依靠文件旧的话， make 就执行相应的命令，以便更新目的文件。（目的文件不一定是最后的可执行文件，它可以是任何一个文件，甚至是一个不存在的文件）

makefile一般被叫做“makefile”或“Makefile”。当然也可以在make的命令行通过-f参数指定别的文件名。如果不特别指定，它会寻找当前目录下的“makefile”或“Makefile”文件，因此使用这两个名字是最简单的。

一个 makefile 主要含有一系列的规则，如下：

:

(tab)

(tab)

例如，考虑以下的 makefile 文件：

这是一个非常基本的makefile。make从最上面开始，把上面第一个目的：‘myprog’，做为它的主要目标（一个它需要保证其总是最新的最终目标）。给出的规则说明只要文件‘myprog’比文件‘foo.o’或‘bar.o’中的任何一个旧，下一行的命令将会被执行。

但是，在检查文件foo.o和bar.o的时间戳之前，它会往下查找那些把foo.o或bar.o做为目标文件的规则。它找到的关于foo.o的规则，该文件的依靠文件是foo.c, foo.h和bar.h 。它从下面再找不到生成这些依靠文件的规则，它就开始检查磁碟上这些依靠文件的时间戳。如果这些文件中任何一个的时间戳比foo.o的新，命令'gcc -o foo.o foo.c'将会执行，从而更新文件 foo.o 。

接下来对文件bar.o做类似的检查，依靠文件在这里是文件bar.c和bar.h 。

现在，make回到‘myprog’的规则。如果刚才两个规则中的任何一个被执行，myprog 就需要重建（因为其中一个 .o 就会比‘myprog’新），因此连接命令将被执行。

到此，可以看出使用make工具来建立程序的好处——源码文件里一个简单改变都会造成那个文件被重新编译（因为.o 文件依靠.c 文件），进而可执行文件被重新连接（因为 .o 文件被改变了）。其实真正的得益是在当改变一个header文件的时候——我们不再需要记住那个源码文件依靠它，因为所有的信息都在makefile里。make会很轻松的替我们重新编译所有那些因依靠这个header文件而改变了的源码文件，如有需要，再进行重新连接。

2.编写 make 规则 (Rules)

最明显的编写规则的方法是一个一个的查看源码文件，把它们的目标文件做为目的，而Ｃ源码文件和被它#include的header文件做为依靠文件。但是也要把其它被这些header文件#include 的header文件也列为依靠文件，还有那些被包括的文件所包括的文件……然后你会发现要对越来越多的文件进行管理，然后你的头发开始脱落，你的脾气开始变坏，你的脸色变成菜色，你走在路上开始跟电线杆子碰撞，终于你捣毁你的电脑显示器，停止编程。到低有没有些容易点儿的方法呢？

当然有！向编译器要！在编译每一个源码文件的时候，编译器实在应该知道应该包括什么样的header文件。使用gcc的时候，用-M 开关，它会为每一个指定的Ｃ文件输出一个规则，把目标文件做为目的，而这个Ｃ文件和所有应该被#include的header文件将做为依靠文件。注意这个规则会加入所有header文件，包括被角括号(`<', `>')和双引号(`"')所包围的文件。其实我们可以相当肯定系统header 文件（比如 stdio.h, stdlib.h 等等）不会被我们更改，如果用-MM来代替-M传递给gcc，那些用角括号包围的header文件将不会被包括。（这会节省一些编译时间）。

由gcc输出的规则不会含有命令部分；可以自己写入我们需要的命令或者也可以什么也不写，而让make使用它的隐含的规则。

3.Makefile 变量

上面提到makefiles里主要包含一些规则。它们包含的其它的东西是变量定义。makefile里的变量就像一个环境变量(environment variable)。事实上，环境变量在make过程中被解释成make的变量。这些变量是大小写敏感的，一般使用大写字母。它们可以从几乎任何地方被引用，也可以被用来做很多事情，比如：

1.贮存一个文件名列表。在上面的例子里，生成可执行文件的规则包含一些目标文

件名做为依靠。在这个规则的命令行里同样的那些文件被输送给gcc做为命令参

数。如果在这里使用一个变量来贮存所有的目标文件名，加入新的目标文件会变

的简单而且较不易出错。

2.贮存可执行文件名。如果项目被用在一个非gcc的系统里，或者如果想使用一个

不同的编译器，必须将所有使用编译器的地方改成用新的编译器名。但是如果使

用一个变量来代替编译器名，那么只需要改变一个地方，其它所有地方的命令名

就都改变了。

3.贮存编译器flags。假设想给你所有的编译命令传递一组相同的选项（例如

-Wall -O -g）；如果把这组选项存入一个变量，那么可以把这个变量放在所有

呼叫编译器的地方。而当要改变选项的时候，只需在一个地方改变这个变量的内

容。

要设定一个变量，只要在一行的开始写下这个变量的名字，后面跟一个=号，后面跟要

设定的这个变量的值。以后要引用这个变量，写一个$符号，后面是围在括号里的变量名。

比如在下面，我们把前面的makefile利用变量重写一遍：

还有一些设定好的内部变量，它们根据每一个规则内容定义。三个比较有用的变量是 $@, $< 和 $^ （这些变量不需要括号括住）。 $@ 扩展成当前规则的目的文件名， $< 扩展成

依靠列表中的第一个依靠文件，而$^扩展成整个依靠的列表（除掉了里面所有重复的文件名）。利用这些变量，我们可以把上面的 makefile 写成：

我们可以用变量做许多其它的事情，特别是当把它们和函数混合使用的时候。

4.隐含规则 (Implicit Rules)

请注意，在上面的例子里，几个产生.o文件的命令都是一样的。都是从.c文件和相

关文件里产生.o文件，这是一个标准的步骤。其实make已经知道怎么做——它有一些叫做

隐含规则的内置的规则，这些规则告诉它当你没有给出某些命令的时候，应该怎么办。

如果把生成foo.o和bar.o的命令从它们的规则中删除，make将会查找它的隐含规则，然后会找到一个适当的命令。它的命令会使用一些变量，因此可以按照我们自己的想法来设定：它使用变量CC做为编译器（象我们在前面的例子），并且传递变量CFLAGS（给C 编译器，C++ 编译器用CXXFLAGS），CPPFLAGS（C预处理器旗标），TARGET_ARCH（现在不用考虑这个），然后它加入旗标'-c'，后面跟变量$<（第一个依靠名），然后是旗标'-o' 跟变量$@（目的文件名）。一个Ｃ编译的具体命令将会是：

$(CC) $(CFLAGS) $(CPPFLAGS) $(TARGET_ARCH) -c $< -o $@

5.假象目的 (Phony Targets)

假设一个项目最后需要产生两个可执行文件。主要目标是产生两个可执行文件，但这两个文件是相互独立的——如果一个文件需要重建，并不影响另一个。我们可以使用假象目的来达到这种效果。一个假象目的跟一个正常的目的几乎是一样的，只是这个目的文件是不存在的。因此，make总是会假设它需要被生成，当把它的依赖文件更新后，就会执行它的规则里的命令行。

如果在我们的 makefile 开始处输入：

all : exec1 exec2

其中exec1和exec2是我们做为目的的两个可执行文件。make把这个'all'做为它的主要目的，每次执行时都会尝试把'all'更新。但既然这行规则里没有哪个命令来作用在一个叫 'all' 的实际文件（事实上all并不会在硬盘上实际产生），所以这个规则并不真的改变'all'的状态。可既然这个文件并不存在，所以make会尝试更新all规则，因此就检查它的依靠exec1,exec2是否需要更新，如果需要，就把它们更新，从而达到我们的目的。

假象目的也可以用来描述一组非预设的动作。例如，你想把所有由make产生的文件删除，你可以在makefile里设立这样一个规则：

veryclean :

rm *.o

rm myprog

前提是没有其它的规则依靠这个'veryclean'目的，它将永远不会被执行。但是，如果你明确的使用命令'make veryclean' ，make会把这个目的做为它的主要目标，执行那些rm 命令。

如果硬盘上存在一个叫veryclean文件，会发生什么事？这时因为在这个规则里没有任何依靠文件，所以这个目的文件一定是最新的了（所有的依靠文件都已经是最新的了），所以既使用户明确命令make重新产生它，也不会有任何事情发生。解决方法是标明所有的假象目的（用 .PHONY），这就告诉make不用检查它们是否存在于硬盘上，也不用查找任何隐含规则，直接假设指定的目的需要被更新。在makefile里加入下面这行包含上面规则的规则：

.PHONY : veryclean

注意，这是一个特殊的make规则，make知道.PHONY是一个特殊目的，当然可以在

它的依靠里加入想用的任何假象目的，而make知道它们都是假象目的。

6.函数 (Functions)

makefile里的函数跟它的变量很相似。使用的时候，用一个$符号跟开括号，函数名，空格后跟一列由逗号分隔的参数，最后用关括号结束。例如，在GNU Make里有一个叫'wildcard'的函数，它有一个参数，功能是展开成一列所有符合由其参数描述的文件名，文件间以空格间隔。可以像下面所示使用这个命令：

SOURCES = $(wildcard *.c)

这行会产生一个所有以'.c'结尾的文件的列表，然后存入变量SOURCES里。当然不一定要把结果存入一个变量。

另一个有用的函数是patsubst（patten substitude, 匹配替换的缩写）函数。它需要３个参数——第一个是一个需要匹配的式样，第二个表示用什么来替换它，第三个是一个需要被处理的由空格分隔的字列。例如，处理那个经过上面定义后的变量，OBJS = $(patsubst %.c,%.o,$(SOURCES))

这行将处理所有在SOURCES字列中的字（一列文件名），如果它的结尾是'.c'，就用'.o'把'.c'取代。注意这里的%符号将匹配一个或多个字符，而它每次所匹配的字串叫做一个'柄' (stem)。在第二个参数里，%被解读成用第一参数所匹配的那个柄。

7.一个比较有效的 makefile

利用以上的介绍，我们可以建立一个相当有效的makefile。这个makefile可以完成大部分我们需要的依靠检查，不用做太大的改变就可直接用在大多数的项目里。

首先我们需要一个基本的 makefile 来建我们的程序。我们可以让它搜索当前目录，找到源码文件，并且假设它们都是属于我们的项目的，放进一个叫SOURCES的变量。这里如果也包含所有的*.cc文件，也许会更保险，因为源码文件可能是 C++ 码的。

SOURCES = $(wildcard *.c *.cc)

利用patsubst，我们可以由源码文件名产生目标文件名，我们需要编译出这些目标文件。如果我们的源码文件既有.c 文件，也有.cc 文件，我们需要使用相嵌的patsubst 函数呼叫：

OBJS = $(patsubst %.c,%.o,$(patsubst %.cc,%.o,$(SOURCES)))

最里面一层patsubst的呼叫会对.cc文件进行后缀替代，产生的结果被外层的patsubst呼叫处理，进行对.c文件后缀的替代。

现在我们可以设立一个规则来建可执行文件：

myprog : $(OBJS)

gcc -o myprog $(OBJS)

进一步的规则不一定需要，gcc已经知道怎么去生成目标文件(object files)。下面我们可以设定产生依靠信息的规则：

depends : $(SOURCES)

gcc -M $(SOURCES) > depends

在这里如果一个叫'depends'的文件不存在，或任何一个源码文件比一个已存在的depends文件新，那么一个depends文件会被生成。depends文件将会含有由gcc产生的关于源码文件的规则（注意-M开关）。现在我们要让make把这些规则当做makefile 档的一部分。这里使用的技巧很像C语言中的#include系统——我们要求make把这个文件include到makefile里，如下：

include depends

GNU Make看到这个，检查'depends'目的是否更新了，如果没有，它用我们给它的命令重新产生depends 档。然后它会把这组（新）规则包含进来，继续处理最终目标'myprog' 。当看到有关 myprog 的规则，它会检查所有的目标文件是否更新——利用depends 文件里的规则，当然这些规则现在已经是更新过的了。

Makefile规则

目录 1.简介 3 1.1.准备工作 3 1.2.Makefile介绍 3 1.3.规则简介 4 1.4.make工作原理 4 1.5.使用变量 5 1.6.简化命令 6 1.7.另一种风格 6 1.8.清理 7 2.Makefile 7 2.1.makefile名字 7 2.2.包含 8 2.3.‘MAKEFILE’变量 8 2.4.怎么重新生成makefile 8 2.5.重载makefile 9 3.规则 9 3.1.例子 9 3.2.规则的语法 9 3.3.通配符 10 3.3.1.通配符的缺陷 10 3.3.2.wildcard函数 11 3.4.目录搜索 11 3.4.1.‘VPATH’ 11 3.4.2.选择性搜索 12 3.4.3.使用自动变量 12 3.4.4.目录搜索和隐含规则 12 3.5.PHONY目标 13 3.6.FORCE目标 14 3.7.空目标 14 3.8.内建的特别目标 14 3.9.一个规则多个目标 15 3.10.一个目标多条规则 15 3.11.静态模式规则 16 3.11.1.语法 16 3.11.2.静态模式规则和隐式规则 17 3.12.双冒号规则 17 3.13.自动生成依赖关系 17 4.编写命令 18 4.1.回显 18 4.2.执行 19 4.3.并行执行 19 4.4.错误 19 4.5.中断make 20 4.6.递归使用 20 4.6.1.‘MAKE’变量 20 4.6.2.传递变量到子make 21 5.命令行参数 21 6.参考 25

6.1.指令 25 6.2.函数 26 6.3.自动变量 27 6.4.特别变量 29 GNU Make使用 Make 程式最初设计是为了维护C程式文件防止不必要的重新编译。在使用命令行编译器的时候，修改了一个工程中的头文件，怎么确保包含这个头文件的所有文件都得到编译？目前10机的版本生成是使用批处理程式，编译那些文件依赖于程式的维护者，在模块之间相互引用头文件的情况下，要将所有需要重新编译的文件找出来是一件痛苦的事情；在找到这些文件之后，修改批处理进行编译。实际上这些工作能让make程式来自动完成，make工具对于维护一些具有相互依赖关系的文件特别有用，他对文件和命令的联系（在文件改动时调用来更新其他文件的程式）提供一套编码方法。Make工具的基本概念类似于Proglog语言，你告诉make需要做什么，提供一些规则，make来完成剩下的工作。 1.简介 make工作自动确定工程的哪部分需要重新编译，执行命令去编译他们。虽然make多用于C程式，然而只要提供命令行的编译器，你能将其用于所有语言。实际上，make工具的应用范围不仅于编程，你能描述任和一些文件改动需要自动更新另一些文件的任务来使用他。 1.1.准备工作 如果要使用make，你必须写一个叫做“makefile”的文件，这个文件描述工程中文件之间的关系，提供更新每个文件的命令。典型的工程是这样的：可执行文件靠目标文件来更新，目标文件靠编译源文件来更新。 Makefile写好之后，每次更改了源文件后，只要执行make就足够了，所有必要的重新编译将执行。Make程式利用makefile中的数据库和文件的最后修改时间来确定那个文件需要更新；对于需要更新的文件，make执行数据库中记录的命令。 能提供命令行参数给make来控制那个文件需要重新编译。 1.2.Makefile介绍 Makefile文件告诉make做什么，多数情况是怎样编译和链接一个程式。 这里有一个简单的makefile，描述怎么编译链接由8个C文件和3个头文件组成的一个编辑器： edit : main.o kbd.o command.o display.o insert.o serach.o files.o utils.o cc ?o edit main.o kbd.o command.o display.o insert.o search.o files.o utils.o main.o : main.c defs.h cc ?c main.c kdb.o : kbd.c defs.h command.h cc ?c kbd.c command.o : command.c defs.h command.h cc -c command.c display.o : display.c defs.h buffer.h cc -c display.c insert.o : insert.c defs.hbuffer.h cc -c insert.c search.o : search.c defs.hbuffer.h cc -c search.c files.o : files.c defs.h buffer.h command.h cc -c files.c utils.o : utils.c defs.h cc -c utils.c

手动建立makefile简单实例解析

手动建立makefile简单实例解析 假设我们有一个程序由5个文件组成，源代码如下：/*main.c*/ #include "mytool1.h" #include "mytool2.h" int main() { mytool1_print("hello mytool1!"); mytool2_print("hello mytool2!"); return 0; } /*mytool1.c*/ #include "mytool1.h" #include void mytool1_print(char *print_str) { printf("This is mytool1 print : %s ",print_str); } /*mytool1.h*/ #ifndef _MYTOOL_1_H #define _MYTOOL_1_H void mytool1_print(char *print_str); #endif /*mytool2.c*/ #include "mytool2.h" #include void mytool2_print(char *print_str) { printf("This is mytool2 print : %s ",print_str); }

/*mytool2.h*/ #ifndef _MYTOOL_2_H #define _MYTOOL_2_H void mytool2_print(char *print_str); #endif 首先了解一下make和Makefile。GNU make是一个工程管理器，它可以管理较多的文件。我所使用的RedHat 9.0的make版本为GNU Make version 3.79.1。使用make的最大好处就是实现了“自动化编译”。如果有一个上百个文件的代码构成的项目，其中一个或者几个文件进行了修改，make就能够自动识别更新了的文件代码，不需要输入冗长的命令行就可以完成最后的编译工作。make执行时，自动寻找Makefile（makefile）文件，然后执行编译工作。所以我们需要编写Makefile文件，这样可以提高实际项目的工作效率。 在一个Makefile中通常包含下面内容： 1、需要由make工具创建的目标体（target），通常是目标文件或可执行文件。 2、要创建的目标体所依赖的文件（dependency_file）。 3、创建每个目标体时需要运行的命令（command）。 格式如下： target：dependency_files command target：规则的目标。通常是程序中间或者最后需要生成的文件名，可以是.o文件、也可以是最后的可执行程序的文件名。另外，目标也可以是一个make执行的动作的名称，如目标“clean”，这样的目标称为“伪目标”。 dependency_files：规则的依赖。生成规则目标所需要的文件名列表。通常一个目标依赖于一个或者多个文件。 command：规则的命令行。是make程序所有执行的动作（任意的shell命令或者可在shell下执行的程序）。一个规则可以有多个命令行，每一条命令占一行。注意：每一个命令行必须以[Tab]字符开始，[Tab]字符告诉make此行是一个命令行。make按照命令完成相应的动作。这也是书写Makefile中容易产生，而且比较隐蔽的错误。命令就是在任何一个目标的依赖文件发生变化后重建目标的动作描述。一个目标可以没有依赖而只有动作（指定的命令）。比如Makefile中的目标“clean”，此目标没有依赖，只有命令。它所指定的命令用来删除make过程产生的中间文件（清理工作）。 在Makefile中“规则”就是描述在什么情况下、如何重建规则的目标文件，通常规则

LINUX编程 Makefile中的变量详解应用

第六章：Makefile中的变量 -------------------------------------------------------------------------------- 在Makefile中，变量就是一个名字（像是C语言中的宏），代表一个文本字符串（变量的值）。在Makefile的目标、依赖、命令中引用一个变量的地方，变量会被它的值所取代（与C语言中宏引用的方式相同，因此其他版本的make也把变量称之为“宏”）。在Makefile中变量的特征有以下几点： 1. Makefile中变量和函数的展开（除规则的命令行以外），是在make读取makefile文件时进行的，这里的变量包括了使用“=”定义和使用指示符“define”定义的。 2. 变量可以用来代表一个文件名列表、编译选项列表、程序运行的选项参数列表、搜索源文件的目录列表、编译输出的目录列表和所有我们能够想到的事物。 3. 变量名是不包括“:”、“#”、“=”、前置空白和尾空白的任何字符串。需要注意的是，尽管在GNU make中没有对变量的命名有其它的限制，但定义一个包含除字母、数字和下划线以外的变量的做法也是不可取的，因为除字母、数字和下划线以外的其它字符可能会在以后的make版本中被赋予特殊含义，并且这样命名的变量对于一些shell来说不能作为环境变量使用。 4. 变量名是大小写敏感的。变量“foo”、“Foo”和“FOO”指的是三个不同的变量。Makefile 传统做法是变量名是全采用大写的方式。推荐的做法是在对于内部定义定义的一般变量（例如：目标文件列表objects）使用小写方式，而对于一些参数列表（例如：编译选项CFLAGS）采用大写方式，这并不是要求的。但需要强调一点：对于一个工程，所有Makefile中的变量命名应保持一种风格，否则会显得你是一个蹩脚的程序员（就像代码的变量命名风格一样）。 5. 另外有一些变量名只包含了一个或者很少的几个特殊的字符（符号）。称它们为自动化变量。像“$<”、“$@”、“$?”、“$*”等。 6.1 变量的引用 当我们定义了一个变量之后，就可以在Makefile的很多地方使用这个变量。变量的引用方式是：使用“$（VARIABLE_NAME）”或者“${ VARIABLE_NAME }”来引用一个变量的定义。例如：“$(foo) ”或者“${foo}”就是取变量“foo”的值。美元符号“$”在Makefile中有特殊的含义，所有在命令或者文件名中使用“$”时需要用两个美元符号“$$”来表示。对一个变量的引用可以在Makefile的任何上下文中，目标、依赖、命令、绝大多数指示符和新变量的赋值中。这里有一个例子，其中变量保存了所有.o文件的列表： objects = program.o foo.o utils.o program : $(objects) cc -o program $(objects)

makefile新手教程

makefile新手教程 2013-11-08 本文翻译自https://www.wendangku.net/doc/b16541710.html,/tutorials/ Makefiles --通过示例说明 编译源代码是沉闷的，尤其是当你想要include一些源代码，却又每次都需要手动敲编译命令的时候。 恩，我有个好消息告诉你...你用手敲命令行去编译的日子（基本上）一去不复返了，因为你将会学习如何编写Makefile。Makefile是配合make命令使用的特殊文件，make命令则会帮助你自动地、神奇般地管理你的工程。 这里你需要先准备以下文件： main.cpp

hello.cpp factorial.cpp functions.cpp 我建议你新建一个空的目录，然后将上述4个文件放入其中。

注意：我使用g++命令编译。你完全可以换成别的编译器 make工具 如果你运行make 它会去寻找当前目录下名字为makefile的文件，并按里面的内容执行。 如果你有很多makefile文件，那么可以用这个命令来执行： 当然还有其他的参数来使用make工具，详情请man make。 构建过程 1.编译器编译源代码文件，输出到目标文件 2.链接器将目标文件链接，并创建可执行文件 手动编译 手动编译并获得可执行文件，是一种琐碎的方式： 基本的Makefile

基本的makefile文件组成如下： 将此语法应用到我们的例子中，就是: all: g++ main.cpp hello.cpp factorial.cpp -o hello 我们将此文件保存为Makefile-1。要运行此makefile，则输入：make -f Makefile-1 在这个例子中可以看到，我们的target叫做all。这是makefile中的默认target。若无指定参数，make工具将按这个target 执行。 我们同时发现，这个例子中的target，也就是all，没有dependencies（依赖文件），因此make会安全地执行后续的system commands（系统命令）。 最后，make根据我们设定的命令完成了编译。 使用依赖文件 有时候使用多个不同的target会很有用，因为当你只修改了工程中的一个文件时，不必重新编译所有代码，只需要编译修改过的部分。比如：

windows下的makefile教程

windows下的makefile教程 https://www.wendangku.net/doc/b16541710.html,/mirror_hc/archive/2008/03/26/2221117.aspx joeliu 制作4/19/2011 22:10:29 1. 先说几句废话 以前看书时经常遇到makefile，nmake这几个名词，然后随之而来的就是一大段莫名其妙的代码，把我看得云里雾里的。在图书馆和google上搜了半天，也只能找到一些零零星星的资料，把我一直郁闷得不行。最近因缘巧合，被我搞到了一份传说中的MASM6手册，终于揭开了NMAKE的庐山真面目。想到那些可能正遭受着同样苦难的同志以及那些看到E文就头晕的兄弟，所以就写了这篇文章。假如大家觉得有帮助的话，记得回复一下，当作鼓励！如果觉得很白痴,也请扔几个鸡蛋.本文是总结加翻译，对于一些关键词以及一些不是很确定的句子，保留了英文原版，然后再在括号里给出自己的理解以作参考。由于水平有限，加上使用NMAKE的经验尚浅，有不对的地方大家记得要指正唷。MASM6手册在AOGO（好像是）可以download，在我的BLOG上有到那的链接。 2. 关于NMAKE Microsoft 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.obj link first.obj,second.obj 第一行定义了依赖关系，称为dependency line；第二行给出了与该依赖关系相关联的操作，称为command line。因为foo.exe由first.obj和second.obj连接而成，所以说foo.exe依赖于first.ogj和second.obj，即foo.exe为target，first.obj和second.obj为dependent。如果first.obj和second.obj中的任何一个被修改了（其time stamp更大），则调用link.exe，重新连接生成foo.exe。这就是NMAKE的执行逻辑。 综上，NMAKE的核心就是这3个家伙——依赖关系，操作和判定逻辑（target.timestamp < dependent.timestamp，如果为true，就执行相应操作）。 3. MAKEFILE的语法 现在详细讨论一下makefile的语法。makefile就像一个玩具型的程序语言，麻雀虽小，但五脏具全。makefile的组成部分包括：描述语句（description block），推导规则（inference rules），宏和指令（directive）。 描述语句就是dependent lines和command lines的组合；推导规则就是预先定义好的或用户自己定义的依赖关系和关联命令；宏就不用说了吧；指令就是内定的一些可以被NMAKE识别的控制命令，提供了很多有用的功能。 3.1 特殊符号

make_Makefile 结构分析

Makefile结构分析 -----uClinux （2.6.x内核）系统映像过程 刘江欧阳昭暐吕熙隆 1、源代码文件及目录构成 解压缩uClinux-dist-20070130.tar.gz压缩文件，在uClinux-dist原始子目录下主要有：config、Bin、linux-2.4.x、linux-2.6.x 、lib、tools、Include、user和vendors，以及文件Makefile。另外，在编译后生成子目录images和romfs，以及文件autoconfig.h、config.in和两个隐含文件：.config和.depend。 config子目录包含文件及下一级子目录，如 config.in、configure.help、Fixconfig、Makefile、 Mkconfig、Setconfig所有这些文件及子目录 Scripts均与系统配置有关； linux-2.6.x子目录是嵌入式操作系统 uClinux-2.6.x的核心目录，包括下一级子目录 arch、include、init、drivers、fs、ipc、kernel、 lib、Mm、scripts和关键文件Makefile、 rules.make，编译后还要生成新文件romfs.o、linux 和system.map；lib子目录为嵌入式操作系统提供 压缩和改进了的函数库支持；tools子目录包含 romfs-inst.sh文件，通过调用此文件，可以把目录 或文件加入到romfs子目录中；user子目录包含各 种驱动程序文件目录，根据用户的配置情况，不同的 驱动程序会被编译进最后形成的操作系统中； vendors子目录包括与特定硬件平台相关的分类目录 组。目录结构如图1所示。 Makefile的详细介绍情况在 uClinux-dist\linux-2.6.x\Documentation\kbuil d中，如图2所示。图1、目录结构即Linux 内核中的 Makefile 以及与 Makefile 直接相关的文件有：

3-Makefile书写规则

3 Makefile书写规则 规则包含两个部分，一个是依赖关系，一个是生成目标的方法。 在Makefile中，规则的顺序是很重要的，因为，Makefile中只应该有一个最终目标，其它的目标都是被这个目标所连带出来的，所以一定要让make知道你的最终目标是什么。一般来说，定义在Makefile中的目标可能会有很多，但是第一条规则中的目标将被确立为最终的目标。如果第一条规则中的目标有很多个，那么，第一个目标会成为最终的目标。make所完成的也就是这个目标。 好了，还是让我们来看一看如何书写规则。 3.1 规则举例 foo.o : foo.c defs.h # foo模块 cc -c -g foo.c 看到这个例子，各位应该不是很陌生了，前面也已说过，foo.o是我们的目标，foo.c和defs.h是目标所依赖的源文件，而只有一个命令“cc -c - g foo.c”（以Tab键开头）。这个规则告诉我们两件事： 1. 文件的依赖关系，foo.o依赖于foo.c和defs.h的文件，如果foo.c 和defs.h的文件日期要比foo.o文件日期要新，或是foo.o不存 在，那么依赖关系发生。 2. 如果生成（或更新）foo.o文件。也就是那个cc命令，其说明 了，如何生成foo.o这个文件。（当然foo.c文件include了defs.h 文件） 3.2 规则的语法 targets : prerequisites command

... 或是这样： targets : prerequisites ; command command ... targets是文件名，以空格分开，可以使用通配符。一般来说，我们的目标基本上是一个文件，但也有可能是多个文件。 command是命令行，如果其不与“target:prerequisites”在一行，那么，必须以[Tab键]开头，如果和prerequisites在一行，那么可以用分号做为分隔。（见上） prerequisites也就是目标所依赖的文件（或依赖目标）。如果其中的某个文件要比目标文件要新，那么，目标就被认为是“过时的”，被认为是需要重生成的。这个在前面已经讲过了。 如果命令太长，你可以使用反斜框（‘\’）作为换行符。make对一行上有多少个字符没有限制。规则告诉make两件事，文件的依赖关系和如何成成目标文件。 一般来说，make会以UNIX的标准Shell，也就是/bin/sh来执行命令。3.3 在规则中使用通配符 如果我们想定义一系列比较类似的文件，我们很自然地就想起使用通配符。make支持三各通配符：“*”，“?”和“[...]”。这是和Unix的B-Shell是相同的。 波浪号（“~”）字符在文件名中也有比较特殊的用途。如果是“~/test”，这就表示当前用户的$HOME目录下的test目录。而“~hchen/test”则表示用户hchen的宿主目录下的test目录。（这些都是Unix下的小知识了，make也支持）而在Windows或是MS-DOS下，用户没有宿主目录，那么波浪号所指的目录则根据环境变量“HOME”而定。

编译内核Makefile时 混和的隐含和普通规则。停止

编译时makefile:Makefile:1503: *** 混和的隐含和普通规则。停止。处理 (2012-05-05 16:45:32) 转载▼ 1.makefile #AR=ar #ARCH=arm #CC=arm-linux-gcc obj-m := hello.o #if we need more than one source code to build the module #we should use the variable below: example: modules-objs := file1.o file2.o #KDIR := /lib/modules/$(shell uname -r)/build KDIR := /UP-Magic/kernel/linux-2.6.24.4 PWD := $(shell pwd) default: # $(MAKE) -C $(KDIR) M=$(PWD) modules $(MAKE) -C $(KDIR) M=$(PWD) modules clean: rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versions *.order *.symvers make时出现； [root@hpx driverPractise]# make make -C /UP-Magic/kernel/linux-2.6.24.4 M=/bochuang/driverPractise modules make[1]: 进入目录“/UP-Magic/kernel/linux-2.6.24.4” Makefile:1503: *** 混和的隐含和普通规则。停止。 make[1]: 离开目录“/UP-Magic/kernel/linux-2.6.24.4” make: *** [default] 错误 2 搜索一下，有人解决了，转载过来： 在编译 kernel 时，有机会碰见下面的错误： Makefile: *** 混合的隐含和普通规则。停止。 Makefile: *** mixed implicit and normal rules. Stop. 这个原因可能是Make工具对低版本内核的Makefile一些旧的规则兼容不好，我们只需要修改对应的Makefile。 如一：

Makefile 语法分析

Makefile 语法分析第一部分 VERSION = 2 # 给变量VERSION赋值 PATCHLEVEL = 6 # 给变量PATCHLEVEL赋值 SUBLEVEL = 22 # 给变量SUBLEVEL赋值 EXTRAVERSION = .6 # 给变量EXTRAVERSION赋值 NAME = Holy Dancing Manatees, Batman! # 给变量NAME赋值 # *DOCUMENTATION* # To see a list of typical targets execute "make help" # More info can be located in ./README # Comments in this file are targeted only to the developer, do not # expect to learn how to build the kernel reading this file. # Do not: # o use make's built-in rules and variables # (this increases performance and avoid hard-to-debug behavour); # o print "Entering directory ..."; MAKEFLAGS += -rR --no-print-directory # 操作符“+=”的作用是给变量（“+=”前面的MAKEFLAGS）追加值。 # 如果变量（“+=”前面的MAKEFLAGS）之前没有定义过，那么，“+=”会自动变成“=”； # 如果前面有变量（“+=”前面的MAKEFLAGS）定义，那么“+=”会继承于前次操作的赋值符；# 如果前一次的是“:=”，那么“+=”会以“:=”作为其赋值符 # 在执行make时的命令行选项参数被通过变量“MAKEFLAGS”传递给子目录下的make程序。# 对于这个变量除非使用指示符“unexport”对它们进行声明，它们在整个make的执行过程中始终被自动的传递给所有的子make。 # 还有个特殊变量SHELL与MAKEFLAGS一样，默认情况（没有用“unexport”声明）下在整个make的执行过程中被自动的传递给所有的子make。 # # -rR --no-print-directory # -r disable the built-in impilict rules. # -R disable the built-in variable setttings. # --no-print-directory。 # We are using a recursive build, so we need to do a little thinking # to get the ordering right. # # Most importantly: sub-Makefiles should only ever modify files in # their own directory. If in some directory we have a dependency on # a file in another dir (which doesn't happen often, but it's often # unavoidable when linking the built-in.o targets which finally # turn into vmlinux), we will call a sub make in that other dir, and

Linux如何写makefile文件

Linux如何写makefile文件 关于程序的编译和链接 —————————— 在此，我想多说关于程序编译的一些规范和方法，一般来说，无论是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语言

程序员之路——如何学习C语言并精通C语言 程序员之路——如何学习C语言 学习C语言不是一朝一夕的事情，但也不需要花费十年时间才能精通。如何以最小的代价学习并精通C 语言是本文的主题。请注意，即使是“最小的代价”，也绝不是什么捷径，而是以最短的时间取得最多的收获，同时也意味着你需要经历艰苦的过程。 一、要读就读好书，否则不如不读 所有初学者面临的第一个问题便是：如何选择教材。好的开始是成功的一半，选择一本优秀的教材是事半功倍的关键因素。不幸的是，学校通常会帮你指定一本很差劲的C语言课本；而幸运的是，你还可以再次选择。 大名鼎鼎的谭浩强教授出了一本《C语言程序设计》，据说发行量有超过400万，据我所知，很多学校都会推荐这本书作为C语言课本。虽然本人的名字（谭浩宇）跟教授仅仅一字之差，但我是无比坚定地黑他这本书的。这本书不是写给计算机专业的学生的，而是给那些需要考计算机等级考试的其它专业学生看的。这本书的主要缺点是：例子程序非常不专业，不能教给你程序设计应该掌握的思考方式；程序风格相当地不好，会让你养成乱写代码的恶习；错误太多，曾经有人指出过这本书的上百个错误，其中不乏关键的概念性错误。好了，这本书我也不想说太多了，有兴趣大家可以百度一下：） Kernighan和Ritchie的《The C Programming Language》（中译名《C程序设计语言》）堪称经典中的经典，不过旧版的很多内容都已过时，和现在的标准C语言相去甚远，大家一定要看最新的版本，否则不如不看。另外，即使是最经典最权威的书，也没有办法面面俱到，所以手边常备一本《C语言参考手册》是十分必要的。《C语言参考手册》就是《C Reference Manual》，是C语言标准的详细描述，包括绝大多数C标准库函数的细节，算得上是最好的标准C语言的工具书。顺便提一句，最新的《C程序设计语言》是根据C89标准修订的，而《C语言参考手册》描述的是C99标准，二者可能会有些出入，建议按照C99标准学习。还有一本《C和指针》，写得也是相当地不错，英文名是《Pointers on C》，特别地强调指针的重要性，算是本书的一个特点吧。不过这本书并不十分适合初学者，如果你曾经学过C语言，有那么一些C语言的基础但又不是很扎实，那么你可以尝试一下这本书。我相信，只要你理解了指针，C语言便不再神秘。 如果你已经啃完了一本C语言教材，想要更进一步，那么有两本书你一定要看。首先是《C Traps and Pitfalls》（中译名《C陷井与缺陷》），很薄的一本小册子，内容非常非常地有趣。要注意一点，这本书是二十多年前写成的，里面提到的很多C语言的缺陷都已被改进，不过能够了解一些历史也不是什么坏事。然后你可以挑战一下《Expert C Programming》（中译名《C专家编程》），书如其名，这本书颇具难度，一旦你仔细读完并能透彻理解，你便可以放心大胆地在简历上写“精通C语言”了。 切记一个原则，不要读自己目前还看不懂的书，那是浪费生命。如果你看不懂，那你一定是缺失了某些必需基础知识。此时，你要仔细分析自己需要补充哪些内容，然后再去书店寻找讲述的这些内容的书籍。把基础知识补充完毕再回头来学习，才会真正的事半功倍。 二、Unix/Linux还是Windows，这是个很大的问题 不同的编程环境会造就出不同思维的程序员。Windows的程序员大多依赖集成开发环境，比如Visual Studio，而Unix程序员更加钟爱Makefile与控制台。显而易见，集成开发环境更容易上手，在Windows上学习C语言，只需要会按几个基本的Visutal C++工具栏按钮就可以开始写Hello, World!了，而在Unix下，你需要一些控制台操作的基本知识。有人也许认为Unix的环境更简洁，但习惯的力量是很大的，大家都很熟悉Windows的基本操作，而为了学习C语言去专门装一个Unix系统，似乎有点不划算。 对于一个只懂得Windows基本操作、连DOS是什么都不知道的新手而言，尽快做一些有趣而有意义的事情才是最重要的。用C语言写一个小程序远比学习ls、cat等命令有趣，况且我们要专注于C语言本身，就不得不暂时忽略一些东西，比如编译链接的过程、Makefile的写法等等等等。 所以我建议初学者应该以Visual C++ 6.0（不是VisualC++ .NET）或者Dev C++作为主要的学习环境，而且千万不要在IDE的使用技巧上过多纠缠，因为今后你一定要转向Unix环境的。Visual C++ 6.0使用很方便，调试也很直观，但其默认的编译器对C标准的支持并不好，而Dev C++使用gcc编译器，对C99的标准都支持良好。使用顺带提一下，很多大学的C语言课程还在使用Turbo C 2.0作为实验环境，这是相当不可取的，原因其一是TC 2.0对C标准几乎没有支持，其二是TC 2.0编译得到的程序是16位的，这对今后理解32位的程序会造成极大的困扰（当然,用djgpp之类的东西可以使TC

c 程序的书写格式

c 程序的书写格式 c++程序的书写格式2010-05-18 17：03文件结构文件头注释所有C++的源文件均必须包含一个规范的文件头，文件头包含了该文件的名称、功能概述、作者、版权和版本历史信息等内容。标准文件头的格式为：/*！@file*PRE模块名：文件所属的模块名称文件名：文件名相关文件：与此文件相关的其它文件文件实现功能：描述该文件实现的主要功能作者：作者部门和姓名版本：当前版本号--备注：其它说明--修改记录：日期版本修改人修改内容YYYY/MM/DD X.Y作者或修改者名修改内容/PRE*/如果该文件有其它需要说明的地方，还可以专门为此扩展一节：/*！@file*PRE模块名：文件所属的模块名称文件名：文件名相关文件：与此文件相关的其它文件文件实现功能：描述该文件实现的主要功能作者：作者部门和姓名版本：当前版本号--备注：其它说明--修改记录：日期版本修改人修改内容YYYY/MM/DD X.Y作者或修改者名修改内容/PRE**项目1-项目1.1-项目1.2==*项目2-项目2.1-项目2.2.*/每行注释的长度都不应该超过80个半角字符。还要注意缩进和对其，以利阅读。关于文件头的完整例子，请参见：文件头例子关于文件头的模板，请参见：文件头注释模板头文件头文件通常由以下几部分组成：文件头注释每个头文件，无论是内部的还是外部的，都应该由一个规范的文件头注释作为开始。预处理块为了防止头文件被重复引用，应当用ifndef/define/endif结构产生预处理块。函数和类/结构的声明等声明模块的接口需要包含的内联函数定义文件(如果有的话)如果类中的内联函数较多，或者一个头文件中包含多个类的定义(不推荐)，可以将所有内联函数定义放入一个单独的内联函数定义文件中，并在类声明之后用 "#include"指令把它包含进来。头文件的编码规则：引用文件的格式用 #include filename.h格式来引用标准库和系统库的头文件(编译器将从标准库目录开始搜索)。用#include"filename.h"格式来引用当前工程中的头文件(编译器将从该文件所在目录开始搜索)。分割多组接口(如果有的话)如果在一个头件中定义了多个类或者多组接口(不推荐)，为了便于浏览，应该在每个类/每组接口间使用分割带把它们相互分开。关于头文件的完整例子，请参见：头文件例子内联函数定义文件如上所述，在内联函数较多的情况下，为了避免头文件过长、版面混乱，可以将所有的内联函数定义移到一个单独的文件中去，然后再用#include指令将它包含到类声明的后面。这样的文件称为一个内联函数定

makefile 中文手册 第六章 _ Makefile中的变量

第六章：Makefile中的变量 在Makefile中，变量是一个名字（像是C语言中的宏），代表一个文本字符串（变量的值）。在Makefile的目标、依赖、命令中引用变量的地方，变量会被它的值所取代（与C语言中宏引用的方式相同，因此其他版本的make也把变量称之为“宏”）。在Makefile中变量有以下几个特征： 1.Makefile中变量和函数的展开（除规则命令行中的变量和函数以外），是在make读取makefile文件时 进行的，这里的变量包括了使用“=”定义和使用指示符“define”定义的。 2.变量可以用来代表一个文件名列表、编译选项列表、程序运行的选项参数列表、搜索源文件的目录列 表、编译输出的目录列表和所有我们能够想到的事物。 3.变量名是不包括“:”、“#”、“=”、前置空白和尾空白的任何字符串。需要注意的是，尽管在GNU make中没有对变量的命名有其它的限制，但定义一个包含除字母、数字和下划线以外的变量的做法也是不可取的，因为除字母、数字和下划线以外的其它字符可能会在make的后续版本中被赋予特殊含义，并且这样命名的变量对于一些shell来说是不能被作为环境变量来使用的。 4.变量名是大小写敏感的。变量“foo”、“Foo”和“FOO”指的是三个不同的变量。Makefile传统做 法是变量名是全采用大写的方式。推荐的做法是在对于内部定义定义的一般变量（例如：目标文件列表objects）使用小写方式，而对于一些参数列表（例如：编译选项CFLAGS）采用大写方式，但这并不是要求的。但需要强调一点：对于一个工程，所有Makefile中的变量命名应保持一种风格，否则会显得你是一个蹩脚的程序员（就像代码的变量命名风格一样）。 5.另外有一些变量名只包含了一个或者很少的几个特殊的字符（符号）。称它们为自动化变量。 像“$<”、“$@”、“$?”、“$*”等。 6.1变量的引用 当我们定义了一个变量之后，就可以在Makefile的很多地方使用这个变量。变量的引用方式 是：“$（VARIABLE_NAME）”或者“${ VARIABLE_NAME }”来引用一个变量的定义。例如：“$(foo)”或者“${foo}”就是取变量“foo”的值。美元符号“$”在Makefile中有特殊的含义，所有在命令或者文件名中使用“$”时需要用两个美元符号“$$”来表示。对一个变量的引用可以在Makefile的任何上下文中，目标、依赖、命令、绝大多数指示符和新变量的赋值中。这里有一个例子，其中变量保存了所有.o文件的列表： objects = program.o foo.o utils.o program : $(objects) cc -o program $(objects) $(objects) : defs.h 变量引用的展开过程是严格的文本替换过程，就是说变量值的字符串被精确的展开在变量被引用的地方。因此规则： foo = c prog.o : prog.$(foo) $(foo) $(foo) -$(foo) prog.$(foo) 被展开后就是：

Makefile超强经典教程

Makefile经典教程 0 Makefile概述 (2) 0.1关于程序的编译和链接 (2) 1 Makefile介绍 (3) 1.1 Makefile的规则 (4) 1.2一个示例 (4) 1.3 make是如何工作的 (6) 1.4 makefile中使用变量 (7) 1.5让make自动推导 (8) 1.6另类风格的makefile (9) 1.7清空目标文件的规则 (10) 2 Makefile总述 (11) 2.1 Makefile里有什么？ (11) 2.2Makefile的文件名 (12) 2.3引用其它的Makefile (12) 2.4环境变量MAKEFILES (13) 2.5 make的工作方式 (13) 3 Makefile书写规则 (14) 3.1规则举例 (14) 3.2规则的语法 (14) 3.3在规则中使用通配符 (15) 3.4文件搜寻 (16) 3.5伪目标 (17) 3.6多目标 (19) 3.7静态模式 (20) 3.8自动生成依赖性 (22) 4 Makefile书写命令 (24) 4.1显示命令 (24) 4.2命令执行 (25) 4.3命令出错 (25) 4.4嵌套执行make (26) 4.5定义命令包 (29) 1

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++的编译的知识，相关于这方面的内容，还请各位查看相关的编译器的文档。这里所默认的编译器是UNIX下的GCC和CC。 0.1关于程序的编译和链接 在此，我想多说关于程序编译的一些规范和方法，一般来说，无论是C、C++、还是pas，首先要把源文件编译成中间代码文件，在Windows下也就是.obj 文件，UNIX