《 makefile介绍及使用》

1、利用makefile 来构建和管理自己的工程。

 

2、整个工程只需要一个命令，就能完成编译、连接、和最后的执行。

 

3、make 是一个命令工具，它解析makefile中的指令（规则）

 

4、在makefile中可以使用shell提供的任何命令

 

5、make 在使用的时候需要一个命名为Makefile的文件

 

6、make 通过对比相应文件（规则的目标和依赖）的最后的修改时间来确定那些文件需要更新那些文件不需要更新

 

7、可以通过make的命令行选项来指定需要重新编译的文件

 

二、Makefile 规则

 

1、一个简单的Makefile描述规则组成：

TARGET... : PREREQUISITES...

COMMAND

...

...

target：规则的目标。通常是最后需要生成的文件名或者为了实现这个目的而必需的中间过程文件名。可以是.o文件、也可以是最后的可执行程序的文件名等。另外，目标也可以是一个make执行的动作的名称，如目标“clean”，我们称这样的目标是“伪目标”

 

command：规则的命令行。是规则所要执行的动作（任意的shell命令或者是可在shell下执行的程序）。它限定了make执行这条规则时所需要的动作。

一个规则可以有多个命令行，每一条命令占一行。

 

注意：每一个命令行必须以[Tab]字符开始，[Tab]字符告诉make此行是一个命令行。make按照命令完成相应的动作。这也是书写Makefile中容易产生，而且比较隐蔽的错误。

 

2、命令就是在任何一个目标的依赖文件发生变化后重建目标的动作描述。一个目标可以没有依赖而只有动作（指定的命令）。比如Makefile中的目标“clean”，此目标没有依赖，只有命令。它所定义的命令用来删除make过程产生的中间文件（进行清理工作）。

在Makefile中“规则”就是描述在什么情况下、如何重建规则的目标文件，通常规则中包括了目标的依赖关系（目标的依赖文件）和重建目标的命令

 

3、规则包含了文件之间的依赖关系和更新此规则目标所需要的命令。

 

4、make程序根据规则的依赖关系，决定是否执行规则所定义的命令的过程我们称之为执行规则。 

 

5、首先书写时，可以将一个较长行使用反斜线（\）来分解为多行，这样可以使我们的Makefile书写清晰、容易阅读理解。但需要注意：反斜线之后不能有空格（这也是大家最容易犯的错误，错误比较隐蔽

 

6、当规则的目标是一个文件，在它的任何一个依赖文件被修改以后，在执行“make”时这个目标文件将会被重新编译或者重新连

 

7、make程序会把出现在第一条规则之后的所有以[Tab]字符开始的行都作为命令行来处理

 

8、目标“clean”不是一个文件，它仅仅代表执行一个动作的标识。正常情况下，不需要执行这个规则所定义的动作，因此目标“clean”没有出现在其它任何规则的依赖列表中。因此在执行make时，它所指定的动作不会被执行。除非在执行make时明确地指定它。而且目标“clean”没有任何依赖文件，它只有一个目的，就是通过这个目标名来执行它所定义的命令。

 

Makefile中把那些没有任何依赖只有执行动作的目标称为“伪目标”（phony targets）

 

make 是如何工作的

 

edit : main.o kbd.o command.o display.o \

insert.o search.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

kbd.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.h buffer.h

cc -c insert.c

search.o : search.c defs.h buffer.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

clean :

rm edit main.o kbd.o command.o display.o \

insert.o search.o files.o utils.o

 

1、默认的情况下，make执行的是Makefile中的第一个规则，此规则的第一个目标称之为“最终目的”或者“终极目标”

 

 

2、对于一个Makefile文件，“make”首先解析终极目标所在的规则，根据其依赖文件依次寻找创建这些依赖文件的规则。

首先为第一个依赖文件（main.o）寻找创建规则，如果第一个依赖文件依赖于其它文件（main.c、defs.h），则同样为这个依赖文件寻找创建规则（创建main.c和defs.h的规则，通常源文件和头文件已经存在，也不存在重建它们的规则）……，直到为所有的依赖文件找到合适的创建规则。

