makefile文件编写

makefile文件编写及VC++自带的Nmake

1.Dos下运行VC++自带的Nmake，设置路径

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

注：摘录侯俊杰--在console mode 中使用 C/C++ 编译器

●C/C++ 编译器需要的环境变数设定

古早以来，PC 上的 C 编译器，就需要两个环境变数：

LIB：这个环境变数告诉编译器说，必要的libraries 在哪里（哪个磁碟目录下）

INCLUDE：告诉编译器说，必要的 header files 在哪里（哪个磁碟目录下）

另外，为了让我们能够在任何working directory 都叫得到编译器，当然我们必须设定PATH。

从古早以来，一直到现在，C/C++ 编译器都需要这三个环境变数。

●以Visual C++ 为例

以Visual C++ 为例，如果安装後的档案布局如下：

C:\MSDEV\VC98\BIN : 这里放有编译器CL.EXE

C:\MSDEV\VC98\INCLUDE : 这里放有C/C++ header files

C:\MSDEV\VC98\LIB : 这里放有C/C++ standard libraries

那麽你可以写一个批次档如下：

set PATH=C:\MSDEV\VC98\BIN;C:\MSDEV\COMMON\MSDEV98\BIN

set INCLUDE=C:\MSDEV\VC98\INCLUDE

set LIB=C:\MSDEV\VC98\LIB

之所以需要另外设定PATH=C:\MSDEV\COMMON\MSDEV98\BIN，是因为编译器CL.EXE 执行时需要MSPDB60.DLL，而它被安装於C:\MSDEV\COMMON\MSDEV98\BIN 之中。

如果你写的程式不只是单纯的C/C++ 程式，还用到了MFC，一样可以在console mode 下编译，这时候你的环境变数应该如此设定：

set PATH=C:\MSDEV\VC98\BIN;C:\MSDEV\COMMON\MSDEV98\BIN

set INCLUDE=C:\MSDEV\VC98\INCLUDE;C:\MSDEV\VC98\MFC\INCLUDE

set LIB=C:\MSDEV\VC98\LIB;C:\MSDEV\VC98\MFC\LIB

多指定了MFC\INCLUDE 和MFC\LIB，就可以让编译器和联结器找到MFC 的header files 和libraries。如果你还需要用到ATL，就得在INCLUDE 环境变数中再加上C:\MSDEV\VC98\ATL\INCLUDE。

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

我的VC++安装在D:\Program Files\Microsoft Visual Studio下，所以改写批次档如下：

set PATH=D:\Program Files\Microsoft Visual Studio\VC98\Bin;D:\Program Files\Microsoft Visual Studio\Common\MSDev98\Bin

set INCLUDE=D:\Program Files\Microsoft Visual Studio\VC98\Include;D:\Program Files\Microsoft Visual Studio\VC98\MFC\Include

set LIB=D:\Program Files\Microsoft Visual Studio\VC98\Lib;D:\Program Files\Microsoft Visual Studio\VC98\MFC\Lib

然后运行cmd，将以上设置复制粘贴到鼠标闪烁处。如果想要确认路径更改正确，可以键入set命令查看。注：这样的环境变量修改，仅对本次命令行窗口有效，因为它是一个虚拟设备。如果想要每次进入时，不做这个工作。可以运行VCVARS32.BAT然后设置你的环境变量。为了不影响VC++的原本设置方便集成环境的使用，我并没有实际操作，一个简单的复制粘贴也不见得麻烦。另外还可以在我的电脑-属性-高级-

环境变量里直接修改，这个修改也是永久性的。到这里，路径就设置好了。下面试操作一下：

我在F:\盘保存了一个test.cpp文件作为测试文件。文件内容如下：

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

#include

void main()

{

cout<<"hello"<

}

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

使用cd命令把当前命令行窗口路径切换到F:\>,然后执行cl test.cpp命令，在F:\盘路径下生成了两个文件，test.obj和test.exe。然后再运行test.exe，就可以看到结果了（输出hello）。

下面再举一个例子，也就是下面要学习的makefile文件。测试文件名为mypath.mak（你可以任意取名），依旧存储在当前路径下。

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

all:

@echo $(PATH)

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

