Linux如何写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表示目标文件列表。
linux makefile中路径写法

linux makefile中路径写法================Makefile在Linux系统中被广泛用于编译和构建项目,它能够自动化地完成许多重复的任务,大大提高了开发效率。
在Makefile中,路径的书写是一个重要的组成部分。
下面我们将详细讨论在Linux Makefile中如何正确地书写路径。
一、绝对路径与相对路径-----------在Makefile中,路径的书写主要有两种方式:绝对路径和相对路径。
1. **绝对路径**:从文件系统的根目录开始的路径。
例如`/home/user/myfile.txt`就是一个绝对路径。
在Makefile中,绝对路径通常是从构建系统的根目录开始的。
2. **相对路径**:相对于当前工作目录的路径。
在Makefile 中,通常使用`./`表示当前目录,`../`表示上级目录。
选择使用绝对路径还是相对路径取决于你的项目结构和开发者的偏好。
一般来说,推荐使用相对路径,因为它们更灵活,可以适应不同的项目目录结构。
二、路径书写规范--------在Makefile中书写路径时,有一些规范和最佳实践需要遵循:1. **文件名**:文件名应该简洁明了,不要使用空格或其他特殊字符。
避免使用长文件名或难以理解的文件名。
2. **目录分隔符**:在Linux系统中,路径的分隔符是反斜杠(`\`)。
当路径包含多个目录时,需要使用两个反斜杠(`\\` 或`/`)。
在Makefile中,推荐使用正斜杠(`/`),因为它在所有平台上都是通用的。
3. **自动更新**:在Makefile中,可以使用`$(wildcard)`函数来匹配目录中的文件。
例如,`$(wildcard source/*.c)`将匹配source目录下的所有C源文件。
4. **构建系统根目录**:在Makefile中,通常使用构建系统的根目录作为路径的起点。
这可以通过变量来实现,例如`ROOT :=/path/to/build`。
Linux之make的用法讲解

Linux之make的⽤法讲解在 Linux环境下使⽤ GNU 的 make⼯具能够⽐较容易的构建⼀个属于你⾃⼰的⼯程,整个⼯程的编译只需要⼀个命令就可以完成编译、连接以⾄于最后的执⾏。
不过这需要我们投⼊⼀些时间去完成⼀个或者多个称之为 Makefile ⽂件的编写。
此⽂件正是 make 正常⼯作的基础。
make 是⼀个命令⼯具,它解释 Makefile 中的指令(应该说是规则)。
在 Makefile⽂件中描述了整个⼯程所有⽂件的编译顺序、编译规则。
准备知识:编译,链接,静态库,共享库编译:把⾼级语⾔所书写的代码转换成机器可识别的指令,此时还不能够被执⾏,编译器通过检查⾼级语⾔的语法,函数和变量的声明是否正确!如果正确则产⽣中间⽬标⽂件(⽬标⽂件在Liunx中默认后缀为“.o”)链接:将多.o ⽂件,或者.o ⽂件和库⽂件链接成为可被操作系统执⾏的可执⾏程序静态库:⼜称为⽂档⽂件(Archive File)。
它是多个.o⽂件的集合。
Linux中静态库⽂件的后缀为“.a”共享库:也是多个.o ⽂件的集合,但是这些.o ⽂件时有编译器按照⼀种特殊的⽅式⽣成(共享库已经具备了可执⾏条件)在执⾏ make 之前,需要⼀个命名为 Makefile 的特殊⽂件(本⽂的后续将使⽤Makefile 作为这个特殊⽂件的⽂件名)来告诉 make 需要做什么(完成什么任务),该怎么做。
当使⽤make ⼯具进⾏编译时,⼯程中以下⼏种⽂件在执⾏make 时将会被编译(重新编译):1.所有的源⽂件没有被编译过,则对各个 C 源⽂件进⾏编译并进⾏链接,⽣成最后的可执⾏程序;2.每⼀个在上次执⾏ make 之后修改过的 C 源代码⽂件在本次执⾏make 时将会被重新编译;3.头⽂件在上⼀次执⾏make 之后被修改。
则所有包含此头⽂件的 C 源⽂件在本次执make 时将会被重新编译。
Makefile规则介绍⼀个简单的 Makefile 描述规则组成:TARGET... : PREREQUISITES...COMMAND......target:规则的⽬标。
linux vscode makefile语法

linux vscode makefile语法在Linux 系统中,如果您想使用VSCode 编写Makefile 相关的项目,可以参考以下步骤进行安装和配置:1. 首先,确保已经正确安装了Visual Studio Code。
如果尚未安装,可以参考[1] 中的教程进行安装。
2. 安装Makefile 插件。
打开VSCode,转到“扩展”选项卡(快捷键:Ctrl+Shift+X),搜索“Makefile”,找到名为“Makefile Support”的插件,点击“安装”。
3. 创建一个新的Makefile 项目。
在VSCode 中,创建一个新的文件夹,然后在该文件夹中打开终端(快捷键:Ctrl+`)。
4. 编写Makefile 语法。
在项目根目录下创建一个名为“Makefile”的文件,然后编写相应的Makefile 语法。
以下是一个简单的示例:```make# 设置变量MY_PROJECT_NAME = MyProjectMY_PROJECT_VERSION = 1.0# 设置目标all: build# 构建目标build:echo "Building $MY_PROJECT_NAME $MY_PROJECT_VERSION"# 在这里添加您的构建命令,例如:cmake、make等# 清理目标clean:echo "Cleaning $MY_PROJECT_NAME"# 在这里添加您的清理命令,例如:rm -rf build/# 默认执行构建目标default: build```5. 保存Makefile 文件并按F5 键运行项目。
VSCode 将会自动使用内置的终端执行Makefile 中的命令。
6. 如果需要使用GPU 加速构建,可以在Makefile 中添加相应的NVIDIA CUDA 或者AMD OpenCL 命令。
例如,如果您使用的是NVIDIA GPU,可以添加以下命令:```makebuild_gpu:echo "Building $MY_PROJECT_NAME $MY_PROJECT_VERSION using GPU"# 在这里添加您的GPU 构建命令,例如:nvcc、cuda编译器等```7. 按照项目需求修改Makefile 中的命令和目标。
makefile编译流程

makefile编译流程Makefile是一种用于自动化编译的工具,它可以根据源代码文件的依赖关系自动编译出目标文件。
Makefile的编写需要遵循一定的规则和语法,下面将介绍Makefile的编译流程。
1. 编写Makefile文件Makefile文件是一个文本文件,其中包含了编译的规则和依赖关系。
在编写Makefile文件时,需要遵循一定的语法规则,如使用TAB键缩进、使用变量和函数等。
2. 执行make命令在Makefile文件所在的目录下执行make命令,make会自动读取Makefile文件,并根据其中的规则和依赖关系进行编译。
如果Makefile文件中没有指定目标,则默认编译第一个目标。
3. 分析依赖关系在执行make命令时,make会先分析Makefile文件中的依赖关系,确定哪些文件需要重新编译。
如果某个源文件被修改了,那么与之相关的目标文件也需要重新编译。
4. 编译源文件在确定需要重新编译的文件后,make会依次编译每个源文件,生成对应的目标文件。
编译过程中,make会根据Makefile文件中的规则和命令进行编译。
5. 链接目标文件在所有的源文件都编译完成后,make会将所有的目标文件链接起来,生成最终的可执行文件。
链接过程中,make会根据Makefile文件中的规则和命令进行链接。
6. 完成编译当所有的源文件都编译完成并链接成功后,make会输出编译成功的信息,并生成最终的可执行文件。
如果编译过程中出现错误,make会输出错误信息并停止编译。
总之,Makefile编译流程是一个自动化的过程,它可以大大提高编译的效率和准确性。
在编写Makefile文件时,需要注意语法规则和依赖关系,以确保编译过程的正确性。
makefile基本使用方法

makefile基本使用方法makefile是一种用来管理和自动化构建程序的工具。
它可以根据源代码文件的依赖关系和编译规则来自动构建目标文件和可执行文件。
makefile的基本使用方法如下:1. 创建makefile文件:在项目的根目录下创建一个名为makefile 的文件。
2. 定义变量:在makefile中,可以使用变量来存储一些常用的参数和路径,以便于后续的使用。
例如,可以定义一个名为CC的变量来指定编译器的名称,如:CC=gcc。
3. 编写规则:在makefile中,可以使用规则来指定如何编译源代码文件和生成目标文件。
一个规则由两部分组成:目标和依赖。
目标是要生成的文件,依赖是生成目标文件所需要的源代码文件。
例如,可以编写以下规则:```target: dependency1 dependency2command1command2```其中,target是目标文件,dependency1和dependency2是依赖的源代码文件,command1和command2是生成目标文件所需要执行的命令。
4. 编写默认规则:在makefile中,可以使用一个默认规则来指定如何生成最终的可执行文件。
默认规则的目标通常是可执行文件,依赖是所有的源代码文件。
例如,可以编写以下默认规则:```all: target1 target2```其中,target1和target2是生成的目标文件。
5. 编写clean规则:在makefile中,可以使用clean规则来清理生成的目标文件和可执行文件。
例如,可以编写以下clean规则: ```clean:rm -f target1 target2```其中,target1和target2是要清理的目标文件。
6. 运行make命令:在命令行中,使用make命令来执行makefile 文件。
make命令会自动根据规则和依赖关系来编译源代码文件和生成目标文件。
例如,可以运行以下命令:``````make命令会根据makefile文件中的规则和依赖关系来编译源代码文件并生成目标文件和可执行文件。
Linux下C语言多文件的编译以及makefile的应用
Linux下C语⾔多⽂件的编译以及makefile的应⽤1.关于编译和链接⼀般来说,⽆论是C、C++,⾸先要把源⽂件编译成中间代码⽂件,在Windows下也就是.obj⽂件,UNIX下是.o⽂件,即Object File,这个动作叫做编译(compile)。
然后再把⼤量的Object File合成执⾏⽂件,这个动作叫作链接(link)。
也就是源⽂件(.c ⽂件或者.cpp⽂件)⾸先会⽣成中间⽬标⽂件,再由中间⽬标⽂件⽣成执⾏⽂件。
在编译时,编译器只检测程序语法,和函数、变量是否被声明。
如果函数未被声明,编译器会给出⼀个警告,但可以⽣成Object File。
⽽在链接程序时,链接器会在所有的Object File中找寻函数的实现,如果找不到,那到就会报链接错误码(Linker Error)。
2.使⽤命令编译链接 如果使⽤命令编译,过程⽐较⿇烦。
假如我有三个.h的头⽂件和四个.c的代码⽂件。
⾸先将这七个⽂件放到⼀个⽂件夹⾥(这⾥只介绍简单应⽤,所以放在⼀个⽂件夹,以后慢慢填坑)如下图。
接下来打开终端,并转到这个⽂件夹。
然后在终端输⼊gcc -c main.cgcc -c AAA.cgcc -c BBB.cgcc -c CCC.c 这样就把四个⽂件编译完成,查看⽂件会出现四个.o⽂件(下图) 接下来链接即可。
在终端输⼊gcc main.o AAA.o BBB.o CCC.o -o main 就可以⽣成可执⾏⽂件 main 这样执⾏ ./main即可。
整个执⾏过程如下:3.使⽤make编译链接虽然上述⽅式可以实现,但是只要修改⽂件就需要重新编译链接,特别⿇烦。
⽤makefile实现更为巧妙。
先放出⼀种写法,如果仅是为了执⾏⾃⼰的代码可以先看⼀下,后⾯的坑慢慢补。
objects = main.o AAA.o BBB.o CCC.occ = gccedit : $(objects)cc -o edit $(objects)main.o : main.cAAA.o : AAA.c AAA.hBBB.o : BBB.c BBB.hCCC.o : CCC.c CCC.h.PHONY : cleanclean :rm edit main.o AAA.o BBB.o CCC.o这样可以直接运⾏,我将刚才⽣成的编译链接⽂件删掉然后重新运⾏之后如果在make的时候出现makefile:3: *** missing separator:原因是丢失了tab键,每⼀条命令在执⾏的时候需要⼀个tab键。
linux下makefile文件中比较大小的语法
linux下makefile文件中比较大小的语法在Linux下,Makefile是一种常用的构建工具,用于自动化编译和构建软件项目。
在Makefile中,我们经常需要比较文件的大小来判断是否需要重新编译或执行某些操作。
本文将介绍在Linux下Makefile 文件中比较大小的语法。
在Makefile中,我们可以使用shell命令来执行系统命令。
比较文件大小的常用命令是`stat`和`du`。
`stat`命令用于获取文件的详细信息,包括文件大小,而`du`命令用于计算文件或目录的大小。
首先,我们可以使用`stat`命令获取文件的大小,并将结果保存到一个变量中。
下面是一个示例:```file_size := $(shell stat -c %s file.txt)```上述命令将获取文件`file.txt`的大小,并将结果保存到变量`file_size`中。
`-c %s`选项用于指定输出文件大小的格式。
接下来,我们可以使用条件语句来比较文件大小。
常用的条件语句有`ifeq`和`ifneq`。
下面是一个示例:```ifeq ($(file_size), 0)@echo "文件为空"else@echo "文件大小为$(file_size)字节"endif```上述代码将判断文件大小是否为0,如果是,则输出"文件为空",否则输出"文件大小为$(file_size)字节"。
`@echo`命令用于输出信息,`$(file_size)`表示变量的值。
除了使用`stat`命令获取文件大小外,我们还可以使用`du`命令计算文件或目录的大小。
下面是一个示例:```file_size := $(shell du -b file.txt | cut -f1)```上述命令将使用`du`命令计算文件`file.txt`的大小,并使用`cut`命令提取文件大小。
简单制作Makefile方法
1.在当前目录下创建一个名为hello的子目录。hello这个目录用于存放hello.c这个程序及相关文件。新建一个源程序文件hello.c
#include <stdio.h>
int main(int argc, char** argv)
{
printf("Welcome to use autoconf and automake\n");
通过以上步骤,在源代码所在目录下自动生成了Makefile文件。
configure.in文件
autoconf提用来产生"configure"文件的工具。"configure"是一个Shell脚本,它可以自动设定一些编译参数使程序能够在不同平台上进行编译。autoconf读取configure.in文件然后产生,"configure"这个Shell脚本。
如何使用产生的Makefile文件
执行configure脚本文件所产生的Makefile文件有几个预定的选项可供使用。
l make all:产生设定的目标,即生成所有的可执行文件。使用make也可以达到此目的。
l make clean:删除之前编译时生成的可执行文件及目标文件(形如*.o的中间文件)。
configure.in文件的内容是一系列GNU m4的宏,这些宏经autoconf理后会变成检查系统特性的Shell脚本。configure.in文件中宏的顺序并没有特别的规定,但是每一个configure.in文件必须以宏AC_INIT开头,以宏AC_OUTPUT结束。一般可先用autoscan这个工具扫描原始文件以产生一个configure.scan文件,再对configure.scan作些修改,从而生成configure.in文件
(完整版)浅谈手动书写Makefile与自动生成Makefile
最近一直在搞Makefile文件的编辑,一直想通过自己的心得体会与广大网友分享。
Linux学习者只有参与的大多人当中去,才能体会到乐趣。
同时慢慢培养自己的学习linux的兴趣爱好。
与广大网上爱好者互动。
Linux的GNU计划:Linux下构建自己的开源软件使用的是linux下自己带的强大的工具。
Autoconf libtoolize 和automake .这是开源软件必须的基本工具。
如果使用了autoconf和automake,除了编译应用程序,用户并不需要有这些工具。
使用这些工具的目的是创建能在用户环境使用的、可移植的shell脚本和Makefile文件。
Autoconf实际上是一个工具集,其中包含aclocal、autoheader和autoconf等可执行文件。
这些工具生成一个可移植的shell脚本—configure,configure和软件包一起发布给用户。
它探查编译系统,生成Makefile文件和一个特殊的头文件config.h。
由configure生成的文件能适应用户系统的特定环境。
configure脚本从一个称为Makefile.in的模板文件生成每个Makefile文件。
而Makefile.in 有Makefile.am 生成。
Configure.in 有开发者自己手动修改。
Makefile.am 是由开发者自己手写。
Libtool软件包是第三个重要的GNU工具,它的作用是确定共享库在特定平台上的特性。
因为共享库在不同平台上可能会有所不同。
上述是自动生成Makefile的概括。
以后再细讲。
手动书写Makefile:手动书写顾名思义就是自己跳过configure.Scan configure.in configure Makefile.am Makefile.in 的生成过程。
直接书写Makefile 这种方式只能用于相对简单的源代码。
如有几个,几十个或者上百个源文件时,自己编写Makefile往往是可行的,但是如果我们所编写的源文件有几千,几万,几十万甚至更多时,显然手动书写Makefile不是个明智之举。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
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个C文件,和3个头文件,我们要写一个Makefile来告诉make命令如何编译和链接这几个文件。
我们的规则是:1)如果这个工程没有编译过,那么我们的所有C文件都要编译并被链接。
2)如果这个工程的某几个C文件被修改,那么我们只编译被修改的C文件,并链接目标程序。
3)如果这个工程的头文件被改变了,那么我们需要编译引用了这几个头文件的C文件,并链接目标程序。
只要我们的Makefile写得够好,所有的这一切,我们只用一个make命令就可以完成,make命令会自动智能地根据当前的文件修改的情况来确定哪些文件需要重编译,从而自己编译所需要的文件和链接目标程序。
一、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.occ -o edit main.o kbd.o command.o display.o \insert.o search.o files.o utils.omain.o : main.c defs.hcc -c main.ckbd.o : kbd.c defs.h command.hcc -c kbd.ccommand.o : command.c defs.h command.hcc -c command.cdisplay.o : display.c defs.h buffer.hcc -c display.cinsert.o : insert.c defs.h buffer.hcc -c insert.csearch.o : search.c defs.h buffer.hcc -c search.cfiles.o : files.c defs.h buffer.h command.hcc -c files.cutils.o : utils.c defs.hcc -c utils.cclean :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文件和prerequisites文件的修改日期,如果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.occ -o edit main.o kbd.o command.o display.o \insert.o search.o files.o utils.o我们可以看到[.o]文件的字符串被重复了两次,如果我们的工程需要加入一个新的[.o]文件,那么我们需要在两个地方加(应该是三个地方,还有一个地方 在clean中)。