吐血共享我收集并总结后的makefile的编写规则级方法
linux makefile编写规则
linux makefile编写规则（原创实用版）目录一、Makefile 简介二、Makefile 的规则1.目标文件2.依赖文件3.命令三、Makefile 中的变量1.通用变量2.局部变量四、Makefile 中的路径1.源文件路径2.目标文件路径3.库文件路径五、Makefile 编写实例六、总结正文一、Makefile 简介Makefile 是一个用于自动化构建和编译软件的脚本文件，通常在Linux 系统中使用。
它可以帮助开发者管理源代码，以及确定哪些文件需要编译，如何编译，以及编译后的文件如何链接。
通过编写 Makefile，开发者可以轻松地构建和维护复杂的软件项目。
Makefile 主要包括三类规则：目标文件、依赖文件和命令。
1.目标文件目标文件是 Makefile 中要生成的文件，可以是对象文件、库文件或执行文件。
在 Makefile 中，目标文件通常以“target”关键字开头，后面跟要生成的文件名。
例如：“target = main.o”。
2.依赖文件依赖文件是 Makefile 中要生成目标文件所需要的其他文件，通常是源代码文件。
在 Makefile 中，依赖文件通常以“prerequisites”关键字开头，后面跟要依赖的文件名。
例如：“prerequisites = a.c b.c”。
3.命令命令是用来生成目标文件的命令，通常是编译器或链接器。
在Makefile 中，命令通常以“command”关键字开头，后面跟要执行的命令。
例如：“command = gcc -o main.o a.c b.c”。
三、Makefile 中的变量Makefile 中的变量可以用于存储常量值，以便在 Makefile 中多次使用。
变量分为通用变量和局部变量。
1.通用变量通用变量是在整个 Makefile 中都可以使用的变量。
通用变量通常在Makefile 的开头定义，使用“define”关键字。
c语言makefile编写规则(一)
c语言makefile编写规则(一)C语言Makefile编写规则1. Makefile介绍Makefile是一种文件，其中包含了一组规则（rules）用于编译和构建项目。
它的作用是告诉系统如何编译代码，生成可执行文件。
2. Makefile规则基本结构Makefile规则由以下几部分组成：目标（Target）目标是一个文件，可以是源代码文件、中间文件或最终生成的可执行文件。
依赖（Dependencies）依赖指的是生成目标所需要的文件或其他目标。
当某个依赖文件发生变化时，目标就需要重新生成。
命令（Commands）命令是指执行编译、链接等操作的具体命令。
当目标需要重新生成时，Makefile会执行相应的命令。
规则示例以下是一个简单的示例，展示了一个C语言源文件的编译过程：target: dependenciescommand其中， - target表示目标文件； - dependencies表示生成目标所需要的文件或其他目标； - command表示具体的编译命令。
例如，假设有一个名为`的C语言源文件，我们想要生成一个名为hello`的可执行文件。
那么对应的Makefile规则可以定义如下：hello:gcc -o hello3. Makefile变量Makefile中还可以定义变量，以提高代码的可读性和重用性。
变量可以存储命令、文件名、路径等信息。
变量定义变量的定义采用变量名 = 值的方式进行，例如：CC = gcc其中，CC是变量名，gcc是变量的值。
变量引用使用变量时，需要在变量名前加$符号进行引用。
例如，使用上述定义的CC变量可以这样写：$(CC) -o hello4. Makefile示例以下是一个完整的Makefile示例，展示了多个目标之间的依赖关系和命令定义：CC = gccall: hellohello:$(CC) -o hello:$(CC) -cclean:rm -f hello在上述示例中，共定义了3个目标：all、hello和。
makefile编写规则
makefile编写规则⼀、makefile 规则：⼀般开头都是 Tab ，不能空格， include 前⾯不能是 Tab； 1、如果没编译过，将所有的（.c）⽂件编译并且链接； 2、如果有其中的（.c）⽂件改变，编译并链接改变的⽂件； 3、如果（.h）⽂件被修改，编译引⽤相应的（.c）⽂件, 链接； 4、在随意修改时间的情况下，会导致编译过程中⽣成的（.o 中间⽂件）与可执⾏⽂件时间不⼀致，此时会编译相应的⽂件，并链接，最终编译成可执⾏⽂件；⼆、第⼀版 makefile： 例如有2个 .h ⽂件（utils.h, player.h, actor.h）和 3个 .c ⽂件( main.c, player.c, actor.c)需要编译链接：/*****main.c*********/#include "utils.h"#include "player.h"void main() {// do something}/*******player.c**********/#include "utils.h"#include "actor.h"bool create_player() {// do something}/****actor.c************/#include "utils.h"bool create_actor() {// do something}/********* makefile *****************/test : main.o actor.occ -o test main.o actor.omain.o : main.c utils.h player.h actor.hcc -c main.cpalyer.o: player.c player.h actor.h utils.hcc -c player.cactor.o: actor.h utils.hcc -c actor.cclean:rm test ain.o player.o actor.o 优点：可毒性很强，思路清晰明了； 缺点：⿇烦，重复的依赖过多，当需要编译⼤量⽂件时容易出错；第⼆版：利⽤ makefile 的变量；/********* makefile *****************/OBJ = main.o actor.o // 跟第⼀版⽐较，唯⼀的区别在这test : $(OBJ) // 这⼉cc -o test $(OBJ) // 这⼉main.o : main.c utils.h player.h actor.hcc -c main.cpalyer.o: player.c player.h actor.h utils.hcc -c player.cactor.o: actor.h utils.hcc -c actor.c .PHONY : clean // 伪⽬标，避免：如果当前⽬录下存在 clean rm 指令不执⾏clean:-rm test $(OBJ) // 前⾯的（-）表⽰，执⾏过程中不 care 出错；第三版：利⽤ GUN make 的⾃动推导规则 当 make 看到（.o ）⽂件，他会⾃动把（.c）⽂件加上依赖关系，包括执⾏的语句（cc -c xx.c）;/********* makefile *****************/OBJ = main.o actor.o // 跟第⼀版⽐较，唯⼀的区别在这test : $(OBJ) // 这⼉cc -o test $(OBJ) // 这⼉main.o : utils.h player.h actor.hpalyer.o: player.h actor.h utils.hactor.o: actor.h utils.h .PHONY : clean // 伪⽬标，避免：如果当前⽬录下存在 clean rm 指令不执⾏clean:-rm test $(OBJ)第四版：对第三版的整理（有⼀些重复的 .h） 公共的⼀起依赖，单独的单独依赖/********* makefile *****************/OBJ = main.o actor.o // 跟第⼀版⽐较，唯⼀的区别在这test : $(OBJ) // 这⼉cc -o test $(OBJ) // 这⼉$(OBJ) : utils.h actor.omain.o player.o .PHONY : clean // 伪⽬标，避免：如果当前⽬录下存在 clean rm 指令不执⾏clean:-rm test $(OBJ)优点：简洁缺点：不好理解以上的makefike⽂件的基本写法；或许你也发现了，如果有⼏百个源⽂件咋整呢，光是⽬录就要晕死，下⾯就是针对这种情况来说⼀下⼤型⼯程 makefile 的编写设计⼆、⼤型项⽬makefile编写： Makefile 同样也有像 c / c++ 类似的include功能； 例如我们有⼀堆 a.mk , b.mk以及 foo.make和⼀个变量 $（bar），其包含了 e.mk,f.mk, 那么 include foo.make *.mk $(bar) ------- 等价-------》 include foo.make a.mk b.mk e.mk f.mk。
makefile编写规则 ifeq
makefile编写规则 ifeq什么是makefile？makefile是一种用于自动化构建程序的工具，它能够根据文件之间的依赖关系，自动决定哪些文件需要重新编译。
makefile由一系列规则组成，每个规则定义了如何生成一个或多个目标文件。
make命令会根据这些规则来执行相应的操作，从而实现自动化构建的功能。
ifeq规则的作用在makefile中，ifeq是一种条件语句，用于判断某个条件是否为真。
它的基本语法如下：ifeq (condition, value)# 条件为真时执行的操作else# 条件为假时执行的操作endifcondition是一个条件表达式，可以使用各种比较运算符来进行比较。
value是一个字符串，用于与condition进行比较。
如果condition和value相等，则条件为真，执行ifeq后面的操作；否则条件为假，执行else后面的操作。
ifeq规则的使用场景ifeq规则在makefile中的使用场景很多，下面列举了几个常见的用法：1. 根据不同的操作系统执行不同的操作在跨平台开发中，可能需要根据不同的操作系统执行不同的操作。
可以使用ifeq 规则来判断当前的操作系统，然后执行相应的操作。
ifeq ($(OS),Windows_NT)# Windows系统下的操作CC = clelse# 非Windows系统下的操作CC = gccendif上面的示例中，如果当前操作系统是Windows，则将CC变量设置为cl；否则，将CC变量设置为gcc。
2. 根据变量的值执行不同的操作有时候需要根据某个变量的值来执行不同的操作。
可以使用ifeq规则来判断变量的值，然后执行相应的操作。
ifeq ($(DEBUG),1)# 调试模式下的操作CFLAGS = -gelse# 非调试模式下的操作CFLAGS =endif上面的示例中，如果DEBUG变量的值为1，则将CFLAGS变量设置为-g；否则，将CFLAGS变量设置为空。
[转]makefile文件的编写规则及实例
![[转]makefile文件的编写规则及实例](https://img.taocdn.com/s3/m/b6cc746d0a1c59eef8c75fbfc77da26925c596a1.png)
[转]makefile⽂件的编写规则及实例1.⼀个简单的makefile例⼦假设⼀个程序有两个⽂件file1.c,file2.c,每个⽂件都包含head.h,⽣成file可执⾏⽂件file:file1.o file2.o 附属⾏(⽂件的依存关系)gcc -o file1.o file2.o 命令⾏file1.o:file1.c head.hgcc -c file1.cfile2.o:file2.c head.hgcc -c file2.c从file最终的⽬标⽂件开始倒推,依次列出⽂件的依存关系,make在执⾏时:(1)判断file可执⾏⽂件是否存在,若不存在,则执⾏命令⾏,向下寻找依存关系(2)若file存在,则检查依靠⽂件,是否存在更新,若存在更新则执⾏命令⾏,若没有更新则给出提⽰:make:'file' is up to date.2.makefile中的宏定义及内部变量宏定义:OBJS = file1.o file2.oCC = gccCFLAGS = -wall -O -g引⽤:file:$(OBJS)$(CC) $(OBJS) -o filefile1.o:file1.c head.h$(CC) $(FLAGS) -c file1.cfile2.o:file2.c head.h$(CC) $(FLAGS) -c file2.c内部变量:$@:当前规则的⽬的⽂件名$<:依靠列表中的第⼀个依靠⽂件$^:整个依靠列表file:$(OBJS)$(CC) $^ -o $@file1.o:file1.c head.h$(CC) $(FLAGS) -c $< -o $@file2.o:file2.c head.h$(CC) $(FLAGS) -c $< -o $@"$(CC) $(FLAGS) -c $< -o $@"是隐含规则,可以不写,默认使⽤此规则3.假象假设⼀个项⽬要⽣成两个可执⾏⽂件file1和file2,这两个⽂件是相与独⽴的,则在makefile开始处:all:file1 file2make总是假设all要⽣成,去检查它的依赖⽂件4.清除由make产⽣的⽂件clean:rm *.orm file执⾏:make clean则会清除由make⽣成的*.o和file⽂件如果有clean⽂件存在,则清除不会执⾏(因clean没有可依赖的⽂件,永远是最新的)使⽤PHONY⽬标,避免同名⽂件相冲突,不会检查clean⽂件存在与否,都要执⾏清除操作.PHONY : cleanclean:rm *.orm file5.makefile函数搜索当前⽬录,⽣成由*.c结尾的⽂件列表,wildcard--函数名SOURCE = $(wildcard *.c)⽤%.o替换$(SOURCE)中的%.c⽂件OBJS = $(patsubst %.c,%.O,$(SOURCE))6.产⽣新规则SOURCE = $(wildcard *.c)depends:$(SOURCE)gcc -M $(SOURCE) > depends(为每⼀个.c⽂件产⽣规则,c⽂件和相关头⽂件为依靠)在makefile⽂件中:include depends7.⼀个有效的makefile⽂件可以完成⼤部分我们所需要的依靠检查,不⽤做太多的修改就可⽤在⼤多数项⽬⾥功能:搜索当前⽬录,寻找源码⽂件,放⼊SOURCE变量⾥,利⽤patsubst产⽣⽬标⽂件(*.o)CC = gccCFLAGS = -Wall -O -gSOURCE = $(wildcard *.c,*.cc)OBJS = $(patsubst %.c,%.o,$(patsubst,%.cc,%.o,$(SOURCE)))file:$(OBJS)$(CC) $^ -o $@⽤默认规则产⽣⽬标⽂件(*.o)1：编译可执⾏程序。
makefile的编写
makefile的编写Makefile是一种文本文件，它描述了如何编译和链接源文件来构建程序。
它包含规则、变量和命令，用于指示编译器怎样工作。
Makefile通常用于编译大型项目，以确保能够快速构建和生成目标文件。
下面我们将分步骤阐述如何编写一个Makefile。
第一步：定义变量在编写Makefile时，我们首先需要定义变量。
变量可以用于存储文件名、目录名、选项、标志等信息。
在Makefile中，为了提高可读性和可维护性，最好把常量值都定义成变量。
变量的定义格式为：变量名=变量值。
例如：```CC = g++CFLAGS = -Wall -O2```上述代码中，CC变量定义为编译器g++，CFLAGS变量定义为编译选项-Wall -O2。
这样，我们在Makefile中就可以直接使用这些变量，而不用每次都输入完整的命令。
第二步：编写规则Makefile中的规则描述了如何生成目标文件。
一般来说，每一条规则包含两部分：目标（target）和依赖关系（dependencies）。
目标是指要生成的文件，依赖关系是指这个文件所依赖的其他文件。
规则的格式为：```target: dependenciescommands```例如：main: main.cpp func.cpp$(CC) $(CFLAGS) -o main main.cpp func.cpp```这条规则表示将main.cpp和func.cpp编译成可执行文件main。
当我们使用make命令时，Makefile会检查main.cpp和func.cpp是否有修改，如果有修改，则重新编译目标文件main。
第三步：定义伪目标伪目标（phony target）用于定义一些没有实际文件对应的操作，例如清理、安装等。
伪目标的语法格式为：```.PHONY: target```例如：```.PHONY: cleanclean:rm -f *.o main```这个规则定义了一个名为clean的伪目标，用于删除所有的目标文件和可执行文件。
Makefile
MakefileMake的基本规则：Target [属性] 分隔符 [依赖文件] [;命令行 ]{Tab 命令行}注：命令行间可以加入任意多个空行，但空行也要以tab开头。
Cat –v -t -e Makefile会使Makefile文件中tab以^]显示，行尾以$显示。
注：命令过长，用\来连接多行成一行。
注释以#开头，如果#要用作字符符号，―#‖。
分隔符：：：目标有多个规则。
哪条规则中的依赖文件比目标新，执行哪条规则。
如果多条规则的依赖文件都比目标新，多条规则都执行。
由于后面的规则可能覆盖前面规则的执行结构，所以规则顺序不同，执行结构也不同。
：^把本规则依赖文件和目标文件已有的依赖文件合起来，生成目标新的依赖文件列表。
：-清除目标已有依赖文件，把本规则依赖文件作为目标依赖文件列表。
：！对每个更新过的依赖文件都执行一次命令菜单。
：|内部规则专用。
如：file.o ：file.cfile.o ：^ filef.c现依赖文件为file.c filef.cfile.o ：- filef.c现依赖文件为 filef.c令行属性：- 若本命令的执行错误，忽略掉，继续向下执行。
（不加该标志，make会停止）+ 始终执行本命令，即使make参数使用了-n-q-t。
（前提是本规则中依赖文件新与目标文件，命令行需要执行）@ 本命令行不在标准输出显示。
Target属性：指定多个目标文件属性：属性属性…… ：目标目标……规则中指定单个目标属性：目标属性：[依赖文件] ……·IGNORE 类似与命令行属性-·SILENT 类似与命令行属性@·PRECIOUS 保留中间文件·LIBRARY 目标是一个库。
如果make发现目标是lib(member)或lib((entry))形式，会自动给名为lib的目标加上该属性。
·LIBRARYM 目标是库的一个成员。
如果make发现目标是lib（member）形式，会自动给lib目标加上·LIBRARY，被member目标加上·LIBRARYM。
c语言makefile编写规则
c语言makefile编写规则C语言Makefile编写规则什么是MakefileMakefile是一种用于管理和构建软件项目的文件，通常被用于编译和链接C语言程序。
Makefile中包含了一系列的规则和指令，用于告诉编译器如何编译程序中的各个部分，并最终生成可执行文件。
Makefile的基本结构Makefile的基本结构由多个规则组成，每个规则由一个目标（target）和一个或多个依赖（dependencies）组成。
目标指明了要生成的文件或要执行的操作，依赖指明了目标所依赖的文件或操作。
一个简单的Makefile规则的语法如下：target: dependenciescommand其中，target是生成的文件或要执行的操作，dependencies是目标所依赖的文件或操作，command是执行的命令。
每个规则的命令必须以一个tab键开始。
Makefile的应用场景Makefile广泛应用于C语言项目的构建中，它可以自动化执行编译、链接和清理等操作。
通过Makefile，我们可以方便地管理源代码文件、头文件和库文件之间的关系，从而提高项目的可维护性和可扩展性。
Makefile的编写规则1.目标和依赖应该使用合适的命名方式，能够清晰地表达其作用以及所依赖的内容。
避免使用中文、空格和特殊字符，使用下划线和英文字母进行命名。
2.命令行命令应该以tab键开始，而不是空格。
这是Makefile的语法要求，且使用tab键可以提高代码的可读性。
3.注意规则的顺序，确保前置依赖在目标之前。
Makefile会按照规则的声明顺序进行构建，如果前置依赖在目标之后，可能导致构建失败。
4.使用变量来定义重复使用的内容，如编译器选项、源文件列表等。
这样可以提高代码的可维护性，并方便进行后续的修改和维护。
5.使用通配符来表示一类文件，如使用*.c表示所有的C语言源文件，使用$(wildcard pattern)函数来获取符合某种模式的文件列表。
makefile 中文手册 第四章 _ Makefile的规则
第四章：Makefile的规则本章我们将讨论Makefile的一个重要内容，规则。
熟悉规则对于书写Makefile至关重要。
Makefile中，规则描述了在何种情况下使用什么命令来重建一个特定的文件，此文件被称为规则“目标”（通常规则中的目标只有一个）。
规则中出目标之外的罗列的其它文件称为“目标”的依赖，而规则的命令是用来更新或者创建此规则的目标。
除了makefile的“终极目标”所在的规则以外，其它规则的顺序在makefile文件中没有意义。
“终极目标”就是当没有使用make 命令行指定具体目标时，make默认的更新的哪一个目标。
它是makefile文件中第一个规则的目标。
如果在makefile中第一个规则有多个目标的话，那么多个目标中的第一个将会被作为make的“终极目标”。
有两种情况的例外：1. 目标名以点号“.”开始的并且其后不存在斜线“/”（“./”被认为是当前目录；“../”被认为是上一级目录）；2. 模式规则的目标。
当这两种目标所在的规则是Makefile的第一个规则时，它们并不会被作为“终极目标”。
“终极目标”是执行make的唯一目的，其所在的规则作为第一个被执行的规则。
而其它的规则是在完成重建“终极目标”的过程中被连带出来的。
所以这些目标所在规则在Makefile中的顺序无关紧要。
因此，我们书写的makefile的第一个规则应该就是重建整个程序或者多个程序的依赖关系和执行命令的描述。
4.1 一个例子我们来看一个规则的例子：foo.o : foo.c defs.h # module for twiddling the frobscc -c -g foo.c这是一个典型的规则。
看到这个例子，大家应该能够说出这个规则的各个部分之间的关系。
不过我们还是要把这个例子拿出来讨论。
目的是让我们更加明确地理解Makefile的规则。
本例第一行中，文件“foo.o”是规则需要重建的文件，而“foo.c”和“defs.h”是重建“foo.o”所要使用的文件。
Makefile编写规则（三）条件判断和伪目标
Makefile编写规则（三）条件判断和伪⽬标Makefile编写规则（三）条件判断和伪⽬标Makefile条件判断使⽤ Makefile 编译⽂件时，可能会遇到需要分条件执⾏的情况，⽐如在⼀个⼯程⽂件中，可编译的源⽂件很多，但是它们的类型是不相同的，所以编译⽂件使⽤的编译器也是不同的。
⼿动编译去操作⽂件显然是不可⾏的（每个⽂件编译时需要注意的事项很多），所以 make 为我们提供了条件判断来解决这样的问题。
条件语句可以根据⼀个变量的值来控制 make 执⾏或者时忽略 Makefile 的特定部分，条件语句可以是两个不同的变量或者是常量和变量之间的⽐较。
注意：条件语句只能⽤于控制 make 实际执⾏的 Makefile ⽂件部分，不能控制规则的 shell 命令执⾏的过程。
下⾯是条件判断中使⽤到的⼀些关键字：关键字功能ifeq判断参数是否不相等，相等为 true，不相等为 false。
ifneq判断参数是否不相等，不相等为 true，相等为 false。
ifdef判断是否有值，有值为 true，没有值为 false。
ifndef判断是否有值，没有值为 true，有值为 false1）ideq和ifneq条件判断的使⽤⽅式如下：ifeq (ARG1, ARG2)ifeq 'ARG1' 'ARG2'ifeq "ARG1" "ARG2"ifeq "ARG1" 'ARG2'ifeq 'ARG1' "ARG2"实例：libs_for_gcc= -lgnunormal_libs=foo:$(objects)ifeq($(CC),gcc)$(CC) -o foo $(objects) $(libs_for_gcc)else$(CC) -o foo $(objects) $(noemal_libs)endif条件语句中使⽤到三个关键字“ifeq”、“else”、“endif”。
makefile编译规则
makefile编译规则Makefile编译规则一、引言在软件开发过程中，编译是将源代码转化为可执行文件或者库文件的重要步骤。
为了简化编译过程，提高开发效率，我们可以使用Makefile来管理和自动化编译过程。
Makefile是一个文本文件，其中包含一系列的规则，用于描述源文件之间的依赖关系和编译操作。
二、Makefile基本语法1. 目标(T arget)Makefile中的目标是指我们希望生成的文件，可以是可执行文件、库文件或者中间文件等。
目标一般以文件名表示，可以包含路径信息。
2. 依赖(Prerequisites)依赖是指目标生成所依赖的文件或者其他目标。
当依赖文件发生变化时，Make会自动重新编译相关的目标。
3. 规则(Rule)规则是Makefile中最重要的部分，用于描述目标和依赖之间的关系，以及如何生成目标文件。
规则的基本语法如下：```target: prerequisitescommand```其中，target表示目标文件，prerequisites表示依赖文件或者其他目标，command表示生成目标文件的命令。
4. 变量(Variable)Makefile中的变量用于存储和传递数据，可以是字符串、路径、命令等。
变量的定义使用“=”或者“:=”，例如：```CC = gccCFLAGS = -Wall -O2```变量的使用使用“$”符号，例如：```$(CC) $(CFLAGS) -o target source.c```5. 通配符(Wildcard)通配符可以帮助我们查找符合某种模式的文件，常用的通配符包括“*”和“?”。
例如，我们可以使用以下命令查找所有的.c文件：```sources = $(wildcard *.c)```6. 函数(Function)函数是Makefile中的一个重要概念，可以帮助我们处理字符串、路径和文件等。
常用的函数包括：- $(patsubst pattern,replacement,text)：将文本中符合模式pattern的部分替换为replacement；- $(shell command)：执行shell命令，并返回结果；- $(dir names)：返回文件路径部分；- $(notdir names)：返回文件名部分；- $(basename names)：返回文件名去除后缀部分；- $(suffix names)：返回文件后缀部分。
makefile语法规则
makefile语法规则Makefile是一种文本文件，它用来定义一组规则来指明编译软件项目所需要完成的步骤。
它也是构建、编译以及安装一个软件项目必不可少的一部分。
Makefile可以帮助开发者，其中一项重要的原因是它可以在编译软件时降低开发者的工作量，使其能够更快更轻松地解决编译软件的问题。
Makefile语法规则可以分为两类：基本语法规则和特殊语法规则。
基本语法规则涉及Makefile文件中每行需要遵守的语法，而特殊语法规则涉及到Makefile中使用的自定义变量或函数。
下面将详细介绍这两类规则。
1.本语法规则基本语法规则是Makefile文件核心的部分，其定义了文件每一行的正确格式。
下面我们将介绍几条基本语法规则：a)Makefile文件中，每行以冒号开头的一行代表一条规则，并且冒号前面必须是一个有效的标识符，比如变量名或是函数名。
b) Makefile文件中，每行以Tab键开头的一行代表一个操作，这个操作会被执行以完成一个特定的任务c)有以#开头的行都会被忽略，因为它表示一行注释，用来解释Makefile语句的内容d)Makefile文件中，变量与函数的定义必须放在Makefile文件的开头，才能在 Makefile件内部使用它们e)一行末尾需要加上一个分号，这样才能表达出每条规则被终止的意思，以避免 Makefile现错误2.特殊语法规则特殊语法规则涉及到 Makefile件中使用的自定义变量或是函数。
该规则是用来控制 Makefile件中定义的任务如何被执行。
a)量：变量是一种使用字符来代表值的方法，变量使用美元符号($)来表示。
它可以被声明在 Makefile文件的开头，也可以在Makefile件的某一行中使用。
b)数：函数是一种在 Makefile件中独立运行的代码块，它可以接受参数，并且返回一个字符串或者一组字符串。
使用函数有助于提高 Makefile件的整体性和可维护性，并且可以多次使用，以减少重复的工作。
make使用方法以及makefile的编写
make使用方法以及makefile的编写make是一个常用的构建工具，通过解析Makefile文件来完成代码的编译、链接和打包等操作。
下面是make的使用方法以及Makefile的编写方法：使用方法：1. 创建一个名为Makefile的文件，并在该文件中定义编译规则。
2. 在命令行中进入到Makefile所在的目录。
3. 执行make命令即可开始编译。
4. make根据Makefile文件中的规则来判断哪些文件需要重新编译，然后执行相应的编译命令。
Makefile的编写：1. 编写规则格式如下：target: dependencies<tab> command其中，target是规则的目标文件，dependencies是依赖的文件，command 是执行的命令。
2. 使用变量来简化编写过程，例如：CC=gccCFLAGS=-Walltarget: dependencies(CC) (CFLAGS) -o target source.c这里的CC是编译器，CFLAGS是编译选项。
3. 使用通配符（如"%"）来表示一组文件或者目录，例如：objects := (patsubst %.c, %.o, (wildcard *.c))target: (objects)(CC) (CFLAGS) -o target (objects)这里使用wildcard获取所有的.c文件，然后使用patsubst将.c替换为.o。
4. 可以定义伪目标（phony target）来执行一些特殊的命令，例如：.PHONY: cleanclean:rm -f target (objects)这里的clean是一个伪目标，rm命令会删除目标文件以及所有的依赖文件。
5. 可以使用条件语句来根据不同的条件执行不同的命令，例如：ifdef DEBUGCFLAGS += -gendiftarget: dependencies(CC) (CFLAGS) -o target source.c这里的ifdef DEBUG表示只有在定义了DEBUG宏的情况下才启用-g（调试）选项。
makefile的规则和编写方法
makefile的规则和编写方法Makefile是一种文本文件，它包含了一系列规则和命令，用于描述源代码的编译和构建过程。
Makefile的规则和编写方法对于项目的管理和维护非常重要。
下面是关于Makefile规则和编写方法的一些要点：1. 目标（Targets）：每个Makefile中都应该定义一个或多个目标。
目标通常代表项目中的某个文件、可执行程序或者一个任务。
在Makefile中，目标的名称应该在冒号（:）后面给出，并且每个目标都应该独占一行。
2. 依赖（Dependencies）：在Makefile中，每个目标通常都会依赖于其他文件或目标。
依赖关系表示了一个文件或目标的生成所依赖的其他文件或目标。
依赖关系可以使用冒号（:）来表示，冒号前是目标名称，冒号后是该目标所依赖的文件或目标。
3. 命令（Commands）：在Makefile中，每个目标都需要定义一个或多个命令，用于生成该目标所描述的文件或任务。
每个命令需要以制表符（Tab）开头，紧随其后的是具体的操作指令，如编译命令、链接命令等。
命令之间可以使用换行符进行分隔。
4. 变量（Variables）：在Makefile中，可以使用变量来存储常用的数值、目录路径或者编译器选项等信息。
变量可以使用等号（=）或冒号等号（:=）进行赋值。
通过使用变量，可以大大简化Makefile的编写和维护过程。
5. 注释（Comments）：注释用于解释Makefile中的规则和命令，以提高代码的可读性。
在Makefile 中，可以使用井号（#）表示注释，井号后的内容会被忽略。
编写一个简单的Makefile示例：```# 定义变量CC = gccCFLAGS = -Wall -O2# 定义目标和依赖关系myprogram: main.o func1.o func2.o$(CC) $(CFLAGS) -o myprogram main.o func1.o func2.o# 生成目标的命令main.o: main.c$(CC) $(CFLAGS) -c main.cfunc1.o: func1.c$(CC) $(CFLAGS) -c func1.cfunc2.o: func2.c$(CC) $(CFLAGS) -c func2.c# 清理目标文件的命令clean:rm -f *.o myprogram```以上是一个简单的Makefile示例。
makefile编写规则 ifeq
makefile编写规则 ifeq【实用版】目录1.Makefile 简介2.Makefile 编写规则3.ifeq 函数的作用4.ifeq 函数的语法5.ifeq 函数的实例6.结论正文1.Makefile 简介Makefile 是一种用于自动化构建和编译软件的脚本文件。
它通常包含一系列的规则，用于指定如何构建和编译源代码。
Makefile 的主要目的是为了简化和自动化构建过程，以便开发者能够更专注于编写代码。
2.Makefile 编写规则在 Makefile 中，编写规则通常遵循以下格式：```目标：依赖文件t命令```其中，目标表示要构建的文件，依赖文件表示构建目标所需的输入文件，命令表示用于构建目标的命令。
例如，要编译一个名为“main.c”的源文件，可以编写如下规则：```main.o: main.ctgcc -c main.c```3.ifeq 函数的作用ifeq 函数是 Makefile 中的一种条件函数，用于根据某个条件决定是否执行相应的命令。
它可以帮助开发者根据不同的环境或配置选择性地执行代码。
4.ifeq 函数的语法ifeq 函数的语法如下：```ifeq (条件)ttrue-casetfalse-caseelsetelse-caseendif```其中，条件是一个逻辑表达式，true-case 和 false-case 分别表示条件为真和假时执行的命令。
else-case 是可选的，用于表示条件不满足时执行的命令。
5.ifeq 函数的实例假设我们希望根据不同的操作系统选择不同的编译器选项，可以编写如下 Makefile 规则：```%.o: %.ctifeq ($(OS), Linux)ttgcc -o $@ $< -std=gnu99telsettgcc -o $@ $< -std=ansitendif```在这个例子中，我们使用 ifeq 函数根据当前操作系统（$(OS)）选择不同的编译器选项。
Makefile 编写详解
Makefile 编写详解I 概述Makefile 介绍一、Makefile的规则二、一个示例三、make是如何工作的四、makefile中使用变量五、让make自动推导六、另类风格的makefile七、清空目标文件的规则II Makefile 总述一、Makefile里有什么？二、Makefile的文件名三、引用其它的Makefile四、环境变量 MAKEFILES五、make的工作方式III 书写规则一、规则举例二、规则的语法三、在规则中使用通配符四、文件搜寻五、伪目标六、多目标七、静态模式八、自动生成依赖性IV 书写命令一、显示命令二、命令执行三、命令出错四、嵌套执行make五、定义命令包V 使用变量一、变量的基础二、变量中的变量三、变量高级用法四、追加变量值五、override 指示符六、多行变量七、环境变量八、目标变量九、模式变量VI 使用条件判断一、示例二、语法VII 使用函数一、函数的调用语法二、字符串处理函数三、文件名操作函数四、foreach 函数五、if 函数六、call函数七、origin函数八、shell函数九、控制make的函数VIII make 的运行一、make的退出码二、指定Makefile三、指定目标四、检查规则五、make的参数IX 隐含规则一、使用隐含规则二、隐含规则一览三、隐含规则使用的变量四、隐含规则链五、定义模式规则六、老式风格的"后缀规则"七、隐含规则搜索算法X 使用make更新函数库文件一、函数库文件的成员二、函数库成员的隐含规则三、函数库文件的后缀规则四、注意事项后序概述什么是makefile？或许很多Winodws的程序员都不知道这个东西，因为那些Windows的IDE都为你做了这个工作，但我觉得要作一个好的和professional的程序员，makefile还是要懂。
这就好像现在有这么多的HTML的编辑器，但如果你想成为一个专业人士，你还是要了解HTML的标识的含义。
makefile.am编写规则
makefile.am编写规则makefile.am 规则编写makefile.am 文件是 Automake 工具用来生成 Makefile 的文本文件。
它包含定义如何构建软件项目的一组规则。
编写makefile.am 规则时，有几个关键准则需要遵循：目标和依赖项：每个规则都包含一个目标和一个或多个依赖项。
目标是规则将生成的文件或操作。
依赖项是目标所需的输入文件或先决条件。
目标和依赖项使用冒号 (:) 分隔。
命令：规则还包括一组命令，这些命令指定如何生成目标。
命令以缩进的方式编写，缩进量为一个制表符或四个空格。
变量：Makefile.am 中可以使用变量来存储通用的信息，例如源文件路径或编译器选项。
变量使用美元符号 ($) 和变量名表示。
通用规则：Automake 提供了一些通用规则来处理常见任务，例如编译 C源文件或创建存档。
这些规则可以通过在目标中使用模式来调用。
宏：宏允许您封装重复使用的代码块。
宏使用双圆括号 (()) 表示。
编写规则示例：以下是一个示例 makefile.am 规则，用于编译一个名为main.c 的 C 源文件：```makefile.ammain.o: main.c$(CC) $(CFLAGS) -c main.c```在这个规则中：`main.o` 是目标文件，表示编译源文件 main.c 后生成的对象文件。
`main.c` 是依赖项，表示要编译的目标。
`$(CC)` 是变量，存储编译器命令。
`$(CFLAGS)` 是变量，存储编译器选项。
编写 makefile.am 规则的最佳实践：保持规则简短且易于阅读。
使用注释来解释每个规则的目的。
尽量使用通用规则和宏来简化规则编写。
彻底测试规则以确保其正确性。
遵循这些准则将帮助您编写清晰且维护良好的 makefile.am 文件，从而简化软件构建过程。
makefile语法规则
通配符代替了你一系列的文件，如“*.c”表示所以后缀为 c 的文件。一个需要我 们注意的是，如果我们的文件名中有通配符，如：“*”，那么可以用转义字符 “\”，如“\*”来表示真实的“*”字符，而不是任意长度的字符串。好吧，还是 先来看几个例子吧： clean: rm -f *.o 上面这个例子我不不多说了，这是操作系统 Shell 所支持的通配符。这是在命令中 的通配符。 print: *.c lpr -p $? touch print 上面这个例子说明了通配符也可以在我们的规则中，目标 print 依赖于所有的[.c] 文件。其中的“$?”是一个自动化变量，表示被修改的文件。 objects = *.o 上面这个例子，表示了，通符同样可以用在变量中。并不是说[*.o]会展开，不！ objects的值就是“*.o”。Makefile 中的变量其实就是 C/C++中的宏。如果你要让 通配符在变量中展开，也就是让 objects 的值是所有[.o]的文件名的集合，那么， 你可以这样：objects := $(wildcard *.o)，这种用法由关键字“wildcard”指 出。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
makefile关系到了整个工程的编译规则。
一个工程中的源文件不计数，其按类型、功能、模块分别放在若干个目录中，makefile定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作，因为makefile 就像一个Shell脚本一样，其中也可以执行操作系统的命令。
makefile带来的好处就是——“自动化编译”，一旦写好，只需要一个make命令，整个工程完全自动编译，极大的提高了软件开发的效率。
make是一个命令工具，是一个解释makefile 中指令的命令工具。
unix下的中间代码文件是.o文件。
头文件中应该只是声明，而定义应该放在C/C++文件中makefile的规则是：1）如果这个工程没有编译过，那么我们的所有C文件都要编译并被链接。
2）如果这个工程的某几个C文件被修改，那么我们只编译被修改的C文件，并链接目标程序。
3）如果这个工程的头文件被改变了，那么我们需要编译引用了这几个头文件的C文件，并链接目标程序。
只要我们的Makefile写得够好，所有的这一切，我们只用一个make命令就可以完成，make 命令会自动智能地根据当前的文件修改的情况来确定哪些文件需要重编译，从而自己编译所需要的文件和链接目标程序。
Makefile的规则。
target ... : prerequisites ...command......target也就是一个目标文件，可以是Object File，也可以是执行文件。
还可以是一个标签（Label），对于标签这种特性，在后续的“伪目标”章节中会有叙述。
prerequisites就是，要生成那个target所需要的文件或是目标。
command也就是make需要执行的命令。
（任意的Shell命令）这是一个文件的依赖关系，也就是说，target这一个或多个的目标文件依赖于prerequisites 中的文件，其生成规则定义在command中。
说白一点就是说，prerequisites中如果有一个以上的文件比target文件要新的话，command所定义的命令就会被执行。
这就是Makefile 的规则。
也就是Makefile中最核心的内容.PHONY : clean ，“.PHONY”表示，clean是个伪目标文件。
一般的风格都是：clean:rm edit $(objects)更为稳健的做法是：.PHONY : cleanclean :-rm edit $(objects)前面说过，.PHONY意思表示clean是一个“伪目标”，。
而在rm命令前面加了一个小减号的意思就是，也许某些文件出现问题，但不要管，继续做后面的事。
Makefile里主要包含了五个东西：显式规则、隐晦规则、变量定义、文件指示和注释。
1、显式规则。
显式规则说明了，如何生成一个或多的的目标文件。
这是由Makefile的书写者明显指出，要生成的文件，文件的依赖文件，生成的命令。
2、隐晦规则。
由于我们的make有自动推导的功能，所以隐晦的规则可以让我们比较粗糙地简略地书写Makefile，这是由make所支持的。
3、变量的定义。
在Makefile中我们要定义一系列的变量，变量一般都是字符串，这个有点你C语言中的宏，当Makefile被执行时，其中的变量都会被扩展到相应的引用位置上。
4、文件指示。
其包括了三个部分，一个是在一个Makefile中引用另一个Makefile，就像C 语言中的include一样；另一个是指根据某些情况指定Makefile中的有效部分，就像C语言中的预编译#if一样；还有就是定义一个多行的命令。
有关这一部分的内容，我会在后续的部分中讲述。
5、注释。
Makefile中只有行注释，和UNIX的Shell脚本一样，其注释是用“#”字符，这个就像C/C++中的“//”一样。
如果你要在你的Makefile中使用“#”字符，可以用反斜框进行转义，如：“\#”。
最后，还值得一提的是，在Makefile中的命令，必须要以[Tab]键开始。
默认的情况下，make命令会在当前目录下按顺序找寻文件名为“GNUmakefile”、“makefile”、“Makefile”的文件，你可以使用别的文件名来书写Makefile，比如：“Make.Linux”，“Make.Solaris”，“Make.AIX”等，如果要指定特定的Makefile，你可以使用make的“-f”和“--file”参数，如：make -f Make.Linux或make --file Make.AIX。
引用其它的Makefile在Makefile使用include关键字可以把别的Makefile包含进来，这很像C语言的#include，被包含的文件会原模原样的放在当前文件的包含位置。
include的语法是：include <filename>filename可以是当前操作系统Shell的文件模式（可以保含路径和通配符）在include前面可以有一些空字符，但是绝不能是[Tab]键开始。
include和<filename>可以用一个或多个空格隔开。
举个例子，你有这样几个Makefile：a.mk、b.mk、c.mk，还有一个文件叫foo.make，以及一个变量$(bar)，其包含了e.mk和f.mk，那么，下面的语句：include foo.make *.mk $(bar)等价于：include foo.make a.mk b.mk c.mk e.mk f.mkmake命令开始时，会把找寻include所指出的其它Makefile，并把其内容安置在当前的位置。
就好像C/C++的#include指令一样。
如果文件都没有指定绝对路径或是相对路径的话，make 会在当前目录下首先寻找，如果当前目录下没有找到，那么，make还会在下面的几个目录下找：1、如果make执行时，有“-I”或“--include-dir”参数，那么make就会在这个参数所指定的目录下去寻找。
2、如果目录<prefix>/include（一般是：/usr/local/bin或/usr/include）存在的话，make 也会去找。
如果有文件没有找到的话，make会生成一条警告信息，但不会马上出现致命错误。
它会继续载入其它的文件，一旦完成makefile的读取，make会再重试这些没有找到，或是不能读取的文件，如果还是不行，make才会出现一条致命信息。
如果你想让make不理那些无法读取的文件，而继续执行，你可以在include前加一个减号“-”。
如：-include <filename>其表示，无论include过程中出现什么错误，都不要报错继续执行。
和其它版本make 兼容的相关命令是sinclude，其作用和这一个是一样的。
GNU的make工作时的执行步骤入下：（想来其它的make也是类似）1、读入所有的Makefile。
2、读入被include的其它Makefile。
3、初始化文件中的变量。
4、推导隐晦规则，并分析所有规则。
5、为所有的目标文件创建依赖关系链。
6、根据依赖关系，决定哪些目标要重新生成。
7、执行生成命令。
make支持三各通配符：“*”，“?”和“[...]”。
波浪号（“~”）字符在文件名中也有比较特殊的用途。
如果是“~/test”，这就表示当前用户的$HOME目录下的test目录。
而“~hchen/test”则表示用户hchen的宿主目录下的test目录。
（这些都是Unix下的小知识了，make也支持）而在Windows或是MS-DOS下，用户没有宿主目录，那么波浪号所指的目录则根据环境变量“HOME”而定。
通配符代替了你一系列的文件，如“*.c”表示所以后缀为c的文件。
一个需要我们注意的是，如果我们的文件名中有通配符，如：“*”，那么可以用转义字符“\”，如“\*”来表示真实的“*”字符，而不是任意长度的字符串。
文件搜寻在一些大的工程中，有大量的源文件，我们通常的做法是把这许多的源文件分类，并存放在不同的目录中。
所以，当make需要去找寻文件的依赖关系时，你可以在文件前加上路径，但最好的方法是把一个路径告诉make，让make在自动去找。
Makefile文件中的特殊变量“VPATH”就是完成这个功能的，如果没有指明这个变量，make 只会在当前的目录中去找寻依赖文件和目标文件。
如果定义了这个变量，那么，make就会在当当前目录找不到的情况下，到所指定的目录中去找寻文件了。
VPATH = src:../headers上面的的定义指定两个目录，“src”和“../headers”，make会按照这个顺序进行搜索。
目录由“冒号”分隔。
（当然，当前目录永远是最高优先搜索的地方）另一个设置文件搜索路径的方法是使用make的“vpath”关键字（注意，它是全小写的），这不是变量，这是一个make的关键字，这和上面提到的那个VPATH变量很类似，但是它更为灵活。
它可以指定不同的文件在不同的搜索目录中。
这是一个很灵活的功能。
它的使用方法有三种：1、vpath <pattern> <directories>为符合模式<pattern>的文件指定搜索目录<directories>。
2、vpath <pattern>清除符合模式<pattern>的文件的搜索目录。
3、vpath清除所有已被设置好了的文件搜索目录。
vapth使用方法中的<pattern>需要包含“%”字符。
“%”的意思是匹配零或若干字符，例如，“%.h”表示所有以“.h”结尾的文件。
<pattern>指定了要搜索的文件集，而<directories>则指定了<pattern>的文件集的搜索的目录。
例如：vpath %.h ../headers该语句表示，要求make在“../headers”目录下搜索所有以“.h”结尾的文件。
（如果某文件在当前目录没有找到的话）我们可以连续地使用vpath语句，以指定不同搜索策略。
如果连续的vpath语句中出现了相同的<pattern>，或是被重复了的<pattern>，那么，make会按照vpath语句的先后顺序来执行搜索。
如：vpath %.c foovpath % blishvpath %.c bar其表示“.c”结尾的文件，先在“foo”目录，然后是“blish”，最后是“bar”目录。
vpath %.c foo:barvpath % blish而上面的语句则表示“.c”结尾的文件，先在“foo”目录，然后是“bar”目录，最后才是“blish”目录。