makefile 中 $@ $^ % 使用

合集下载

makefile中的特殊符号及关键字

makefile中的特殊符号及关键字

makefile中的特殊符号及关键字1.常见⾃动变量和含义* :表⽰⽬标⽂件的名称,不包含⽬标⽂件的扩展名。

+ :表⽰所有的依赖⽂件,这些依赖⽂件之间以空格分开,按照出现的先后为顺序,其中可能包含重复的依赖⽂件。

< :表⽰依赖项中第⼀个依赖⽂件的名称:依赖项中,所有⽬标⽂件时间戳晚的⽂件(表⽰修改过),依赖⽂件间以空格分开@ :⽬标项中⽬标⽂件的名称^ :依赖项中,所有不重复的依赖⽂件,以空格分开。

2.预定义变量Makefile中常⽤的变量及含义AR⽣成静态库库⽂件的程序名称arAS汇编编译器的名称asCC C语⾔编译器的名称ccCPP C语⾔预编译器的名称$(CC) -ECXX C++语⾔编译器的名称g++FC FORTRAN语⾔编译器的名称f77RM删除⽂件程序的名称rm -fARFLAGS⽣成静态库库⽂件程序的选项⽆默认值ASFLAGS汇编语⾔编译器的编译选项⽆默认值CFLAGS C语⾔编译器的编译选项⽆默认值CPPFLAGS C语⾔预编译器的编译选项⽆默认值CXXFLAGS C++语⾔编译器的编译选项⽆默认值FFLAGS FORTRAN语⾔编译器的编译选项⽆默认值3.设置搜索路径 指定需要搜索的⽬录, make 会⾃动找到指定⽂件的⽬录并添加到⽂件上。

VPATH = path1:path2:...4.递归make对于规模⽐较⼤的程序,需要多个⼈在多个⽬录下进⾏开发。

如果只⽤⼀个 Makefile 来维护就会⽐较⿇烦,因此可以在每个⽬录下建⽴⾃⼰的 Makefile ,然后在总控 Makefile 中调⽤⼦⽬录的 Makefile ⽂件。

