实例—使用make及Makefile文件

2.3 实例—使用make及Makefile文件

一个工程有3个头文件（head1.h、head2.h、exam2.h）和8个C文件（main.c、exam1.c、exam2.c、exam3.c、exam4.c、exam5.c、exam6.c、exam7.c），建立一个Makefile文件（文件名为makefile），内容如下。注意，上述12个文件位于同一个目录中。

example : main.o exam1.o exam2.o exam3.o exam4.o exam5.o exam6.o exam7.o

gcc -o example main.o exam1.o exam2.o exam3.o exam4.o exam5.o exam6.o exam7.o

main.o : main.c head1.h

gcc -c main.c

exam1.o : exam1.c head1.h exam2.h

gcc -c exam1.c

exam2.o : exam2.c head1.h exam2.h

gcc -c exam2.c

exam3.o : exam3.c head1.h head2.h

gcc -c exam3.c

exam4.o : exam4.c head1.h head2.h

gcc -c exam4.c

exam5.o : exam5.c head1.h head2.h

gcc -c exam5.c

exam6.o : exam6.c head1.h head2.h exam2.h

gcc -c exam6.c

exam7.o : exam7.c head1.h

gcc -c exam7.c

clean :

rm example main.o exam1.o exam2.o exam3.o exam4.o exam5.o exam6.o exam7.o

makefile文件告诉make命令如何编译和链接这几个文件。在当前路径下执行make命令，就可以生成可执行文件example。如果要删除可执行文件和所有的中间目标文件，只需执行make clean命令即可。

Makefile文件的操作规则是：

①如果该工程没有编译过，所有C文件都要编译并被链接。

②如果该工程的某几个C文件被修改，只需编译被修改的C文件，并链接目标程序。

③如果该工程的头文件被改变，需要编译包含这些头文件的C文件，并链接目标程序。

在这个Makefile文件中，目标文件（target）有：执行文件example和中间目标文件（*.o）；依赖文件（prerequisites）有：冒号后面的.c文件和.h文件。

每一个.o文件都有一组依赖文件，而这些.o文件又是执行文件example的依赖文件。依赖关系是指目标文件由哪些文件生成。在定义好依赖关系后，规则命令定义了如何生成目标文件，其一定要以一个Tab键打头。

make会比较targets文件和prerequisites文件的时间戳，如果prerequisites文件的日期比targets文件的日期要新，或者target不存在，make就会执行相应的规则命令。

默认方式下，执行make命令时，make会在当前目录下找Makefile，如果找到，make 会找文件中的第一个目标文件（target），上面的例子是example文件，并把这个文件作为最终的目标文件。如果example文件不存在，或example所依赖的.o文件的修改时间比example 文件新，make就会执行相应的规则命令生成example文件。如果example所依赖的.o文件不存在，make会在当前目录中找目标为.o文件的依赖文件（C文件和H文件），如果找到，则根据规则生成.o文件，然后再用.o文件生成make的最终结果，也就是可执行文件example。

有上可知，make会一层一层地去找文件的依赖关系，直到最终编译出第一个目标文件。在寻找的过程中，如果出现错误（比如被依赖的文件找不到）make就会直接退出，并报错。

clean不是一个文件，只是一个动作名字，类似于C语言中的lable，冒号后什么也没有，这样make就不会自动去找文件的依赖性，也就不会自动执行其后所定义的规则命令。要执行其后的命令，就要在make命令后显式的指出这个lable的名字，例如执行make clean命令。

1．在Makefile文件中使用变量

其中字符串（main.o exam1.o exam2.o exam3.o exam4.o exam5.o exam6.o exam7.o）被重复了两次。如果这个工程需要加入一个新的.o文件，需要在三个位置插入该字符串。如果工程很大，Makefile文件也会很复杂，就要对更多的地方进行修改，因此就容易出错，从而会导致编译失败。所以，为了Makefile文件的易维护，在Makefile文件中可以使用变量。Makefile 文件的变量也就是一个字符串（类似于C语言中的宏）。

可以在Makefile文件中以$(objects)的方式来使用这个变量。改进后的Makefile文件如下：