之后make从最后一个规则（上例目标为main.o的规则）回退开始执行，最终完成终极目标的第一个依赖文件的创建和更

 

3、edit 中的.o文件有两处比较麻烦，使用一个变量“objects”、“OBJECTS”、“objs”、“OBJS”、“obj”或者“OBJ”来作为所有的.o文件的列表的替代

objects = main.o kbd.o command.o display.o \

insert.o search.o files.o utils.o

 

 

 

清除工作过程文件

 

1、clean :

rm edit $(objects)

在实际应用时，我们把这个规则写成如下稍微复杂一些的样子。以防止出现始料未及的情况。 

 

2、.PHONY : clean

clean :

-rm edit $(objects)

这两个实现有两点不同： 1. 通过“.PHONY”特殊目标将“clean”目标声明为伪目标。避免当磁盘上存在一个名为“clean”文件时，目标“clean”所在规则的命令无法执行。

2. 在命令行之前使用“-”，意思是忽略命令“rm”的执行错误

 

makefile 综述

 

1、在一个完整的Makefile中，包含了5个东西：显式规则、隐含规则、变量定义、指示符 、注释

 

 1》显式规则：它描述了在何种情况下如何更新一个或者多个被称为目标的文件（Makefile的目标文件）。书写Makefile时需要明确地给出目标文件、目标的依赖文件列表以及更新目标文件所需要的命令

 2》隐含规则：它是make根据一类目标文件（典型的是根据文件名的后缀）而自动推导出来的规则。make根据目标文件的名，自动产生目标的依赖文件并使用默认的命令来对目标进行更新

 3》变量定义：使用一个字符或字符串代表一段文本串，当定义了一个变量以后，Makefile后续在需要使用此文本串的地方，通过引用这个变量来实现对文本串的使用

 4》Makefile指示符：指示符指明在make程序读取makefile文件过程中所要执行的一个动作。其中包括：

    1>读取一个文件，读取给定文件名的文件，将其内容作为makefile文件的一部分

       makefile文件的命名不是这三个任何一个时，需要通过make的“-f”或者“--file”

       选项来指定make 读取的makefile文件

 

    2>决定（通常是根据一个变量的得值）处理或者忽略Makefile中的某一特定部分

       条件语句可以根据一个变量的值来控制make执行或者忽略Makefile的特定部分。

       条件语句可以是两个不同变量、或者变量和常量值的比较

       ifeq ($(CC),gcc)

$(CC) -o foo $(objects) $(libs_for_gcc)

else

$(CC) -o foo $(objects) $(normal_libs)

endif

     3> 定义一个多行变量

        定义变量的另外一种方式是使用“define”指示符

     4> 注释：Makefile中“#”字符后的内容被作为是注释内容

 

注意：Makefile中第一个规则之后的所有以[Tab]字符开始的的行，make程序都会将其交给系统shell程序去解释执行。因此，以[Tab]字符开始的注释行也会被交给shell来处理，此命令行是否需要被执行（shell执行或者忽略）是由系统shell程序来判决的。

另外，在使用指示符“define”定义一个多行的变量或者命令包时，其定义体（“define”和“endef”之间的内容）会被完整的展开到Makefile中引用此变量的地方

 

2、GUN make的执行过程分为两个阶段。

第一阶段：读取所有的makefile文件（包括“MAKIFILES”变量指定的、指示符“include”指定的、以及命令行选项“-f(--file)”指定的makefile文件），内建所有的变量、明确规则和隐含规则，并建立所有目标和依赖之间的依赖关系结构链表。

在第二阶段：根据第一阶段已经建立的依赖关系结构链表决定哪些目标需要更新，并使用对应的规则来重建这些目标。

理解make执行过程的两个阶段是很重要的。它能帮助我们更深入的了解执行过程中变量以及函数是如何被展开的

 

3、make的执行过程如下：

1. 依次读取变量“MAKEFILES”定义的makefile文件列表

2. 读取工作目录下的makefile文件（根据命名的查找顺序“GNUmakefile”，“makefile”，“Makefile”，首先找到那个就读取那个）

3. 依次读取工作目录makefile文件中使用指示符“include”包含的文件