运行命令nmake mypath.mak，你可以看到输出结果为你刚才设置过的路径（我的结果是D:\Program Files\Microsoft Visual Studio\VC98\Bin;D:\Program Files\Microsoft Visual Studio\Common\MSDev98\Bin）。

2.产生自己的makefile文件

下面是我在网上找到的一个简单的例子及其解说

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

下面来看一个简单的例子（以下内容均以Win32平台为例）：

文件名：makefile

1. # makefile

2. # this is a example of make file

3. all:a1 a2

4. @echo this is all!

5. a1:

6. @echo this is a1!

7. a2:

8. @echo this is a2!

运行make后，结果如下：

this is a1!

this is a2!

this is all!

现在让我们来分析一下这个简单的规则文件。

第1、2行不用说，一眼就可以看出是注释。在Make规则文件中，注释是以―#‖开始，是行注释，和C++中的―//‖功能一样。不过你可不能把它放到其它的语句之后，否则就错了。第3行就是规则开始了！all:a1 a2一行中，规则的名字就是all，它通常是目标名（target）。一条规则可以有不止一个名字，像

这一行，你也可以把它写成all all2:a1 a2。这时，规则就有了两个名称—all和all2。当然，还可以有更多，都看你自己。后面的5、7两行也分别是两条规则的起始。在―:‖之后的，就是依赖项。在这一行里，依赖项有两个，分别是a1和a2。这些依赖项可以是其它的规则名（目标名），也可以是文件名。依赖和目标之间的关系就是―依赖关系‖。一条规则中，可以有零个（像后面的两条规则）、一个或多个依赖。第4行@echo this is all!是命令行。它是执行all规则时要执行的命令。要注意的是，一条规则内的命令要以tab为一行的起始，以表示命令是属于一个规则。一条规则也可以有多条命令，每条命令占一行（要以tab开头）。至于可以使用哪些命令，这完全取决于你使用的OS和SHELL。

当执行make时，它会找到第一条规则。然后，make就会检查依赖和目标之间的关系。如果目标比依赖旧，就执行规则，以更新目标。执行完规则就结束。如何判定目标和依赖的新旧呢？如果目标（文件）不存在，目标的时间就为0；如果目标（文件存在），目标的时间就为文件的修改时间。如果依赖项是一条规则，就执行依赖的规则（这里是一个递归），然后依赖的时间就是当前最新时间；如果是一个存在的文件，就为文件的修改时间，否则就报错。之后，就可以比较目标和依赖之间的关系。不过，有一点特殊的是，在没有依赖项时，依赖的时间为1。

在这个例子中，make先找到规则―all‖，发现目标不存在，所以目标的时间为0；然后在查找依赖―a1‖，结果―a1‖不存在；于是，执行规则―a1‖。―a1‖不存在，所以它的时间为0，而―a1‖没有依赖，它的依赖时间为1；1>0，所以，执行规则―a1‖。然后返回规则―all‖，再检查依赖―a2‖。―a2‖执行过程同―a1‖。这时，―all‖的目标时间为0，依赖时间为最新时间。于是，执行规则―all‖的命令。

当然，大家也可以指定一条规则让make执行，比如：make a1这个命令就是告诉make程序不去找第一条规则，而是规则―a1‖来执行。并且我们还可以一次执行多条规则，比如：执行make a1 a2就会连续执行―a1‖、―a2‖两条规则。

OK，虽然讲得很混乱，但也费了我半天的力气。大家应该有一点了解make规则的执行过程了吧。==============================================

依赖的基本写法如下：

Target：Dependence

Command

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

Target可以是文件名。Dependence可以是其它的target名或文件名。Command就是操作系统所运行的命令行。

变量

一个make规则文件有这些内容就已经基本可以工作了。可是，当我们在编译一个程序时，如果有些内容要反复用到，每次都要写一长串的话，是很麻烦的。于是，make就引入了宏这个概念（其实也可以看成简单的脚本语言）。

宏变量的定义如下：

var1 = this is a macro demo!

var1就是变量名，它的值就是―this is a macro demo!‖

如果我们要使用这个变量的值，那只有通过$这个运算符才行—$（var1）代表的就是―this is a macro demo!‖。