objects = main.o exam1.o exam2.o exam3.o exam4.o exam5.o exam6.o exam7.o

example : $(objects)

gcc -o example $(objects)

main.o : main.c head1.h

gcc -c main.c

exam1.o : exam1.c head1.h exam2.h

gcc -c exam1.c

exam2.o : exam2.c head1.h exam2.h

gcc -c exam2.c

exam3.o : exam3.c head1.h head2.h

gcc -c exam3.c

exam4.o : exam4.c head1.h head2.h

gcc -c exam4.c

exam5.o : exam5.c head1.h head2.h

gcc -c exam5.c

exam6.o : exam6.c head1.h head2.h exam2.h

gcc -c exam6.c

exam7.o : exam7.c head1.h

gcc -c exam7.c

clean :

rm example $(objects)

2．让make自动推导依赖关系

make可以自动推导文件以及文件依赖关系后面的命令，因此没有必要在每一个.o文件后都写上类似的命令。只要make看到一个.o文件，就会自动把.c文件加在依赖关系中，比如make看到hello.o，就会将hello.c作为hello.o的依赖文件，并且会自动推导出gcc -c hello.c。

修改后的Makefile文件如下：

这种方法也就是make的隐含规则。.PHONY表示clean是个伪目标文件。

伪目标并不是一个文件，只是一个标签。由于伪目标不是文件，所以make无法生成它的依赖关系和决定它是否要执行，只有通过显式地指明这个目标才能让其生效。当然，伪目标的取名不能和文件名重名，不然其就失去了伪目标的意义了。为了避免和文件重名这种情况，可以使用一个特殊的标记.PHONY（假）来显式地指明一个目标是伪目标，告诉make，不管是否有这个文件，这个目标就是伪目标。

在Linux中，软件发布时，特别是GNU这种开放源代码的软件发布时，其Makefile文

件都包含了编译、安装、打包等功能。可以参照这种规则来书写Makefile文件中的目标。

一些常用的伪目标及其功能见表2.10。

表2.10 伪目标及其功能

3．清空目标文件的规则

每个Makefile文件都应该有一个清空目标文件（.o和执行文件）的规则，这不仅便于

在rm命令前面加上一个减号（在Tab键之后），作用是如果某些文件出现问题将被忽略，继续进行后面的操作。另外，clean规则不要放在Makefile文件的开头，否则会变成make 的默认目标。不成文的规矩是clean规则放在文件的最后。

4．重新认识Makefile文件

Makefile文件主要包含5部分内容：显式规则、隐含规则、变量定义、文件指示和注释。见表2.11。

表2.11 Makefile文件内容

默认情况下，make命令会在当前目录下按顺序寻找文件名为GNUMakefile、makefile、Makefile的文件，找到后解释这个文件。在这3个文件名中，最好使用Makefile这个文件名。

不要用GNUMakefile文件名。大多数的make都支持makefile和Makefile这两种默认的文件名。当然，可以使用别的文件名来书写Makefile文件，此时要使用make的-f或--file选项。

在Makefile文件中使用include关键字可以把别的Makefile文件包含进来，被包含的文件会保持原来的状态，并被放在当前文件的包含位置。include的语法是：include

可以是当前操作系统Shell的文件模式（可以包含路径和通配符）。在include 前面可以有一些空字符，但是一定不能以[Tab]键开始。include和可以用一个或多个空格隔开。

如果没有指定绝对路径或相对路径，make会在当前目录下首先寻找，如果当前目录下没有找到，make还会在下面的几个目录下寻找：

①如果make有-I或--include-dir参数，就会在该参数所指的目录下去寻找。

②如果目录/include存在，make也会去寻找。

如果找到Makefile文件，make命令会将其内容安置在当前的位置。

如果没有找到Makefile文件，make命令会生成一条警告信息，但不会马上出现致命错误信息，它会继续载入其它文件，一旦完成Makefile文件的读取，make会再重试这些没有找到或是不能读取的文件，如果还是不行，make才会出现一条致命错误信息。如果想让make 忽略那些无法读取的文件，而继续执行，可以在include前加一个减号。例如：-include