⽬录结构如下:.├── add│├── add_float.c│├── add.h│├── add_int.c│└── Makefile├── main.c├── Makefile└── sub├── Makefile├── sub_float.c├── sub.h└── sub_int.c1.递归调⽤的⽅式add:cd add && $(MAKE)它等价于add:$(MAKE) -C add2.总控MakefileCC = gccCFLAGS = -O2TARGET = cacuexport OBJSDIR = $(shell pwd)/objs$(TARGET):$(OBJSDIR) main.o$(MAKE) -C add$(MAKE) -C sub$(CC) -o $(TARGET) $(OBJSDIR)/*.o$(OBJSDIR):mkdir -p $@main.o:%.o:%.c$(CC) -c $< -o $(OBJSDIR)/$@ $(CFLAGS) -Iadd -Isubclean:-$(RM) $(TARGET)-$(RM) $(OBJSDIR)/*.o如果总控 Makefile 中的⼀些变量需要传递给下层的 Makefile,可以使⽤ export 命令。

make makefile 的参数

make makefile 的参数

make makefile 的参数make是一个常用的构建工具,用于自动化编译和构建软件项目。

makefile是make工具的配置文件,用于描述项目的构建规则和依赖关系。

本文将介绍makefile的参数,包括常用的参数及其用法。

一、常用参数及其用法1. -f 文件名:指定makefile的文件名,默认为"makefile"或"Makefile"。

通过该参数,可以使用其他名称的makefile文件。

2. -C 目录:指定make命令的工作目录。

在执行make命令时,会切换到指定的目录,并在该目录下查找makefile文件进行构建。

3. -n:显示执行make命令时的操作,但不实际执行。

通过该参数,可以预览make命令的执行过程,检查构建规则是否正确。

4. -p:显示make命令的内置变量和规则。

通过该参数,可以查看make命令的内部工作机制,了解makefile文件的编写规则和使用方法。

5. -B:强制重新构建目标文件。

通过该参数,可以忽略文件的时间戳,强制重新执行构建规则,生成新的目标文件。

6. -j 并发数:指定make命令的并发执行数。

通过该参数,可以提高构建速度,同时执行多个任务。

7. -s:静默模式,不显示执行的命令。

通过该参数,可以减少输出信息,使构建过程更加清晰。

二、makefile的构建规则makefile由一系列构建规则组成,每个规则定义了目标文件、依赖文件和构建命令。

make命令根据构建规则,自动判断需要更新的文件,并执行相应的构建命令。

构建规则的基本格式如下:目标文件: 依赖文件构建命令其中,目标文件是要生成的文件,依赖文件是目标文件依赖的文件,构建命令是生成目标文件的命令。

构建规则中的目标文件和依赖文件可以是文件名,也可以是变量。

通过使用变量,可以提高makefile的可维护性和灵活性。

构建命令可以是任意的Shell命令,包括编译、链接、拷贝等操作。

Makefile条件编译debug版和release版

Makefile条件编译debug版和release版

Makefile条件编译debug版和release版⼀般,在开发测试阶段⽤debug版本,⽽上线发布⽤release版本。

使⽤Makefile定制编译不同版本,避免修改程序和Makefile⽂件,将会⼗分⽅便。

读了⼀些资料,找到⼀个解决⽅法,Makefile预定义宏与条件判断,结合make预定义变量,进⾏条件编译。

⽐如,有⼀个test.cpp,包含这段代码#ifdef debug//your code#endif你希望在debug版本要执⾏它,在release版本不执⾏。

我们可以写这样的⼀个Makefile:1 ver = debug23 ifeq ($(ver), debug)4 ALL: test_d5 CXXFLAGS = -c -g -Ddebug6else7 ALL: test_r8 CXXFLAGS = -c -O39 endif1011 test_d: test.do12 g++ -o $@ $^1314 test_r: test.ro15 g++ -o $@ $^1617 %.do: %.cpp18 g++ $(CXXFLAGS) $< -o $@1920 %.ro: %.cpp21 g++ $(CXXFLAGS) $< -o $@简单说⼀下,Makefile根据ver的不同定义了不同的编译选项CXXFLAGS与输出程序ALL,debug版本输出程序是test_d,release版本输出程序是test_rdebug版本编译选项是"-c -g -Ddebug",release版本编译选项是"-c -O3"debug版本object⽂件后缀是".do",release版本object⽂件后缀是".ro"debug版本编译选项使⽤"-D"定义宏debug,使得your code能够执⾏。

makefile正则表达式

makefile正则表达式

makefile正则表达式makefile是一种常用的工具,可以用于自动化构建和管理项目。

在makefile中,正则表达式是一个强大的工具,可以帮助我们更方便地匹配和处理文本内容。

makefile中常用的正则表达式包括:1. ^(起始符):匹配字符串的开头。

2. $(结束符):匹配字符串的结尾。

3. .(点号):匹配除了换行符外的任意一个字符。

4. *(星号):匹配前面的字符出现0个或多个。

5. +(加号):匹配前面的字符出现1个或多个。

6. ?(问号):匹配前面的字符出现0个或1个。

7. [ ](中括号):匹配中括号中任意一个字符。

8. [^ ](中括号取反):匹配不在中括号中的任意一个字符。

9. ( )(圆括号):将括号中的内容视为一个整体,可以和其他正则表达式一起使用。

除了这些常用的正则表达式外,还有一些特殊的符号和语法可以帮助我们更精确地匹配文本内容,比如:1. (反斜杠):转义符,可以将特殊字符转义为普通字符。

2. |(竖线):或运算符,可以匹配多个表达式中的一个。

3. { }(花括号):重复次数符号,可以指定一个字符或表达式的重复次数。

在使用正则表达式时,我们需要注意一些事项,比如:1. 正则表达式是区分大小写的。

2. 正则表达式中的空格和换行符也会被匹配。

3. 正则表达式可能会匹配到我们不需要的内容,因此需要通过进一步筛选和处理来达到我们的目的。

总之,正则表达式在makefile中的应用非常广泛,可以帮助我们更方便地编写自动化构建和管理脚本。

熟练掌握正则表达式的使用方法,可以极大地提高我们的工作效率。

Makefile中的几个常见的符号及其含义

Makefile中的几个常见的符号及其含义

Makefile中的⼏个常见的符号及其含义= 是最基本的赋值:= 是覆盖之前的值= 是如果没有被赋值过就赋予等号后⾯的值+= 是添加等号后⾯的值“=”和“:=”的区别:1、“=”make会将整个makefile展开后,再决定变量的值。

也就是说,变量的值将会是整个makefile中最后被指定的值。

看例⼦: x = fooy = $(x) barx = xyz在上例中,y的值将会是 xyz bar ,⽽不是 foo bar 。

2、“:=”“:=”表⽰变量的值决定于它在makefile中的位置,⽽不是整个makefile展开后的最终值。

x := fooy := $(x) barx := xyz在上例中,y的值将会是 foo bar ,⽽不是 xyz bar 了。

'@' 符号的使⽤通常makefile会将其执⾏的命令⾏在执⾏前输出到屏幕上。

如果将‘@’添加到命令⾏前,这个命令将不被make回显出来。

例如:@echo --compiling module----; // 屏幕输出 --compiling module----echo --compiling module----; // 没有@ 屏幕输出echo --compiling module----' - ' 符号的使⽤通常删除,创建⽂件如果碰到⽂件不存在或者已经创建,那么希望忽略掉这个错误,继续执⾏,就可以在命令前⾯添加 -, -rm dir;-mkdir aaadir;ref:https:///u012989012/article/details/80572043。

交叉编译makefile编写

交叉编译makefile编写

交叉编译makefile编写交叉编译Makefile编写在软件开发中,我们通常会遇到需要在不同平台上编译程序的情况。

当我们需要在一台主机上编译运行另一种架构的程序时,就需要进行交叉编译。

而Makefile作为一种构建工具,可以帮助我们自动化编译过程,提高开发效率。

本文将介绍如何编写适用于交叉编译的Makefile,以实现在不同平台上的程序构建。

一、了解交叉编译概念交叉编译是指在一台主机上编译生成另一种架构的可执行文件。

通常情况下,我们在本机上编写并编译程序,然后在本机上运行。

但是,当我们需要在不同的平台上运行程序时,由于不同平台的指令集、库文件等差异,我们就需要使用交叉编译来生成适用于目标平台的可执行文件。

二、Makefile的基本结构Makefile是一种用于描述程序构建过程的文件,它包含了一系列规则(rules),每个规则由一个或多个目标(target)和依赖项(dependencies)组成。

当某个目标的依赖项发生变化时,Make工具会根据规则自动更新目标文件。

一个基本的Makefile结构如下所示:```target: dependenciescommand```其中,target表示目标文件,dependencies表示目标文件的依赖项,command表示生成目标文件的命令。

三、交叉编译的Makefile编写在编写交叉编译的Makefile之前,我们需要了解目标平台的相关信息,如架构、编译器、库文件等。

以ARM架构为例,我们可以使用arm-linux-gnueabi-gcc作为交叉编译器。

我们需要定义一些变量,用于指定交叉编译工具链和相关参数:```CC = arm-linux-gnueabi-gccCFLAGS = -Wall -O2```其中,CC表示编译器,CFLAGS表示编译参数。

接下来,我们可以定义目标文件和依赖项:```TARGET = myprogramSRCS = main.c foo.c bar.cOBJS = $(SRCS:.c=.o)```其中,TARGET表示目标文件,SRCS表示源文件列表,OBJS表示目标文件列表。

makefile文件——Inference Rules(推导规则)

makefile文件——Inference Rules(推导规则)

Inference Rules(推导规则)Inference rules(下文简称IR)是一个模板,它用于决定如何从一个具有某种扩展名的文件构造出一个具有另一种扩展名的文件。

NMAKE通过IR来确定用来更新target的命令以及推导target的dependents。

IR的好处在于它满足了像我这样的懒人的需要。

只要提供了正确的IR,则描述语句块就可以极大地化简。

请看下面的例子:foo.obj :上面的语句将会运作得很好。

是不是觉得很吃惊呢?事实上,NMAKE在处理该语句的时候,它首先在当前目录下搜索基本名为foo的文件(假设当前目录下有一个foo.c文件)。

然后它查找一个后缀列表(suffix list),里面的每一项包含了从一种类型的文件构造另一种类型的文件需要调用的命令和参数的相关信息。

在NMAKE预定义的列表中,foo.c到foo.obj的构造命令为CL。

最后NMAKE调用CL,编译foo.c。

呵呵,这么一长串的操作一条简单的语句就搞定了,是不是很方便呢!当出现下列情况之一时,NMAKE就会尝试使用IR:l NMAKE遇到一个没有任何命令的描述语句块。

此时NMAKE就会搜索后缀列表,试图找到一个匹配的命令来构造target。

l 无法找到某个dependent,并且该dependent没有作为target出现在其它dependent line中(即它不是一个pseudotarget)。

此时NMAKE就会搜索给定的目录以及后缀列表,试图找到一个IR来构造出该dependent。

l 一个target没有dependent,并且描述语句块中没有给出指令。

此时NMAKE就会试图找出一个IR来构造出该target。

l 一个target在NMAKE的命令行中给出,但在makefile里没有该target的相关信息(或根本就没有makefile)。

此时NMAKE就会试图找出一个IR来构造出该target。

makefile循环语句

makefile循环语句

在Makefile中,可以使用循环语句来自动化构建规则和操作。

Makefile的循环语句使用`$(foreach)`宏函数来实现。

下面是一个示例,展示如何使用Makefile循环语句来自动构建多个目标文件:
```makefile
SOURCES = file1.c file2.c file3.c
OBJ_FILES = $(addprefix obj/,$(SOURCES:.c=.o))
all: $(OBJ_FILES)
gcc -o myprogram $^
obj/%.o: %.c
gcc -c $< -o $@
clean:
rm -rf obj/
```
在上面的示例中,`SOURCES`变量包含了多个C源文件,`OBJ_FILES`变量通过使用`$(foreach)`宏函数和`$(addprefix)`函数来生
成目标文件的前缀路径。

然后,在默认规则中,使用`$(foreach)`宏函数来遍历`OBJ_FILES`变量,并构建每个目标文件。

最后,使用`gcc`编译器链接所有目标文件生成最终的可执行文件`myprogram`。

当需要清理所有生成的目标文件时,可以执行`make clean`命令。

Makefile中一些特殊符号的意义

Makefile中一些特殊符号的意义

Makefile中⼀些特殊符号的意义在makefile中,有时会接触到⼀些以特殊字符打头的命令,⽐如@, -, +,如果之前没有接触过的话,会感觉⽐较奇怪,其实,多是⼀些为了实现特定⾏为模式⽽引⼊的标记符。

命令⾏以'@'打头的含义:在执⾏到的时候不回显相应的命令内容,只显⽰命令的输出。

命令⾏以'-'打头的含义:在执⾏到的时候如果发⽣错误(退出返回⾮零状态)时,不中断make过程。

命令⾏以'+'打头的含义: makefile中以+开头的命令的执⾏不受到 make的-n,-t,-q三个参数的影响。

我们知道,在make的时候,如果加上-n, -t, -q这样的参数,都是不执⾏相应命令的,⽽以'+'开头的命令,则⽆论make命令后⾯是否跟着三个参数,都会被执⾏。

附:make命令参数make的参数下⾯列举了所有GNU make 3.80版的参数定义。

其它版本和产商的make⼤同⼩异,不过其它产商的make的具体参数还是请参考各⾃的产品⽂档。

“-b”“-m”这两个参数的作⽤是忽略和其它版本make的兼容性。

“-B”“--always-make”认为所有的⽬标都需要更新(重编译)。

“-C <dir>;”“--directory=<dir>;”指定读取makefile的⽬录。

如果有多个“-C”参数,make的解释是后⾯的路径以前⾯的作为相对路径,并以最后的⽬录作为被指定⽬录。

如:“make –C ~hchen/test –C prog”等价于“make –C ~hchen/test/prog”。

“—debug[=<options>;]”输出make的调试信息。

它有⼏种不同的级别可供选择,如果没有参数,那就是输出最简单的调试信息。

下⾯是<options>;的取值:a —— 也就是all,输出所有的调试信息。

makefile中make指令传入的参数

makefile中make指令传入的参数

makefile中make指令传入的参数(实用版)目录1.Makefile 简介2.Make 指令的作用3.Make 指令传入的参数4.示例与实践正文1.Makefile 简介Makefile 是一种构建脚本,用于自动化构建和编译软件项目。

它通常包含一系列的规则和指令,可以自动地执行编译、链接和安装等任务。

Makefile 最早用于 Unix 系统,现在已广泛应用于各种操作系统和编程语言。

2.Make 指令的作用在 Makefile 中,Make 指令是最核心的命令。

它可以自动地执行一系列的编译、链接和安装等任务,以构建软件项目。

Make 指令的工作原理是基于依赖关系,它可以自动地发现源文件和目标文件之间的依赖关系,并按照一定的顺序执行相应的操作。

3.Make 指令传入的参数Make 指令传入的参数主要有以下几种:(1)目标:指定要构建的目标文件,通常是可执行文件或库文件。

(2)源文件:指定构成目标文件的源文件,可以是 C、C++等源代码文件。

(3)编译器:指定用于编译源文件的编译器,例如 gcc、g++等。

(4)链接器:指定用于链接目标文件和库文件的链接器,例如 ld、ld.so 等。

(5)其他选项:还可以指定其他选项,例如优化级别、输出文件名等。

4.示例与实践下面是一个简单的 Makefile 示例,用于编译一个 C 语言程序:```CC = gccCFLAGS = -Wall -o2SOURCES = main.cOBJECTS = main.oTARGET = mainall: $(TARGET)$(TARGET): $(OBJECTS)t$(CC) $(CFLAGS) $^ -o $@$(OBJECTS): $(SOURCES)t$(CC) $(CFLAGS) -c $< -o $@```在这个示例中,我们指定了编译器(CC)、优化选项(CFLAGS)、源文件(SOURCES)、目标文件(TARGET)和依赖关系(all: $(TARGET))。

Makefile

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。

简单的makefile模板

简单的makefile模板

简单的makefile模板makefile不是总⽤到,每次⽤到的时候总要重新找资料,有点⿇烦(怪⾃⼰基础知识不扎实,汗)。

留⼀个通⽤模板放这,⽅便以后使⽤CC = gccCXX = g++LINK = g++CFLAGS = -g -Wall -O2TARGET = mk0SRCS = $(wildcard *.cpp)SRCS += $(wildcard *.c)CXX_OBJS = $(patsubst %.cpp, %.o, $(wildcard *.cpp))C_OBJS = $(patsubst %.c, %.o, $(wildcard *.c))all:$(TARGET)$(TARGET):$(CXX_OBJS) $(C_OBJS)$(LINK) $(CFLAGS) -o $@ $^%.o:%.cpp$(CXX) $(CFLAGS) -c -o $@ $<%.o:%.c$(CC) $(CFLAGS) -c -o $@ $<.PHONY:cleanclean:rm -rf *.o $(TARGET) $(CXX_OBJS) $(C_OBJS)因为项⽬特殊性,经常c与cpp都会⽤到,所以简单写个这样的makefile⽂件上⾯makefile有很⼤局限性,⽐如只能使⽤与所有源⽂件在⼀个⽬录场景。

下⾯展⽰可以多个⽬录下源⽂件,以及程序使⽤动态库的特殊场景CC = gccCXX = g++LINKC = gccLINKCXX = g++CFLAGS = -g -Wall -O2TOP_DIR := $(shell pwd)SRC_DIRS := $(shell find $(TOP_DIR) -maxdepth 1 -type d)TARGET := $(TOP_DIR)/bin/mk0INC_PATH = -I$(TOP_DIR)/include/LIB_PATH = -L$(TOP_DIR)/lib/EXT_LIB = -Wl,-rpath,$(TOP_DIR)/bin/ -lcsayCXX_SRCS = $(foreach dir, $(SRC_DIRS), $(wildcard $(dir)/*.cpp))CXX_OBJS = $(patsubst %.cpp, %.o, $(CXX_SRCS))C_SRCS = $(foreach dir, $(SRC_DIRS), $(wildcard $(dir)/*.c))C_OBJS = $(patsubst %.c, %.o, $(C_SRCS))all:$(TARGET)$(TARGET):$(CXX_OBJS) $(C_OBJS) $(shell if [ ! -d $(TOP_DIR)/bin ]; then mkdir $(TOP_DIR)/bin; fi)ifeq ($(CXX_SRCS),) $(LINKC) $(LIB_PATH) $(EXT_LIB) $(CFLAGS) -o $@ $^else $(LINKCXX) $(LIB_PATH) $(EXT_LIB) $(CFLAGS) -o $@ $^endif%.o:%.cpp $(CXX) $(INC_PATH) $(CFLAGS) -c -o $@ $<%.o:%.c $(CC) $(INC_PATH) $(CFLAGS) -c -o $@ $<.PHONY:cleanclean:rm -rf $(TARGET) $(CXX_OBJS) $(C_OBJS)如上所⽰,代码包括了三个⽬录:. func0 func1⽬录。

Makefile编写规则(三)条件判断和伪目标

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 命令行参数
2. -C选项
-C选项可以指定Makefile所在的路径。如果我们在当前路径下执行make命令,但是Makefile文件不在当前路径下,那么就需要使用-C选项来指定Makefile所在的路径。例如:
make -C /path/to/Makefile
3. -f选项
-f选项可以指定要使用的Makefile文件名。如果我们有多个Makefile文件,那么就可以使用-f选项来指定要使用哪个Makefile文件。例如:
makefile 命令行参数
Makefile是一种用来管理代码编译的工具,它可以自动化执行编译任务,帮助程序员更高效地管理代码。在Makefile中,可以定义一系列规则来指定如何编译代码。在使用Makefile时,我们可以通过命令行参数来控制编译过程的行为。本文将详细介绍makefile命令行参数的使用方法。项
-j选项可以指定并行编译时所使用的线程数。如果我们有多个CPU核心,并且要编译大型项目,那么就可以使用-j选项来加速编译过程。例如:
make -j4
5. --dry-run选项
--dry-run选项可以模拟执行make命令,并输出将要执行的命令列表,但是并不会真正地执行这些命令。这个功能非常实用,因为我们可以预先查看将要执行的命令,确保它们是正确的。例如:
这样做的好处是,我们可以在不修改Makefile的情况下,通过命令行参数来控制编译过程的行为。
四、总结
本文介绍了Makefile命令行参数的用法,包括make命令、-C选项、-f选项、-j选项、--dry-run选项和--print-data-base选项。同时,本文还介绍了一些Makefile常用技巧,包括使用变量来存储编译选项、使用通配符来自动生成目标文件列表和使用命令行参数来控制编译过程。希望本文能够对大家理解和学习Makefile有所帮助。

makefile中反斜杠用法

makefile中反斜杠用法

在Makefile中,反斜杠(\)用于将一行代码拆分成多行以提高可读性。

当一行代码过
长时,可以使用反斜杠将其拆分为多行,并且在下一行的开头位置插入反斜杠。

反斜杠的使用规则如下:
1. 反斜杠必须位于行尾,即只能出现在一行的最后。

2. 反斜杠后面不能有空格或制表符,否则反斜杠将不起作用。

3. 反斜杠后面的换行符会被忽略,多行代码会被连接成一行。

4. 可以使用多个连续的反斜杠来表示多个空行。

以下是一个示例,展示了反斜杠的使用方法:
```makefile
# 示例Makefile
CC := gcc
CFLAGS := -Wall \
-Werror \
-O2
all: program
program: main.o utils.o
$(CC) $(CFLAGS) $^ -o $@
main.o: main.c \
utils.h
$(CC) $(CFLAGS) -c $< -o $@
utils.o: utils.c \
utils.h
$(CC) $(CFLAGS) -c $< -o $@
```
在上述示例中,我们可以看到在`CFLAGS`变量的赋值中使用了反斜杠进行了多行拆分,以提高可读性。

同样地,在目标的依赖关系中,我们也使用了反斜杠将多行代码连接
成一行。

使用反斜杠可以使Makefile更易读,特别是在需要定义长的命令行参数或复杂的依赖
关系时。

它使代码的结构更清晰,并减少了错误和重复。

windows makefile编写规则

windows makefile编写规则

windows makefile编写规则【实用版】目录1.编写 Makefile 的必要性2.Makefile 的基本结构3.变量定义4.规则与依赖关系5.编写 Windows Makefile 的注意事项正文一、编写 Makefile 的必要性在软件开发过程中,我们常常需要编译和链接源代码以生成可执行文件。

尤其是在大型项目中,如何自动化地管理这些编译和链接过程就显得尤为重要。

Makefile 就是在这种情况下应运而生的一种工具,它能帮助我们简化和规范化这个过程。

二、Makefile 的基本结构一个典型的 Makefile 主要包括以下几个部分:1.变量定义:用于设置一些编译选项和路径等。

2.规则:定义了如何将源文件编译成目标文件。

3.依赖关系:描述了目标文件依赖于哪些源文件。

三、变量定义在 Makefile 中,我们可以通过“define”语句来定义变量。

例如:```CC = g++CFLAGS = -g -Wall```上述代码定义了两个变量:CC 和 CFLAGS。

CC 表示编译器,这里设置为 g++;CFLAGS 表示编译选项,这里设置为-g(输出调试信息)和-Wall (启用所有警告)。

四、规则与依赖关系规则和依赖关系是 Makefile 的核心部分,它们描述了如何将源文件编译成目标文件。

规则的一般形式为:```目标文件 : 源文件 1 源文件 2...t$(CC) $(CFLAGS) -o $@ $^```其中,$@表示目标文件,$^表示所有源文件。

依赖关系则是通过“depends”语句来描述的,例如:```target.o : source1.o source2.ot$(CC) $(CFLAGS) -c $< -o $@```五、编写 Windows Makefile 的注意事项在 Windows 系统上编写 Makefile 时,需要注意以下几点:1.路径问题:在 Windows 系统上,路径使用双反斜杠()或者单斜杠(/)表示,需要根据实际情况进行设置。

make的用法总结

make的用法总结

make的用法总结Make 是一款用于编译程序的工具,其主要功能是依据程序的依赖关系自动构建目标文件和可执行文件。

Make 文件格式简单,易于编辑和管理,被广泛应用于各种软件开发项目中。

Make 语法:Makefile 是 Make 的配置文件。

Makefile 由一系列规则组成,每一条规则由三部分组成:目标文件:执行命令生成的文件名;依赖文件:目标文件所依赖的文件名,如果依赖文件发生改变,就需要重新执行规则中的命令;命令:生成目标文件的命令,一般用 Shell 脚本实现。

规则语法如下:target: dependenciescommand1command2...其中,冒号左边是目标文件,冒号右边是依赖文件。

冒号右侧可以有多个文件名,以空格分隔。

命令必须以制表符或者“空格+制表符”开头,否则会出现语法错误。

Make 命令:make 命令用于执行 Makefile 中的规则,生成目标文件或可执行文件。

常用的命令有:make:根据 Makefile 生成目标文件或可执行文件;make target:只生成指定的目标文件;make clean:删除所有目标文件和可执行文件;make help:显示 Makefile 中定义的帮助信息。

Make 变量:Make 变量可以在 Makefile 中定义和使用,用于简化规则的编写和维护。

常用的 Make 变量有:SRC_FILES:源文件列表;OBJ_FILES:目标文件列表;CXX:编译器;CXXFLAGS:编译选项;LD:链接器;LDFLAGS:链接选项。

Make 高级用法:1. 条件语句Makefile 中可以使用条件语句,进行不同的处理。

条件语句格式如下:ifeq ($(variable), value)# do somethingelse# do something elseendif其中,$(variable) 表示变量名,value 表示变量的值。

makefile 常用符号

makefile 常用符号

makefile 常用符号Makefile是一种用于自动化构建和部署软件的工具,它使用规则和宏来描述项目的结构和编译过程。

以下是一些常用的Makefile符号:1. 目标(Targets):Makefile中的命令执行目标。

例如,`all`、`clean`、`build`等。

2. 依赖(Dependencies):目标所需的文件或目标。

可以使用`依赖目标`来表示一个目标依赖于另一个目标。

3. 命令(Commands):用于生成或构建目标的命令。

可以包含多个命令,用分号分隔。

4. 通配符(Patterns):用于匹配文件或目录的名称。

例如,`src/*.c`表示所有以`.c`结尾的文件位于`src`目录。

5. 函数(Functions):Makefile中的自定义功能。

可以通过`定义函数名`来定义一个函数,并在需要时调用它。

6. 变量(Variables):Makefile中的数据存储单元。

可以使用`变量名=值`的方式来定义变量,并在需要时引用它们。

7. 规则(Rules):用于描述如何生成目标的规则。

规则由左边的目标、冒号、右边的命令和可选的`phony:`组成。

8. phony目标(Phony targets):虚拟目标,用于绕过Makefile中的正常构建过程。

可以在phony目标后跟一个冒号,然后是实际的命令。

9. 自动变量(Automatic variables):在构建过程中自动计算的变量。

常见的自动变量有`$@`(所有目标)、`$^`(所有依赖文件)、`$?`(已改变的依赖文件)等。

10. 模式变量(Pattern variables):用于根据文件名匹配值来设置变量。

例如,`OBJS := obj/*.o`,这将把所有以`.o`结尾的文件编译为目标。

11. 隐含规则(Implicit rules):Makefile中用于自动生成目标的一种机制。

当一个目标没有显式规则时,Makefile会尝试使用隐含规则来生成它。

Makefile的作用举例

Makefile的作用举例

Makefile - Makefile一个工程中的源文件不计数,其按类型、功能、模块分别放在若干个目录中,makefile定义了一系列的规则来指定,哪些文件需要先编译,哪些文件需要后编译,哪些文件需要重新编译,甚至于进行更复杂的功能操作,因为 makefile就像一个Shell脚本一样,其中也可以执行操作系统的命令。

makefile带来的好处就是——“自动化编译”,一旦写好,只需要一个make命令,整个工程完全自动编译,极大的提高了软件开发的效率。

make是一个命令工具,是一个解释makefile中指令的命令工具,一般来说,大多数的IDE都有这个命令,比如:Delphi的make,Visual C++的nmake,Linux下GNU的make。

可见,makefile都成为了一种在工程方面的编译方法。

Makefile - Make工具最主要也是最基本的功能就是通过makefile文件来描述源程序之间的相互关系并自动维护编译工作。

而makefile 文件需要按照某种语法进行编写,文件中需要说明如何编译各个源文件并连接生成可执行文件,并要求定义源文件之间的依赖关系。

makefile 文件是许多编译器--包括 Windows NT 下的编译器--维护编译信息的常用方法,只是在集成开发环境中,用户通过友好的界面修改 makefile 文件而已。

在 UNIX 系统中,习惯使用 Makefile 作为 makfile 文件。

如果要使用其他文件作为 makefile,则可利用类似下面的 make 命令选项指定 makefile 文件:$ make -f Makefile.debug例如,一个名为prog的程序由三个C源文件filea.c、fileb.c和filec.c以及库文件LS编译生成,这三个文件还分别包含自己的头文件a.h 、b.h和c.h。

通常情况下,C编译器将会输出三个目标文件filea.o、fileb.o和filec.o。

makefile 冒号的用法

makefile 冒号的用法

Makefile 冒号的用法
在Makefile中,冒号(:)主要有两种用法:
规则中的冒号:在Makefile的规则中,冒号用于分隔目标文件和依赖项。

规则的格式为“目标文件:依赖项1 依赖项2 ... 命令”。

其中,目标文件是规则要生成的文件,依赖项是目标文件所依赖的其他文件,命令是用于生成目标文件的命令。

例如,下面的规则表示当目标文件“foo.o”发生变化时,执行命令“gcc -c foo.c”来重新生成它:
makefile
foo.o: foo.c
gcc -c foo.c
双冒号规则中的冒号:在Makefile中,双冒号规则是一种特殊的规则,用于指定当多个文件具有相同的依赖项时,如何执行不同的命令来生成目标文件。

双冒号规则的格式为“目标文件:: 依赖项1 依赖项2 ... 命令”。

例如,下面的规则表示当“foo.c”或“bar.c”发生变化时,分别执行不同的命令来重新生成“Newprog”目标文件:
makefile
Newprog :: foo.c $(CC) $(CFLAGS) $< -o $@
Newprog :: bar.c $(CC) $(CFLAGS) $< -o $@
在双冒号规则中,当同一个目标出现在多个规则中时,会按照规则的书写顺序执行。

因此,在上面的例子中,如果“foo.c”发生变化,将执行第一个规则重新生成“Newprog”,然后执行第二个规则重新生成“Newprog”,因为“bar.c”没有被修改。

总结起来,冒号在Makefile中有两种主要用法:一种是用于分隔目标文件
和依赖项的普通规则中的冒号,另一种是用于指定多个规则中如何执行不同命令的双冒号规则中的冒号。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

makefile 中$@ $^ %&lt; 使用/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("Thisis mytool1 print %s\n",print_str);}/* mytool2.h */#ifndef_MYTOOL_2_H#define _MYTOOL_2_Hvoidmytool2_print(char *print_str);#endif/* mytool2.c */#include "mytool2.h"void mytool2_print(char *print_str){printf("Thisis 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脚本,让她帮我去完成不就可以了。