4. 查找重建所有已读取的makefile文件的规则（如果存在一个目标是当前读取的某一个makefile文件，则执行此规则重建此makefile文件，完成以后从第一步开始重新执行）

5. 初始化变量值并展开那些需要立即展开的变量和函数并根据预设条件确定执行分支

6. 根据“终极目标”以及其他目标的依赖关系建立依赖关系链表

 

 

 

makefile 的命名

 

1、默认的情况下，make会在工作目录（执行make的目录）下按照文件名顺序寻找makefile文件读取并执行，查找的文件名顺序为：“GNUmakefile”、“makefile”、“Makefile”。（我们推荐使用“Makefile”）

 

2、如果make程序在工作目录下无法找到以上三个文件中的任何一个，它将不读取任何其他文件作为解析对象。但是根据make隐含规则的特性，我们可以通过命令行指定一个目标，如果当前目录下存在符合此目标的依赖文件，那么这个命令行所指定的目标

 

3、也可以通过多个“-f”或者“--file”选项来指定多个需要读取的makefile文件，多个makefile文件将会被按照指定的顺序进行链接并被make解析执行。当通过“-f”或者“--file”指定make读取makefile的文件时，make就不再自动查找这三个标准命名的makefile文件。

 

4、“include”指示符告诉make暂停读取当前的Makefile，而转去读取“include”指定的一个或者多个文件，完成以后再继续当前Makefile的读取。Makefile中指示符“include”书写在独立的一行，其形式如下：

include FILENAMES...

 

5、通常我们在Makefile中可使用“-include”来代替“include”，来忽略由于包含文件不存在或者无法创建时的错误提示（“-”的意思是告诉make，忽略此操作的错误。make继续执行）。像下边那样：

-include FILENAMES...

 

6、变量 MAKEFILES

如果在当前环境定义了一个“MAKEFILES”环境变量，make执行时首先将此变

量的值作为需要读入的Makefile文件，多个文件之间使用空格分开

 

变量定义

 

1、

IMMEDIATE = DEFERRED

IMMEDIATE ?= DEFERRED

IMMEDIATE := IMMEDIATE

IMMEDIATE += DEFERRED or IMMEDIATE

define IMMEDIATE

DEFERRED

Endef

当变量使用追加符（+=）时，如果此前这个变量是一个简单变量（使用 :=定义的）则认为它是立即展开的，其它情况时都被认为是“延后”展开的变量。 
 

规则的分类

 

1、明确规则、模式规则、后缀规则、静态模式规则。

 

 1》隐士规则

 

 1、在使用make编译.c源文件时，编译.c源文件规则的命令可以不用明确给出。这是因为make本身存在一个默认的规则，能够自动完成对.c文件的编译并生成对应的.o文件

 objects = main.o kbd.o command.o display.o \

insert.o search.o files.o utils.o

edit : $(objects)

cc -o edit $(objects)

main.o : defs.h

kbd.o : defs.h command.h

command.o : defs.h command.h

make的隐含规则在实际工程的make中会经常使用，它使得编译过程变得方便。几乎在所有的Makefile中都用到了make的隐含规

 

 2》模式规则

 

   在模式规则中，目标文件是一个带有模式字符“%”的文件，使用模式来匹配目标文件。

   ，一个模式规则的格式为：

%.o : %.c ; COMMAND...

这个模式规则指定了如何由文件“N.c”来创建文件“N.o”，文件“N.c”应该是已存在的或者可被创建的。

 

3》后缀规则

  .c.o:

$(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<</div>

 

文件收缩路径

 

1、GNU make可以识别一个特殊变量“VPATH”。通过变量“VPATH”可以指定依赖文件的搜索路径，当规则的依赖文件在当前目录不存在时

 

循环

 

1、SUBDIRS = foo bar baz

subdirs:

for dir in $(SUBDIRS); do \

$(MAKE) -C $$dir; \

done

 

FORCE

 

clean: FORCE

rm $(objects)

FORCE:

这个例子中，目标“FORCE”符合上边的条件。它作为目标“clean”的依赖，在执行make时，总被认为被更新过。因此“clean”所在规则在被执行时其所定义的命令总会被执行。这样的一个目标通常我们将其命名为“FORCE”。

 

自动化变量

 

1、命令行中“$<”和“$@”是自动化变量，“$<”表示规则中的第一个依赖文件，“$@”表示规则中的目标文件

 

2、模式规则中，规则的目标和依赖文件名代表了一类文件名；规则的命令是对所有这一类文件重建过程的描述，显然，在命令中不能出现具体的文件名，否则模式规则失去意义

 

3、$@表示规则的目标文件名

   $<</span>规则的第一个依赖文件名

   $^规则的所有依赖文件列表，使用空格分隔

 

@回显

 

1、make在执行命令行之前会把要执行的命令行输出到标准输出设备。我们称之为“回显”，就好像我们在shell环境下输入命令执行时一样。

但是，如果规则的命令行以字符“@”开始，则make在执行这个命令时就不会回显这个将要被执行的命令。典型的用法是在使用“echo”命令输出一些信息时

 

export

 

1、上层make过程要将所执行的Makefile中的变量传递给子make过程，需要明确地指

 

2、需要将一个在上层定义的变量传递给子make，应该在上层Makefile中使用指示符“export”对此变量进行声明。格式如下：

export VARIABLE ...

 

3、当不希望将一个变量传递给子make时，可以使用指示符“unexport”来声明这个变量。格式如下：

unexport VARIABLE ...

 

4、1.

export VARIABLE = value

等效于：

VARIABLE = value

export VARIABLE

 

GCC 

 

1、

source = install.cpp

Destination = install

all: $(Destination)

 

$(Destination):$(source)

@g++ $< -I./xml -lInfo -L./xml -o $@

clean:

@rm $(Destination)

 

2、-I、-l、-L 后面的参数均没有空格

 

 

Makefile 中:= ?= += =的区别

 

在Makefile中我们经常看到 = := ?= +=这几个赋值运算符，那么他们有什么区别呢？我们来做个简单的实验

新建一个Makefile，内容为：
ifdef DEFINE_VRE
    VRE = “Hello World!”
else
endif

ifeq ($(OPT),define)
    VRE ?= “Hello World! First!”
endif

ifeq ($(OPT),add)
    VRE += “Kelly!”
endif

ifeq ($(OPT),recover)
    VRE := “Hello World! Again!”
endif

all:
    @echo $(VRE)

敲入以下make命令：
make DEFINE_VRE=true OPT=define 输出：Hello World!
make DEFINE_VRE=true OPT=add 输出：Hello World! Kelly!
make DEFINE_VRE=true OPT=recover  输出：Hello World! Again!
make DEFINE_VRE= OPT=define 输出：Hello World! First!
make DEFINE_VRE= OPT=add 输出：Kelly!
make DEFINE_VRE= OPT=recover 输出：Hello World! Again!

从上面的结果中我们可以清楚的看到他们的区别了
= 是最基本的赋值
:= 是覆盖之前的值
?= 是如果没有被赋值过就赋予等号后面的值
+= 是添加等号后面的值

 

之前一直纠结makefile中“=”和“:=”的区别到底有什么区别，因为给变量赋值时，两个符号都在使用。网上搜了一下，有人给出了解答，但是本人愚钝，看不懂什么意思。几寻无果之下，也就放下了。今天看一篇博客，无意中发现作者对于这个问题做了很好的解答。解决问题之余不免感叹，有时候给个例子不就清楚了吗？为什么非要说得那么学术呢。^_^

      1、“=”

      make会将整个makefile展开后，再决定变量的值。也就是说，变量的值将会是整个makefile中最后被指定的值。看例子：

            x = foo
            y = $(x) bar
            x = xyz

      在上例中，y的值将会是 xyz bar ，而不是 foo bar 。

      2、“:=”

      “:=”表示变量的值决定于它在makefile中的位置，而不是整个makefile展开后的最终值。

            x := foo
            y := $(x) bar
            x := xyz

      在上例中，y的值将会是 foo bar ，而不是 xyz bar 了。

 

2、先看下面的Makefile：

 

1. #example
2. B := $(A)
3. A = later
4. all:
5.     @echo $(B)

 执行make命令，我们发现什么都没输出,我们将第3行的:=换成=。

 

1. #example
2. B = $(A)
3. A = later
4. all:
5.     @echo $(B)

执行make，输出later。

分析：B :=$(A)时，它只会到这句语句之前去找A的值，因A没有定义所以什么都没有输出。

      B = $(A)时，虽然该语句之前A没有定义，但是在其后定义了，所以能输出later。

 

3、 我的理解：

　　拿clean举例，如果make完成后，自己另外定义一个名叫clean的文件，再执行make clean时，将不会执行rm命令。 

　　为了避免出现这个问题，需要.PHONY: clean

 

=======================================================================================

所谓伪目标就是这样一个目标，它不代表一个真正的文件名，在执行make时可以指定这个目标来执行其所在规则定义的命令，有时我们将一个伪目标成为标签。

那么到底什么是伪目标呢？可能作为初学者还不会在乎这个问题，下面我们来看下我们将在什么时候需要它。

首先来看下面一个例子:

当前目录下只有一个myls1.c，于是为了让程序让makefile来管理，写了一个如下的简单的makefile。

执行：

大家会发现，真的可以利用这个makefile管理当前的工程，也能如期按照我们的要求生成执行文件myls。

执行make clean，这样就可以删除可执行程序。

接着我做了个手脚，在当前目录下建立一个叫clean的文件，那么这样执行的效果是如何？

那么这个时候为什么又不能执行了？在我的makefile中其实并没有修改任何东西，为什么这个时候已经能管理工程的makefile又不能来管理文件了。

那要解决这个问题就是添加两行，修改后的makefile如下：

再次返回执行：

这样就解决了问题，那具体的原因是什么？

在makefile中我们使用伪目标就可以解决上述的问题，那为什么要使用伪目标，一种就是如例题，为了避免在makefile中定义的只执行命令的目标和工作目录下的实际文件出现名字冲突，另一种是提交执行makefile时的效率。

第一种情况：

如果我们需要书写这样的一个规则：规则所定义的命令不是去创建目标文件，而是通过make命令行明确指定它来执行一些特点的命令，就像例题中的clean。当文件夹中没有clean这个文件的时候，我们输入“make clean”能按照初衷执行，但是一旦文件夹中出现clean文件，我们再次输入“make clean”，由于这个规则没有任何依赖文件，所以目标被认为是最新的而不去执行规则所定义的命令。所以rm命令不会被执行。为了解决问题，我们将目标clean定义成伪目标。

也就是添加：

.PHONY:clean

那么目录中不论是否有clean文件，只要输入“make clean”就能执行rm命令了。

当一个目标被声明为伪目标后，make在执行规则时不会去试图去查找隐含规则来创建它。这样就提高了make的执行效率，也不用担心由于目标和文件名重名了。

4、Makefile: $^ $^ $@ 与 ..c.o

2010-05-16 15:19

gcc -c main.c 

gcc -c mytool1.c 

gcc -c mytool2.c 

gcc -o main main.o mytool1.o mytool2.o

 

Makefile文件 

main：main.o mytool1.o mytool2.o 

gcc -o main main.o mytool1.o mytool2.o 

main.o：main.c mytool1.h mytool2.h 

gcc -c main.c 

mytool1.o：mytool1.c mytool1.h 

gcc -c mytool1.c 

mytool2.o：mytool2.c mytool2.h 

gcc -c mytool2.c

 

Makefile中也#开始的行都是注释行.Makefile中最重要的是描述文件的依赖关系的说

明.一般的格式是：

 

target： components 

TAB rule

 

Makefile有三个非常有用的变量.分别是$@,$^,$<代表的意义分别是:

$@--目标文件,$^--所有的依赖文件

,$<--第一个依赖文件.

如果我们使用上面三个变量,那么我们可以简化我们的

Makefile文件为:

 

# 这是简化后的

Makefile

main：main.o mytool1.o mytool2.o

gcc -o $@ $^

main.o：main.c mytool1.h mytool2.h

gcc -c $<</span>

mytool1.o：mytool1.c mytool1.h

gcc -c $<</span>

mytool2.o：mytool2.c mytool2.h

gcc -c $<</span>

 

经过简化后我们的Makefile是简单了一点,不过人们有时候还想简单一点.这里我们学习一个Makefile的缺省规则

 

..c.o：

gcc -c $<</span>

 

这个规则表示所有的 .o文件都是依赖与相应的.c文件的.例如

 

mytool.o依赖于mytool.c

 

这样 Makefile还可以变为：

 

Makefile 

main：main.o mytool1.o mytool2.o 

gcc -o $@ $^ 

..c.o： 

gcc -c $<</span>

一个简单的通用Makefile实现

 

Makefile是Linux下程序开发的自动化编译工具，一个好的Makefile应该准确的识别编译目标与源文件的依赖关系，并且有着高效的编译效率，即每次重新make时只需要处理那些修改过的文件即可。Makefile拥有很多复杂的功能，这里不可能也没必要一一介绍，为了简化问题的复杂性，本文仅和大家讨论针对单目录下的C/C++项目开发，如何写一个通用的Makefile。

首先，我们假设当前工程目录为prj/，该目录下有6个文件，分别是：main.c、abc.c、xyz.c、abc.h、xyz.h和Makefile。其中main.c包含头文件abc.h和xyz.h，abc.c包含头文件abc.h，xyz.c包含头文件xyz.h，而abc.h又包含了xyz.h。它们的依赖关系如图1。

 

图1 文件依赖关系

第一次使用Makefile应该写成这个样子（假设生成目标main）：

main:main.o abc.o xyz.o

    gcc main.o abc.o xyz.o -o main

main.o:main.c abc.h xyz.h

    gcc -c main.c –o main.o -g

abc.o:abc.c abc.h xyz.h

    gcc -c abc.c –o abc.o -g

xyz.o:xyz.c xyz.h

    gcc -c xyz.c -o xyz.o -g

clean:

    rm main main.o abc.o xyz.o -f

虽然这样Makefile完全符合Makefile的书写规则，但是当代码文件再增加几倍后，再管理这些命令将会是一个噩梦！！！因此Makefile提供了默认规则和自动推导帮我们完成一些常用功能。然后，我们将Makefile修改如下：

EXE=main

CC=gcc

OBJ=main.o abc.o xyz.o

CFLAGS=-g

(EXE):(OBJ)

    (CC)^ -o $@

clean:

    rm (EXE)(OBJ) -f

变量EXE，CC，OBJ分别代指目标程序名，编译器名，目标文件名。CFLAGS是Makefile的预定义变量，它会附加在每条编译命令（gcc -c）之后。

$(EXE)是对变量的引用，$^代指所有的依赖项——即$(OBJ)，$@代指目标项——即$(EXE)。该命令等价于：(CC)(OBJ) -o $(EXE)。

这个Makefile只有目标文件链接的命令，源文件的编译命令都被忽略了！这正是Makefile的自动推导功能——它可以将目标文件自动依赖于同名的源文件，即：

main.o:main.c

    gcc -c main.c -o main.o

abc.o:abc.c

    gcc -c abc.c -o abc.o

xyz.o:xyz.c

    gcc -c xyz.c -o xyz.o

 

按照上述方式，只要工程下增加了源文件后，只需要在OBJ初始化处增加一个*.o即可。但是这种方式是有问题的，Makefile的自动推导功能只会推导出目标文件对源文件的依赖关系，而不会增加头文件的依赖关系！！！这导致的直接问题就是修改项目的头文件，不会导致make的自动更新！除非修改头文件后运行一次make clean，再运行make…… :-)