表示无论include过程中出现什么错误，都不会报错而是继续执行。和其它版本的make 兼容的相关命令是sinclude，其作用和inculde相同。

GNU的make工作时的执行步骤如下：

①读入所有的Makefile文件。

②读入被include包括的其它Makefile文件。

③初始化文件中的变量。

④推导隐含规则，并分析所有规则。

⑤为所有的目标文件创建依赖关系链。

⑥根据依赖关系，决定哪些目标要重新生成。

⑦执行生成命令。

①～⑤为第一阶段，⑥～⑦为第二阶段。第一阶段中，如果定义的变量被使用了，make 会把其在使用的位置展开。但make并不会马上完全展开，如果变量出现在依赖关系的规则中，仅当这条依赖被决定使用时，变量才会在其内部展开。

Makefile文件中的规则包含两个部分：依赖关系、生成目标的命令。在Makefile文件中，规则的顺序是很重要的，因为Makefile文件中只应该有一个最终目标，其它目标都是被这个目标连带出来的，所以一定要让make知道最终目标是什么。一般来说，定义在Makefile 文件中的目标可能会有很多，但是第一条规则中的目标将被确立为最终目标，make所完成的也就是这个目标。

手动建立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中“规则”就是描述在什么情况下、如何重建规则的目标文件，通常规则

跟我一起写Makefile

跟我一起写Makefile 陈皓 1 概述 什么是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。 2 关于程序的编译和链接 在此，我想多说关于程序编译的一些规范和方法，一般来说，无论是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中找寻函数的实现，如果找不到，那到就会报链接错

Makefile下编写Helloworld的例子

什么是makefile？或许很多Windows的程序员都不知道这个东西，因为那些Windows的IDE都为你做了这个工作，但我觉得 要作一个好的和professional的程序员，makefile还是要懂。这就好像现在有这么多的HTML的编辑器，但如果你想成为一个专 业人士，你还是要了解HTML的标识的含义。特别在Unix下的软件编译，你就不能不自己写makefile了，会不会写makefile， 从一个侧面说明了一个人是否具备完成大型工程的能力。 因为，makefile关系到了整个工程的编译规则。一个工程中的源文件不计数，其按类型、功能、模块分别放在若干个目录中， makefile定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复 杂的功能操作，因为makefile就像一个Shell脚本一样，其中也可以执行操作系统的命令。 makefile带来的好处就是——“自动化编译”，一旦写好，只需要一个make 命令，整个工程完全自动编译，极大的提高了软件 开发的效率。make是一个命令工具，是一个解释makefile中指令的命令工具，一般来说，大多数的IDE都有这个命令，比如： Delphi的make，VisualC++的nmake，Linux下GNU的make。可见，makefile都成为了一种在工程方面的编译方法。 更新版本 hello.c程序 ＃include int main(){printf("Hello,World!\n");

return 0;}=== makefile开始=== Helloworld: hello.o gcc hello.o–o Helloworld Hello.o: hello.c hello.h gcc–MM hello.c gcc–c hello.c–o hello.o .PHONY: clean Clean: rm–rf*.o hellworld === makefile结束===

MakeFile