如下makefile

1. var1 = this is a macro demo!

2. all:

3. @echo $(var1)

结果输出：

this is a macro demo!

用户在执行命令行时也可以定义宏变量。其形式如下：

make all var1=‖this is a test‖

执行结果为：

this is a test

我们不仅可以使用自定义变量，还可以通过这种方式使用系统环境变量。这样可以大大方便我们建议灵活的规则。如下makefile

1. all:

2. @echo $(WINDIR)

执行结果为：

C:\WINDOWS

（注意：makefile中的变量是大小写敏感的）

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

下面介绍makefile文件的一些内置变量：

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

$@代表规则中的目标名（也就是规则名）。

$<代表规则中的依赖项目。注意，它只代表规则所有依赖项目中的第一项！

其它还有：

$^代表规则中所有的依赖项目。

$?代表规则中时间新于目标的依赖项目。

不仅如此，还可以给这些特殊的变量加一些限制。

如：

在规则

debug/out.exe : out.obj

中，$@代表debug/out.exe，而$(@D)代表目录名debug，$(@F)代表文件名out.exe。其它如$(

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

举个例子说明，下面是原始makefile文件内容：

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

myprog : foo.o bar.o

gcc foo.o bar.o -o myprog

foo.o : foo.c foo.h bar.h

gcc -c foo.c -o foo.o

bar.o : bar.c bar.h

gcc -c bar.c -o bar.o

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

用变量代替后的文件内容：

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

OBJS = foo.o bar.o

CC = gcc

CFLAGS = -Wall -O -g

myprog : $(OBJS)

$(CC) $^ -o $@

foo.o : foo.c foo.h bar.h

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

bar.o : bar.c bar.h

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

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

Q：手把手教你如何写Makefile 文件

A：一、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.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

反斜杠（\）是换行符的意思。这样比较便于Makefile的易读。我们可以把这个内容保存在文件为―Makefile‖或―makefile‖的文件中，然后在该目录下直接输入命令―make‖就可以生成执行文件edit。如果要删除执行文件和所有的中间目标文件，那么，只要简单地执行一下―make clean‖就可以了。

在这个makefile中，目标文件（target）包含：执行文件edit和中间目标文件（*.o），依赖文件（prerequisites）就是冒号后面的那些.c 文件和.h文件。每一个.o 文件都有一组依赖文件，而这些.o 文件又是执行文件edit 的依赖文件。依赖关系的实质上就是说明了目标文件是由哪些文件生成的，换言之，目标文件是哪些文件更新的。

在定义好依赖关系后，后续的那一行定义了如何生成目标文件的操作系统命令，一定要以一个Tab键作为开头。记住，make并不管命令是怎么工作的，他只管执行所定义的命令。make 会比较targets文件和prerequ isites文件的修改日期，如果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了。

这就是整个make的依赖性，make会一层又一层地去找文件的依赖关系，直到最终编译出第一个目标文件。在找寻的过程中，如果出现错误，比如最后被依赖的文件找不到，那么make就会直接退出，并报错，而对于所定义的命令的错误，或是编译不成功，make根本不理。make只管文件的依赖性，即，如果在我找了依赖关系之后，冒号后面的文件还是不在，那么对不起，我就不工作啦。

通过上述分析，我们知道，像clean这种，没有被第一个目标文件直接或间接关联，那么它后面所定义的命令将不会被自动执行，不过，我们可以显示要make执行。即命令——―make clean‖，以此来清除所有的目标文件，以便重编译。

于是在我们编程中，如果这个工程已被编译过了，当我们修改了其中一个源文件，比如file.c，那么根据我们的依赖性，我们的目标file.o会被重编译（也就是在这个依性关系后面所定义的命令），于是file.o的文件也是最新的啦，于是file.o的文件修改时间要比edit要新，所以edit也会被重新链接了（详见edit目标文件后定义的命令）。

而如果我们改变了―command.h‖，那么，kdb.o、command.o和files.o都会被重编译，并且，edit会被重链接。

四、makefile中使用变量

在上面的例子中，先让我们看看edit的规则：

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

我们可以看到[.o]文件的字符串被重复了两次，如果我们的工程需要加入一个新的[.o]文件，那么我们需要在两个地方加（应该是三个地方，还有一个地方在clean中）。当然，我们的makefile并不复杂，所以在两个地方加也不累，但如果makefile变得复杂，那么我们就有可能会忘掉一个需要加入的地方，而导致编译失败。所以，为了makefile的易维护，在makefile 中我们可以使用变量。makefile的变量也就是一个字符串，理解成C语言中的宏可能会更好。

比如，我们声明一个变量，叫objects, OBJECTS, objs, OBJS, obj, 或是OBJ，反正不管什么啦，只要能够表示obj文件就行了。我们在makefile一开始就这样定义：

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

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

于是，我们就可以很方便地在我们的makefile中以―$(objects)‖的方式来使用这个变量了，于是我们的改良版makefile就变成下面这个样子：

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 : main.c def

s.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 $(objects)

于是如果有新的.o 文件加入，我们只需简单地修改一下objects 变量就可以了。

关于变量更多的话题，我会在后续给你一一道来。

五、让make自动推导

GNU的make很强大，它可以自动推导文件以及文件依赖关系后面的命令，于是我们就没必要去在每一个[.o]文件后都写上类似的命令，因为，我们的make会自动识别，并自己推导命令。

只要make看到一个[.o]文件，它就会自动的把[.c]文件加在依赖关系中，如果make找到一

个whatever.o，那么whatever.c，就会是whatever.o的依赖文件。并且cc -c whatever.c 也会被推导出来，于是，我们的makefile再也不用写得这么复杂。我们的是新的makefile又出炉了。

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

display.o : defs.h buffer.h

insert.o : defs.h buffer.h

search.o : defs.h buffer.h

files.o : defs.h buffer.h command.h

utils.o : defs.h

.PHONY : clean

clean :

rm edit $(objects)

这种方法，也就是make的―隐晦规则‖。上面文件内容中，―.PHONY‖表示，clean是个伪目标文件。

关于更为详细的―隐晦规则‖和―伪目标文件‖，我会在后续给你一一道来。

六、另类风格的makefile

即然我们的make可以自动推导命令，那么我看到那堆[.o]和[.h]的依赖就有点不爽，那么多的重复的[.h]，能不能把其收拢起来，好吧，没有问题，这个对于make来说很容易，谁叫它提供了自动推导命令和文件的功能呢？来看看最新风格的makefile吧。

objects = main.o kbd.o command.o display.o insert.o search.o files.o utils.o

edit : $(objects)

cc -o edit $(objects)

$(objects) : defs.h

kbd.o command.o files.o : command.h

display.o insert.o search.o files.o : buffer.h

.PHONY : clean

clean :

rm edit $(objects)

这种风格，让我们的makefile变得很简单，但我们的文件依赖关系就显得有点凌乱了。鱼和熊掌不可兼得。还看你的喜好了。我是不喜欢这种风格的，一是文件的依赖关系看不清楚，二是如果文件一多，要加入几个新的.o文件，那就理不清楚了。

七、清空目标文件的规则

每个Makefile中都应该写一个清空目标文件（.o和执行文件）的规则，这不仅便于重编译，也很利于保持文件的清洁。这是一个―修养‖（呵呵，还记得我的《编程修养》吗）。一般的风格都是：

clean:

rm edit $(objects)

更为稳健的做法是：

.PHONY : clean

clean :

-rm edit $(objects)

前面说过，.PHONY意思表示clean是一个―伪目标‖，。而在rm命令前面加了一个小减号的意思就是，也许某些文件出现问题，但不要管，继续做后面的事。当然，clean的规则不要放在文件的开头，不然，这就会变成make的默认目标，相信谁也不愿意这样。不成文的规矩是——―clean从来都是放在文件的最后‖。

上面就是一个makefile的概貌，也是makefile的基础，下面还有很多makefile的相关细节，准备好了吗？准备好了就来。

Makefile文件编写规则--菜鸟学习

Makefile中包含五种内容：显式规则，隐式规则，变量定义，指令（directive）和注释。

1.显式规则――描述如何生成规则的目标，它列出了目标依赖的文件，指定了产生或更新目标的命令。

2.隐式规则――描述如何生成基于文件名的一类文件，说明目标可能依赖于和其文件名类似的文件，指定了相应的命令。

3.指令――类似于编译器的伪指令，包含：指示make读入另一个makefile; 决定是否忽略makefile中的一部分;

4.变量定义－－定义一个变量;

5.注释――一行中?#‘开始是注释，直到行末，除非遇到续行符号。在define和命令中不能有注释，其它情况下注释可出现在任何地方。

Makefile的常见语法规则：

Target ... ：dependencies...

(TAB) Command

(TAB)...

target一般为程序所生成的文件名。例如，是可执行文件名或目标文件名；一个目标也可以是一个将要执行的动作的名称，见下例中的clean。dependencies就是作为输入文件，被用来生成目标文件。一个目标文件可以由好几个输入文件编译而成。

command就是make所执行的动作，可以由好几个命令组成，每个命令独占一行。注意，每个命令行开头必须有一个Tab键，千万不要忘记。

通常，命令是用来编译输入文件以生成目标文件的。当然，命令也可以不需要任何依赖(dependencies)。除了上述语法规则模块，一个makefile文件可能还包含其他内容。

# 注释行

\ 续行符

$ Makefile中允许使用简单的宏指代源文件及其相关编译信息，在Linux中也称宏为变量。在引用宏时只需在变量前加$符号。但值得注意的是，如果变量名的长度超过一个字符，在引用时就必须加圆括号()。

下面都是有效的宏引用：

$(CFLAGS)

$2

$Z

$(Z)

其中最后两个引用是完全一致的。

举例：objects = main.o kbd.o command.o display.o insert.o search.o files.o utils.o ，那么在makefile文件中，可用$(objects)代替上述八个.o文件。

$* 不包含扩展名的目标文件名称。

$+ 所有的依赖文件，以空格分开，并以出现的先后为序，可能包含重复的依赖文件。

$< 第一个依赖文件的名称。

$? 所有依赖文件，以空格分开，这些依赖文件的修改日期比目标文件的创建日期晚。

$@ 目标的完整名称。

$^ 所有的依赖文件，以空格分开，不包含重复的依赖文件。

$% 如果目标是归档成员，则该变量表示目标的归档成员名。

@ 命令如果以"@"起始，则@符号禁止打印输出它所在的命令行

### makefile 结束###

[ ] [ expression ] 相当于test expression。用于shell的逻辑判断。

要注意在[ 的后面和]符号的前面要有一个空格。

expression选项：

-r file用户可读为真

-w file用户可写为真

-x file用户可执行为真

-f file文件为正规文件为真

-d file文件为目录为真

-c file文件为字符特殊文件为真

-b file文件为块特殊文件为真

-s file文件大小非0时为真

-t file当文件描述符(默认为1)指定的设备为终端时为真

条件测试：

-a 与

-o或

!非

exit 0或 exit 1 退出时的返回值主要用来判断程序进行的如何：区别是人为的，你可以自己定义退出值的含义。但是一般用0 表示正常退出，>0 的表示各种含义的异常退出。

& & 使用& &的一般形式为：命令1 && 命令2

只有& &左边的命令（命令1）返回真(即返回0，成功被执行），& &右边的命令（命令2）才能够被执行；换句话说，―如果这个命令执行成功& &那么执行这个命令‖。

举例：[ -f /bin/awk ] && exit 0 如果/bin/awk文件存在，则正常退出。

|| 使用|| 的一般形式为：命令1 || 命令2

如果|| 左边的命令（命令1）未执行成功，那么就执行|| 右边的命令（命令2）；或者换句话说，―如果这个命令执行失败了|| 那么就执行这个命令‖。

举例：[ -f /bin/awk ] || exit 1如果/bin/awk文件不存在，则异常退出。

| f1|f2表示将f1的输出通过管道送至f2作为输入

f1|f2|f3表示将f1的输出作为f2的输入，然后把f2的结果（输出）作为f3的输入，还可以继续将f3的输出定向到某一个文件如: f1|f2|f3>/tmp /file. out

for 循环

For语句的结构如下：

for variable in arg1 arg2 … argn ；

do

command

command

…

done

举例，如果要安装多个程序, 可以通过一个循环来完成：

PROGRAMS=cp ls rm

install:

for p in $(PROGR AMS); do \

$(INSTALL_PROGRAM) $$p $(bindir)/`echo $$p | sed '$(transform)'`; \

done

uninstall:

for p in $(PROGR AMS); do \

rm -f $(bindir)/`echo $$p | sed '$(transform)'`; \

done

说明：

1、p表示从cp ls rm 其中的一个，直到for结束为止。

2、P代表cp ls rm 中的一个。

3、$$p，第二个$表示p所代表的变量的值，在这里是cp ls rm 中的一个。前面的$表示在这个变量的前面加上符号$。

xargs 通过缓冲方式并以前面命令行的输出作为参数，调用随后的命令。它可以使用户对前面命令所匹配到的文件执行几乎所有的系统命令。

举例：-find romfs -name CVS | xargs rm –rf 在romfs目录中查找名字为CVS的文件，并删除之。

If……fi 条件判断，其中fi是用来判断一个if逻辑结构结束的标志。

if - then语句

格式: if command1

then

command2

command3

fi### (if 语句结束) ###

command4

每个程序或命令执行结束后都有一个返回的状态，用户可以用Shell变量$? 获得这一状态。if语句检查前面命令执行的返回状态，若该命令成功执行，那么在then和fi之间的命令都将被执行。在上面的命令序列中，command1和command4总要执行。若command1成功执行,command2和command3也将执行。

跟我一起写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简单实例解析

手动建立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下编写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结束===

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

跟我一起写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 中 $@ $^ % 使用

makefile 中$@ $^ %< 使用 https://www.wendangku.net/doc/fb6819889.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脚本，让她帮我去完成不就可以了。是的对于这个程序来说，是可

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)

怎样使用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）。

如何编写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工程管理器 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 $@

MakeFile编写规则

MakeFile编写规则 什么是makefile (3) 关于程序的编译和链接 (3) Makefile 介绍 (4) 一、Makefile的规则 (4) 二、一个示例 (4) 三、make是如何工作的 (6) 四、makefile中使用变量 (6) 五、让make自动推导 (7) 六、另类风格的makefile (8) 七、清空目标文件的规则 (8) Makefile 总述 (9) 一、Makefile里有什么 (9) 二、Makefile的文件名 (9) 三、引用其它的Makefile (9) 四、环境变量MAKEFILES (10) 五、make的工作方式 (10) 实例说明 (11) 一、简单例子 (11) 二、规则的语法 (11) 三、在规则中使用通配符 (12) 四、文件搜寻 (12) 五、伪目标 (13) 六、多目标 (14) 七、静态模式 (15) 八、自动生成依赖性 (16) 书写命令 (17) 一、显示命令 (17) 二、命令执行 (18) 三、命令出错 (18) 四、嵌套执行make (19) 五、定义命令包 (20) 使用变量 (21) 一、变量的基础 (21) 二、变量的赋值 (21) 第一种方式 (22) 第二种方式 (22) 三、变量高级用法 (23) 一种是变量值的替换 (23) 第二种高级用法——“把变量的值再当成变量” (24) 四、追加变量值 (25) 五、override 指示符 (26) 六、多行变量 (26)

七、环境变量 (26) 八、目标变量 (27) 九、模式变量 (27) 十、自动化变量 (28) 使用条件判断 (30) makefile的编写规则--语法及函数 (31) 条件表达式 (31) 函数 (32) 一、函数的调用语法 (32) 二、字符串处理函数 (33) $(subst ,, ) (33) $(patsubst ,, ) (33) $(strip ) (34) $(findstring , ) (34) $(filter , ) (34) $(filter-out , ) (34) $(sort ) (35) $(word , ) (35) $(wordlist ,, ) (35) $(words ) (35) $(firstword ) (36) 三、文件名操作函数 (36) $(dir ) . (36) $(notdir ) .. (36) $(suffix ) .. (37) $(basename ) .. (37) $(addsuffix , ) (37) $(addprefix , ) .. (37) 其他函数 (37) $(join , ) (37) foreach 函数 (38) if 函数 (38) call函数 (38) origin函数 (39) shell函数 (40) 控制make的函数 (40) $(error ) . (40) $(warning ) . (40) make 的运行 (41) 一、make的退出码 (41) 二、指定Makefile (41) 三、指定目标 (41) 四、检查规则 (42)

实验三 Makefile的编写及应用

闽江学院电子系 实验报告 学生姓名：3142731班级：学号：课程：实时操作系统 一、实验题目：Makefile的编写及应用 二、实验地点：大成楼A210 三、实验目的： 1、了解Makefile的基本概念和基本结构； 2、初步掌握编写简单Makefile的方法； 3、了解递归Make的编译过程； 4、初步掌握应用GNU Make编译应用程序的方法。 四、实验内容： 1、使用命令行的方式手动编译程序的方法； 五、实验环境（使用的软硬件）： 硬件：计算机 软件：Ubuntu Linux 六、实验结果： （1）使用命令行的方式手动编译程序方法 1、利用文本编辑器创建hello.c 文件

2、手动编译hello 应用程序 在hello.c 的目录的终端下输入： #gcc -c hello.c #gcc hello.o -o hello 通过ls 命令查看当前目录下是否生成源代码hello.c 的object 文件hello.o 和可执行文件hello，运行可执行文件hello。查看一下运行结果。 3、修改hello.c 文件，重新手动编译应用程序。

4、删除hello.o 和hello 文件 #rm -f hello.o #rm -f hello (2) 利用GNU make 自动编译应用程序方法 1、利用文本编辑器创建一个Makefile 文件，并将其保存到与hello.c 相同的目录下。 2、先执行如下命令。 #make #ls #./hello 查看并记录所生成的文件和运行的结果。

3、执行make clean 命令： 4、修改hello.c 文件，重复第2、3 步操作，查看并记录所生成的文件和运行结果，并与手动编译进行比较，写出你的结论。 5、重新编辑Makefile 文件（斜黑体表示修改部分）

如何编写makefile文件

目的： 基本掌握了make 的用法，能在Linux系统上编程。 环境： Linux系统，或者有一台Linux服务器，通过终端连接。一句话：有Linux编译环境。准备： 准备三个文件：file1.c, file2.c, file2.h file1.c: #include #include "file2.h" int main() { printf("print file1$$$$$$$$$$$$$$$$$$$$$$$$\n"); File2Print(); return 0; } file2.h: #ifndef FILE2_H_ #define FILE2_H_ #ifdef __cplusplus extern "C" { #endif void File2Print(); #ifdef __cplusplus } #endif #endif file2.c: #include "file2.h" void File2Print() { printf("Print file2**********************\n"); } 基础： 先来个例子： 有这么个Makefile文件。（文件和Makefile在同一目录） === makefile 开始=== helloworld:file1.o file2.o gcc file1.o file2.o -o helloworld file1.o:file1.c file2.h gcc -c file1.c -o file1.o

file2.o:file2.c file2.h gcc -c file2.c -o file2.o clean: rm -rf *.o helloworld === makefile 结束=== 一个makefile 主要含有一系列的规则，如下： A: B (tab) (tab) 每个命令行前都必须有tab符号。 上面的makefile文件目的就是要编译一个helloworld的可执行文件。让我们一句一句来解释：helloworld : file1.o file2.o：helloworld依赖file1.o file2.o两个目标文件。 gcc File1.o File2.o -o helloworld：编译出helloworld可执行文件。-o表示你指定的目标文件名。file1.o : file1.c：file1.o依赖file1.c文件。 gcc -c file1.c -o file1.o：编译出file1.o文件。-c表示gcc 只把给它的文件编译成目标文件，用源码文件的文件名命名但把其后缀由“.c”或“.cc”变成“.o”。在这句中，可以省略-o file1.o，编译器默认生成file1.o文件，这就是-c的作用。 file2.o : file2.c file2.h gcc -c file2.c -o file2.o 这两句和上两句相同。 clean: rm -rf *.o helloworld 当用户键入make clean命令时，会删除*.o 和helloworld文件。 如果要编译cpp文件，只要把gcc改成g++就行了。 写好Makefile文件，在命令行中直接键入make命令，就会执行Makefile中的内容了。 到这步我想你能编一个Helloworld程序了。 上一层楼：使用变量 上面提到一句，如果要编译cpp文件，只要把gcc改成g++就行了。但如果Makefile中有很多gcc，那不就很麻烦了。 第二个例子： === makefile 开始=== OBJS = file1.o file2.o CC = gcc CFLAGS = -Wall -O -g helloworld : $(OBJS) $(CC) $(OBJS) -o helloworld file1.o : file1.c file2.h

linux下makefile文件的编写

linux下Makefile文件的编写- 红联Linux门户- 中国领先 的Linux技... linux下Makefile文件的编写victorywylbc发布于 2009-7-30 | 951次阅读字号: 大中小(网友评论7 条) 我要评论开始使用Linux编程时，一个很讨厌的问题就是如何写Makefile文件，由于在Linux下 不像在Windows下那么熟悉，有那么多好的软件（也许是对Linux孤陋寡闻了）。虽然 象Kylix和Anjuta这样的集成编译环境，但是Kylix太大太慢，用它编写console程序 不亚于高射炮打蚊子——大材小用，而Anjuta又太不稳定，况且字体有那么难看。不 说了，还是言归正传，看看Makefile该如何编写。1. 简单的GCC语法：如果你只有一个文件（或者只有几个文件），那么就可以不写Makefile文件（当然有 Makefile更加方便），用gcc直接编译就行了。在这里我们只介绍几个我经常用的几 个参数，第一是“-o”，它后面的参数表示要输出的目标文件，再一个是“-c”， 表示仅编译（Compile），不连接（Make），如果没有

”-c”参数，那么就表示连接 ，如下面的几个命令：gcc –c test.c，表示只编译test.c 文件，成功时输出目标文件test.ogcc –c test.c –o test.o ，与上一条命令完全相同gcc –o test test.o，将test.o连接成可执行的二进制文件testgcc –o test test.c，将test.c编译并连接成可执行的二进制文件testgcc test.c –o test，与上一条命令相同gcc –c test1.c，只编译test1.c，成功时输出目标文件test1.ogcc –c test2.c，只编译test2.c，成功时输出目标文件test2.ogcc –o test test1.o test2.o，将 test1.o和test2.o连接为可执行的二进制文件testgcc –c test test1.c test2.c，将test1.o和test2.o编译并连接为可执行的二进制 文件test注：如果你想编译cpp文件，那么请用g++，否则会有类似如下莫名其妙的错误： cc3r3i2U.o(.eh_frame+0x12): undefined reference to `__gxx_personality_v0’ ......还有一个参数是”-l”参数，与之紧紧相连的是表示连接时所要的链接库，比如多线 程，如果你使用了pthread_create函数，那么你就应该在编译语句的最后加上”-lpthread ”，”-l”表示连接，

MAKEFILE的编写

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都成为了一种在工程方面的编译方法。 make命令执行时，需要一个Makefile 文件，以告诉make命令需要怎么样的去编译和链接程序。 首先，我们用一个示例来说明Makefile的书写规则。以便给大家一个感兴认识。这个示例来源于GNU的make使用手册，在这个示例中，我们的工程有8个C文件，和3个头文件，我们要写一个Makefile来告诉make命令如何编译和链接这几个文件。我们的规则是：1）如果这个工程没有编译过，那么我们的所有C文件都要编译并被链接。 2）如果这个工程的某几个C文件被修改，那么我们只编译被修改的C文件，并链接目标程序。 3）如果这个工程的头文件被改变了，那么我们需要编译引用了这几个头文件的C文件，并链接目标程序。 只要我们的Makefile写得够好，所有的这一切，我们只用一个make命令就可以完成，make 命令会自动智能地根据当前的文件修改的情况来确定哪些文件需要重编译，从而自己编译所需要的文件和链接目标程序。 以下各章我们将以实际例子详细介绍各类Makefile文件的书写规则。 第二章一个简单的C语言Makefile 红色字体为makefile文件本身，黑色字体为解释。 .SUFFIXES:.ec 用伪目标SUFFIXES来让make知道特定的后缀.ec。后缀规则是一个比较老式的定义隐含规则的方法。后缀规则中，如果没有命令，那是毫无意义的。因为他也不会移去内建的隐含规