为了能让make自动包含头文件的依赖关系，我们需要做一点额外的工作。幸运的是gcc为我们提供了一个编译选项（gcc -M，对于g++是-MM），能输出目标文件的依赖关系！比如：

$gcc -M main.c

main.o:main.c abc.h xyz.h

如果将每个源文件的依赖关系包含到Makefile里，就可以使得目标文件自动依赖于头文件了！再次修改原先的Makefile：

EXE=main

CC=gcc

SRC=$(wildcard *.c)

OBJ=$(SRC:.c=.o)

CFLAGS=-g

all:depend $(EXE)

depend:

@(CC)−MM(SRC) > .depend

-include .depend

(EXE):(OBJ)

(CC)(OBJ) -o $(EXE)

clean:

@rm (EXE)(OBJ) .depend -f

我们虚设了一个目标all，它依赖于depend和实际的目标EXE。而depend正式将所有的源文件对应的目标文件的依赖关系输入到.depend文件，并包含在Makefile内！这里有几个细节需要说明：

1．.depend文件是隐藏文件，避免和工程的文件混淆。

2．include命令之前增加符号‘-’，避免第一次make时由于.depend文件不存在报告错误信息。

3．SRC初始化为wildcard *.c表示当前目录下的所有.c源文件，这就省去了我们手动输入新增的源文件。