MAKE 的使用 当编译单个文件时，使用GCC已经绰绰有余，但对于有几十个甚至上百个源文件的大工程来讲，单纯用GCC命令进行编译肯定就不行了，那样编译一次太麻烦，这就要求有一种自动化的方法，于是在Linux系统中Make工具就诞生了。 1、什么是Make makefile shell 什么是Make，可以将Make理解为一种脚本，这种脚本主要是用于多文件编译，在传统的命令行式编译方式中，如果修改了工程中的某一个头文件，有时候不需要重新编译整个工程，而只需要编译与这个头文件相关联的源文件即可，但如何以手动的方式从一个大工程里将这些文件找出，并手动编译，是件很麻烦的事情。 为了解决这一问题，设计了Make，make程序可以维护具有相互依赖性的源文件，当某些文件发生改变时，它能自动识别出，并只对相应文件进行自动编译。 虽然make工具有很多智能识别机制，但它无法自动了解他所面对的工程源文件的组成以及依赖规则，这些都需要开发人员编写makefile脚本，告诉make工具。MakeFile编写好以后，就可以在每次修改源文件之后，执行make命令就好了。Makefile make 什么又是makefile了，很多windows的程序开发人员都不知道这个东西，因为那些Windows的IDE都为你做了这些工作，但我觉得要作为一个好的和专业的程序员，makefile还是要懂得，这就好像在有这么多的HTML的编辑器，但如果你想成为一个专业人士，就必须了解HTML的标识的含义。特别在Linux下的软件编译，你就必须自己写makefile了，会不会写makefile，从一个侧面说明了一个人是否具备完成某个大型大工程的能力。 2、makefile的组成 一个完整的makefile文件通常由五个部分组成： ◆显示规则 显示规则是指主动编写描述规则，用于指示在何种状态下更新哪些目标文件，即编写makefile时需要明确指出各目标文件所依赖的源文件的集合，以及编 译本目标文件所需的命令。 ◆隐含规则 指用make中默认的编译方式进行编译，即make工具可以根据目标文件的类型自动推导出的规则（由于我们的make有自动推导的功能，所以隐晦的规则可以 让我们比较粗糙地简略书写Makefile ，这是由make所支持的） abc.o abc.c cc -o abc.o -c abc.c ◆变量定义 为提升语句的灵活性，在make脚本中可以使用变量，来代表一个字符串，一组编译命令或一组文件名。（在makefile 中我们要定义一系列的变量，变量一般都是字符串，这个有点类似于C语言中的宏，当makefile 被执行时，其中的变量都会被扩展到相应的引用位置上） ◆makefile指示符 指示符告诉make工具，当程序在读取makefile文件时要执行的动作。 （文件指示包括三部分，一个是在一个makefile中引用另外一个makefile，就像C语言中的include一样，另一个是指根据某些情况制定MakeFile中的有效部分，就像C 语言中的预编译#if一样，还有就是定义一个多行的命令，）

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

Linux下Makefile简单教程

目录 一：Makefile基本规则 1.1示例 1.2 隐式规则 1.3 伪目标 1.4 搜索源文件 二：变量 2.1使用变量定义变量值 2.2追加变量 三：条件判断 四：函数

Linux下Makefile总结 ——一步 MakeFile可以看做是一种简单的编程语言，其诞生的本质目的是实现自动化编译。 以Linux下gcc-c编译器为例，编译一个c语言程序需要经过以下几个步骤： 1.将c语言源程序预处理，生成.i文件； 2.预处理后的.i语言编译成汇编语言，生成.s文件； 3.汇编语言经过汇编，生成目标文件.o文件； 4.将各个模块的.o文件链接起来，生成一个可执行程序文件。 我们知道，在Visual C++6.0中，可以新建一个工程，在一个工程当中能够包含若干个c语言文件，则编译的时候直接编译整个工程便可。Linux下无法为多个c语言文件新建工程，但可以通过MakeFile实现它们的整合编译。 如上gcc-c编译步骤，如果使用Makefile则过程为： .C文件——>.o文件——>可执行文件 当然，Makefile中也加入了自己的设置变量方法与集成了一些函数，能够更有效地方便用户使用。 /**************************分隔符********************************/

一：Makefile基本规则 1.1示例 target ... : prerequisites ... command ... ... target也就是一个目标文件，可以是Object File，也可以是执行文件。prerequisites就是，要生成那个target所需要的文件或是目标。command也就是make需要执行的命令。（任意的Shell命令） 为了方便理解，我们来看一个示例： /*Makefile示例*/ edit : main.o kbd.o command.o display.o / insert.o search.o files.o utils.o gcc -o edit main.o kbd.o command.o display.o / insert.o search.o files.o utils.o main.o : main.c defs.h #生成main.o gcc -c main.c

跟我一起写Makefile(可以注释版)

跟我一起写 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模板及实例