是的对于这个程序来说,是可以起到作用的。

但是当我们把事情想的更复杂一点,如果我们的程序有几百个源程序的时候,难道也要编译器重新一个一个的去编译?为此,聪明的程序员们想出了一个很好的工具来做这件事情,这就是make。

我们只要执行以下make,就可以把上面的问题解决掉。

在我们执行make之前,我们要先编写一个非常重要的文件。

--Makefile。

对于上面的那个程序来说,可能的一个Makefile的文件是:# 这是上面那个程序的Makefile文件main:main.o mytool1.o mytool2.ogcc -o main main.o mytool1.o mytool2.omain.o:main.c mytool1.h mytool2.hgcc -c main.cmytool1.o:mytool1.c mytool1.hgcc -c mytool1.cmytool2.o:mytool2.cmytool2.hgcc -c mytool2.c有了这个Makefile文件,不过我们什么时候修改了源程序当中的什么文件,我们只要执行make命令,我们的编译器都只会去编译和我们修改的文件有关的文件,其它的文件她连理都不想去理的。

下面我们学习Makefile是如何编写的。

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

一般的格式是:target:componentsTAB rule第一行表示的是依赖关系。

第二行是规则。

比如说我们上面的那个Makefile 文件的第二行main:main.o mytool1.o mytool2.o表示我们的目标(target)main的依赖对象(components)是main.o mytool1.o mytool2.o 当倚赖的对象在目标修改后修改的话,就要去执行规则一行所指定的命令。