4．OBJ初始化为SRC:.c=.o，表示将SRC中所有.c结尾的文件名替换为.o结尾的，这样就自动生成了源文件的目标文件序列。

5．clean的rm命令钱@符号表示执行该命令时不输出任何信息。

这样，每次执行make时都会重新计算目标文件的依赖关系，并输出到.depend文件，然后包含到Makefile后进行编译工作，这样目标文件的依赖关系就不会出错了！而我们得到了一个能自动包含源文件和识别头文件依赖关系的Makefile，将该文件应用于任何单目录的C/C++工程（C++需要修改部分细节，不作赘述）都能正常工作。

但是，这种方式也有一定的不足，当头文件的依赖关系不发生变化时，每次make也会重新生成.depend文件。如果这样使得工程的编译变得不尽人意，那么我们可以尝试将依赖文件拆分，使得每个源文件独立拥有一个依赖文件，这样每次make时变化的只是一小部分文件的依赖关系。

EXE=main

CC=gcc

SRC=$(wildcard *.c)

OBJ=$(SRC:.c=.o)

DEP=(patsubst(SRC))

CFLAGS=-g

(EXE):(OBJ)

(CC)^ -o $@

$(DEP):.%.d:%.c

@set -e;\

rm -f $@;\

(CC)−M< > @.$$$;\