1 通用Makefile——1 实现的功能： ?make——编译和连接程序 ?make objs——编译程序，生成目标文件 ?make clean——清除编译产生的目标文件（*.o）和依赖文件（*.d） ?make cleanall——清除目标文件（*.o）、依赖文件（*.d）和可执行文件（*.exe）?make rebuild——重新编译连接程序，相当于make clean && make Usage： Makefile源代码 # Gneric C/C++ Makefile #################################################### PROGRAM := SRCDIRS := SRCEXTS := CPPFLAGS := CFLAGS := CFLAGS += CXXFLAGS := CXXFLAGS += LDFLAGS := LDFLAGS += SHELL = /bin/sh SOURCES = $(foreach d,$(SRCDIRS),$(wildcard $(addprefix $(d)/*,$(SRCEXTS)))) OBJS = $(foreach x,$(SRCEXTS),\ $(patsubst %$(x),%.o,$(filter %$(x),$(SOURCES)))) DEPS = $(patsubst %.o,%.d,$(OBJS)) .PHONY: all objs clean cleanall rebuild all : $(PROGRAM) %.d : %.c @$(CC) -MM -MD $(CFLAGS) {1}lt; %.d : %.C @$(CC) -MM -MD $(CXXFLAGS) {1}lt; objs : $(OBJS) %.o : %.c $(CC) -c $(CPPFLAGS) $(CFLAGS) {1}lt; %.o : %.cpp $(CXX) -c $(CPPFLAGS) $(CXXFLAGS) {1}lt; $(PROGRAM) : $(OBJS) ifeq ($(strip $(SRCEXTS)),.c) $(CC) -o $(PROGRAM) $(OBJS) $(LDFLAGS)

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

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。 关于程序的编译和链接 —————————— 在此，我想多说关于程序编译的一些规范和方法，一般来说，无论是C、C++、还是pas，首先要把源文件编译成中间代码文件，在Windows下也就是 .obj 文件，UNIX下是 .o 文件，即Object File，这个动作叫做编译（compile）。然后再把大量的Object File合成执行文件，这个动作叫作链接（link）。 编译时，编译器需要的是语法的正确，函数与变量的声明的正确。对于后者，通常是你需要告诉编译器头文件的所在位置（头文件中应该只是声明，而定义应该放在C/C++文件中），只要所有的语法正确，编译器就可以编译出中间目标文件。一般来说，每个源文件都应该对应于一个中间目标文件（O文件或是OBJ文件）。

makefile 中 $@ $^ % 使用

makefile 中$@ $^ %< 使用 https://www.sodocs.net/doc/34424431.html,/kesaihao862/article/details/7332528 这篇文章介绍在LINUX下进行C语言编程所需要的基础知识。在这篇文章当中，我们将会学到以下内容：源程序编译Makefile的编写程序库的链接程序的调试头文件和系统求助1.源程序的编译在Linux下面，如果要编译一个C语言源程序，我们要使用GNU的gcc编译器。下面我们以一个实例来说明如何使用gcc编译器。假设我们有下面一个非常简单的源程序(hello.c)：int main(int argc，char **argv){printf("Hello Linux\n")；}要编译这个程序，我们只要在命令行下执行：gcc -o hello hello.cgcc 编译器就会为我们生成一个hello的可执行文件。执行./hello就可以看到程序的输出结果了。命令行中gcc表示我们是用gcc来编译我们的源程序，-o 选项表示我们要求编译器给我们输出的可执行文件名为hello 而hello.c是我们的源程序文件。gcc编译器有许多选项，一般来说我们只要知道其中的几个就够了。-o 选项我们已经知道了，表示我们要求输出的可执行文件名。-c选项表示我们只要求编译器输出目标代码，而不必要输出可执行文件。-g选项表示我们要求编译器在编译的时候提供我们以后对程序进行调试的信息。知道了这三个选项，我