就象我们的上面那个Makefile第三行所说的一样要执行gcc -o main main.o mytool1.o mytool2.o 注意规则一行中的TAB表示那里是一个TAB键Makefile有三个非常有用的变量。

分别是$@,$^,$&lt;代表的意义分别是:$@--目标文件,$^--所有的依赖文件,$&lt;--第一个依赖文件。

如果我们使用上面三个变量,那么我们可以简化我们的Makefile文件为:# 这是简化后的Makefilemain:main.o mytool1.o mytool2.ogcc -o $@$^main.o:main.c mytool1.h mytool2.hgcc -c $&lt;mytool1.o:mytool1.c mytool1.hgcc -c $&lt;mytool2.o:mytool2.c mytool2.hgcc -c $&lt;经过简化后我们的Makefile是简单了一点,不过人们有时候还想简单一点。

这里我们学习一个Makefile的缺省规则.c.o:gcc -c $&lt;这个规则表示所有的 .o文件都是依赖与相应的.c文件的。

例如mytool.o依赖于mytool.c这样Makefile还可以变为:# 这是再一次简化后的Makefilemain:main.o mytool1.o mytool2.ogcc -o $@ $^.c.o:gcc -c $&lt;好了,我们的Makefile 也差不多了,如果想知道更多的关于Makefile规则可以查看相应的文档。