sed 's,$∗\.o[ :]*,\1.o @:,g′<</span>@.

 

> $@;\

rm -f @.$$$

-include $(DEP)

clean:

@rm (EXE)(OBJ) $(DEP) -f

该Makefile增加了一个变量DEP，初始化为patsubst %.c,.%.d,$(SRC)，表示将SRC中的以*.c结尾的源文件名替换为.*.d的形式，比如main.c对应着文件.main.d，这就是main.c的依赖关系文件，且是隐藏的。

为了生成每个源文件的依赖文件，建立了目标依赖关系$(DEP):.%.d:%.c，该关系表示，对于目标DEP，通过$@可以访问一个依赖文件，通过$>则访问对应的同名源文件。命令部分使用\连接，表示当前命令作为一个整体在一个进程内执行。该组命令的含义是：将gcc -M生成的信息输出到一个临时文件，然后在：之前加上当前的文件名输出到依赖文件。比如对于main.c生成的临时文件信息为：

main.o:main.c abc.h xyz.h

处理后依赖文件信息是：

main.o .main.d:main.c abc.h xyz.h

这样的依赖关系表示main.o和它的依赖关系文件的依赖项是一致的，只要相关的源文件或头文件发生了改变，才会重新生成目标文件和依赖关系文件，也就达到了依赖关系文件单独更新的目的了。

虽然如此，但是这样的Makefile也不是完美的。现假设工程目录内新增一个源文件lmn.c，按照Makefile的指令make后会产生.lmn.d依赖关系文件。而如果我们再删除lmn.c源文件后，重新make后.lmn.d依然存在！尤其是当重复增删很多源文件后，工程目录下可能会存在很多无用的依赖文件，当然这些问题可以通过make clean解决。

通过前边的讨论，我们得到一个能在单目录工程下工作的通用Makefile，至于是实现为单独一个依赖文件的形式，还是每个源文件产生一个独立的依赖文件，要根据程序作者自己的喜恶来选择。虽然每种方法都有一些细微的瑕疵，但是不影响这个通用的Makefile的实用性，试想一下在工程目录下拷贝一份当前的Makefile，稍加修改便可以正确的编译开发，一定会令人心情大好。希望本文对你学习Linux写的程序开发有所帮助！