们就可以编译我们自己所写的简单的源程序了，如果你想要知道更多的选项，可以查看gcc的帮助文档，那里有着许多对其它选项的详细说明。2.Makefile的编写假设我们有下面这样的一个程序，源代码如下：/* main.c */#include "mytool1.h"#include "mytool2.h" int main(int argc，char **argv){mytool1_print("hello")；mytool2_print("hello")；}/* mytool1.h */ #ifndef _MYTOOL_1_H#define _MYTOOL_1_Hvoid mytool1_print(char *print_str)；#endif/* mytool1.c */#include "mytool1.h"void mytool1_print(char *print_str){printf("This is mytool1 print %s\n"，print_str)；}/* mytool2.h */#ifndef _MYTOOL_2_H#define _MYTOOL_2_Hvoid mytool2_print(char *print_str)；#endif/* mytool2.c */#include "mytool2.h"void mytool2_print(char *print_str){printf("This is mytool2 print %s\n"，print_str)；}当然由于这个程序是很短的我们可以这样来编译gcc -c main.cgcc -c mytool1.cgcc -c mytool2.cgcc -o main main.o mytool1.o mytool2.o这样的话我们也可以产生main程序，而且也不时很麻烦。但是如果我们考虑一下如果有一天我们修改了其中的一个文件(比如说mytool1.c)那么我们难道还要重新输入上面的命令?也许你会说，这个很容易解决啊，我写一个SHELL脚本，让她帮我去完成不就可以了。是的对于这个程序来说，是可

怎样使用Makefile

Mak k e f ile 跟我一 我一起起写Ma 陈皓 (CSDN) 概 述 什么是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++项目的Makefile编写