3.程序库的链接试着编译下面这个程序/* temp.c */#includeint main(int argc,char **argv){double value;printf("Value:%f\n",value);}这个程序相当简单,但是当我们用gcc -o temp temp.c 编译时会出现下面所示的错误。

/tmp/cc33Kydu.o:In function `main':/tmp/cc33Kydu.o(.text+0xe):undefined reference to`log'collect2:ld returned 1 exit status出现这个错误是因为编译器找不到log的具体实现。

虽然我们包括了正确的头文件,但是我们在编译的时候还是要连接确定的库。

在Linux 下,为了使用数学函数,我们必须和数学库连接,为此我们要加入-lm 选项。

gcc -o temp temp.c -lm这样才能够正确的编译。

也许有人要问,前面我们用printf函数的时候怎么没有连接库呢?是这样的,对于一些常用的函数的实现,gcc编译器会自动去连接一些常用库,这样我们就没有必要自己去指定了。

有时候我们在编译程序的时候还要指定库的路径,这个时候我们要用到编译器的-L选项指定路径。

比如说我们有一个库在/home/hoyt/mylib下,这样我们编译的时候还要加上-L/home/hoyt/mylib。

对于一些标准库来说,我们没有必要指出路径。

只要它们在起缺省库的路径下就可以了。

系统的缺省库的路径/lib /usr/lib /usr/local/lib 在这三个路径下面的库,我们可以不指定路径。

还有一个问题,有时候我们使用了某个函数,但是我们不知道库的名字,这个时候怎么办呢?很抱歉,对于这个问题我也不知道答案,我只有一个傻办法。

首先,我到标准库路径下面去找看看有没有和我用的函数相关的库,我就这样找到了线程(thread)函数的库文件(libpthread.a)。

当然,如果找不到,只有一个笨方法。

比如我要找sin这个函数所在的库。

就只好用nm -o /lib/*.so|grep sin&gt;~/sin 命令,然后看~/sin文件,到那里面去找了。

在sin文件当中,我会找到这样的一行libm-2.1.2.so:00009fa0 W sin 这样我就知道了sin在libm-2.1.2.so库里面,我用-lm选项就可以了(去掉前面的lib 和后面的版本标志,就剩下m了所以是-lm)。

如果你知道怎么找,请赶快告诉我,我回非常感激的。

谢谢!4.程序的调试我们编写的程序不太可能一次性就会成功的,在我们的程序当中,会出现许许多多我们想不到的错误,这个时候我们就要对我们的程序进行调试了。

最常用的调试软件是gdb.如果你想在图形界面下调试程序,那么你现在可以选择xxgdb.记得要在编译的时候加入-g选项.关于gdb的使用可以看gdb的帮助文件。

由于我没有用过这个软件,所以我也不能够说出如何使用。

不过我不喜欢用gdb.跟踪一个程序是很烦的事情,我一般用在程序当中输出中间变量的值来调试程序的。

当然你可以选择自己的办法,没有必要去学别人的。

相关文档
最新文档