一个C++项目的Makefile编写-Tony与Alex的对话系列- - Tony : Hey Alex, How are you doing? Alex : 不怎么样。(显得很消沉的样子) Tony : Oh , Really ? What is the matter? Alex : 事情是这样的。最近有一个Unix下的C++项目要求我独自完成，以前都是跟着别人做，现在让自己独立完成，还真是不知道该怎么办，就连一个最简单的项目的Makefile都搞不定。昨晚看了一晚上资料也没有什么头绪。唉！！ Tony : 别急，我曾经有一段时间研究过一些关于Makefile的东西，也许能帮得上忙，来，我们一起来设计这个项目的Makefile。 Alex : So it is a deal。(一言为定) Tony : 我们现在就开始吧，给我拿把椅子过来。 (Tony坐在Alex电脑的旁边) Tony : 把你的项目情况大概给我讲讲吧。 Alex : No Problem ! 这是一个“半成品”项目，也就是说我将提供一个开发框架供应用开发人员使用，一个类似MFC的东西。 Tony : 继续。 Alex : 我现在头脑中的项目目录结构是这样的： APL (Alex's Programming Library) -Make.properties -Makefile(1) -include //存放头文件 -Module1_1.h -Module1_2.h -Module2_1.h -Module2_2.h -src //存放源文件 -Makefile(2) -module1 -Module1_1.cpp -Module1_2.cpp -Makefile(3) -module2 -Module2_1.cpp -Module2_2.cpp -Makefile(3) -... -lib //存放该Project依赖的库文件,型如libxxx.a -dist //存放该Project编译连接后的库文件libapl.a -examples //存放使用该“半成品”搭建的例子应用的源程序 Makefile(4)

实例—使用make及Makefile文件

2.3 实例—使用make及Makefile文件 一个工程有3个头文件（head1.h、head2.h、exam2.h）和8个C文件（main.c、exam1.c、exam2.c、exam3.c、exam4.c、exam5.c、exam6.c、exam7.c），建立一个Makefile文件（文件名为makefile），内容如下。注意，上述12个文件位于同一个目录中。 example : main.o exam1.o exam2.o exam3.o exam4.o exam5.o exam6.o exam7.o gcc -o example main.o exam1.o exam2.o exam3.o exam4.o exam5.o exam6.o exam7.o main.o : main.c head1.h gcc -c main.c exam1.o : exam1.c head1.h exam2.h gcc -c exam1.c exam2.o : exam2.c head1.h exam2.h gcc -c exam2.c exam3.o : exam3.c head1.h head2.h gcc -c exam3.c exam4.o : exam4.c head1.h head2.h gcc -c exam4.c exam5.o : exam5.c head1.h head2.h gcc -c exam5.c exam6.o : exam6.c head1.h head2.h exam2.h gcc -c exam6.c exam7.o : exam7.c head1.h gcc -c exam7.c clean : rm example main.o exam1.o exam2.o exam3.o exam4.o exam5.o exam6.o exam7.o makefile文件告诉make命令如何编译和链接这几个文件。在当前路径下执行make命令，就可以生成可执行文件example。如果要删除可执行文件和所有的中间目标文件，只需执行make clean命令即可。 Makefile文件的操作规则是： ①如果该工程没有编译过，所有C文件都要编译并被链接。 ②如果该工程的某几个C文件被修改，只需编译被修改的C文件，并链接目标程序。 ③如果该工程的头文件被改变，需要编译包含这些头文件的C文件，并链接目标程序。 在这个Makefile文件中，目标文件（target）有：执行文件example和中间目标文件（*.o）；依赖文件（prerequisites）有：冒号后面的.c文件和.h文件。 每一个.o文件都有一组依赖文件，而这些.o文件又是执行文件example的依赖文件。依赖关系是指目标文件由哪些文件生成。在定义好依赖关系后，规则命令定义了如何生成目标文件，其一定要以一个Tab键打头。 make会比较targets文件和prerequisites文件的时间戳，如果prerequisites文件的日期比targets文件的日期要新，或者target不存在，make就会执行相应的规则命令。 默认方式下，执行make命令时，make会在当前目录下找Makefile，如果找到，make 会找文件中的第一个目标文件（target），上面的例子是example文件，并把这个文件作为最终的目标文件。如果example文件不存在，或example所依赖的.o文件的修改时间比example 文件新，make就会执行相应的规则命令生成example文件。如果example所依赖的.o文件不存在，make会在当前目录中找目标为.o文件的依赖文件（C文件和H文件），如果找到，则根据规则生成.o文件，然后再用.o文件生成make的最终结果，也就是可执行文件example。 有上可知，make会一层一层地去找文件的依赖关系，直到最终编译出第一个目标文件。在寻找的过程中，如果出现错误（比如被依赖的文件找不到）make就会直接退出，并报错。 clean不是一个文件，只是一个动作名字，类似于C语言中的lable，冒号后什么也没有，这样make就不会自动去找文件的依赖性，也就不会自动执行其后所定义的规则命令。要执行其后的命令，就要在make命令后显式的指出这个lable的名字，例如执行make clean命令。

Makefile两个实验教案

Makefile工程管理器 14.1 编写包含多文件的Makefile 【实验内容】 编写一个包含多文件的Makefile。 【实验目的】 通过对包含多文件的Makefile的编写，熟悉各种形式的Makefile，并且进一步加深对Makefile中用户自定义变量、自动变量及预定义变量的理解。 【实验平台】 PC机、CentOS 5 操作系统、gcc等工具。 【实验步骤】 1.用vi在同一目录下编辑两个简单的Hello程序，如下所示： #hello.c #include "hello.h" int main() { printf("Hello everyone!\n"); } #hello.h #include 2.仍在同一目录下用vim编辑Makefile，不使用变量替换，用一个目标体实现（即直接将 hello.c和hello.h编译成hello目标体）。并用make验证所编写的Makefile是否正确。 3.将上述Makefile使用变量替换实现。同样用make验证所编写的Makefile是否正确 4.用编辑另一Makefile，取名为Makefile1，不使用变量替换，但用两个目标体实现（也 就是首先将hello.c和hello.h编译为hello.o，再将hello.o编译为hello），再用make的‘-f’选项验证这个Makefile1的正确性。 5.将上述Makefile1使用变量替换实现 【详细步骤】 1.用vi打开上述两个代码文件‘hello.c’和‘hello.h’ 2.在shell命令行中用gcc尝试编译，使用命令：‘gcc hello.c -o hello’，并运行hello可执 行文件查看结果。 3.删除此次编译的可执行文件：rm –rf hello 4.用vim编辑Makefile，如下所示： hello:hello.c hello.h gcc hello.c -o hello 5.退出保存，在shell中键入：make查看结果 6.再次用vim打开Makefile，用变量进行替换，如下所示： OBJS :=hello.o CC :=gcc hello:$(OBJS) $(CC) $^ -o $@