(基础篇)讲稿-makefile及交叉开发环境
LINUX 开发环境搭建与MAKEFILE设计原理与应用
Linux开发环境搭建与Makefile设计原理与应用课时一：Linux开发环境的搭建1、linux程序编译与windows程序的区别：2、linux下编译器的安装：linux下程序的安装：通常Linux应用软件的安装包有三种：1）tar包，如software-1.2.3-1.tar.gz。
它是使用UNIX系统的打包工具tar打包的。
2）rpm包，如software-1.2.3-1.i386.rpm。
它是Redhat Linux提供的一种包封装格式。
3）dpkg包，如software-1.2.3-1.deb。
它是Debain Linux提供的一种包封装格式。
而且，大多数Linux应用软件包的命名也有一定的规律，它遵循：名称-版本-修正版-类型例如：1）software-1.2.3-1.tar.gz意味着：软件名称：software版本号：1.2.3修正版本：1类型：tar.gz，说明是一个tar包。
2）sfotware-1.2.3-1.i386.rpm软件名称：software版本号：1.2.3修正版本：1可用平台：i386，适用于Intel80x86平台。
类型：rpm，说明是一个rpm包。
注：由于rpm格式的通常是已编译的程序，所以需指明平台先来看看Linux软件扩展名：软件后缀为.rpm最初是Red Hat Linux提供的一种包封装格式，现在许多Linux发行版本都使用；后缀为.deb是Debain Linux提供的一种包封装格式；后缀为.tar.gz、tar.Z、tar.bz2或.tgz是使用Unix系统打包工具tar打包的；后缀为.bin的一般是一些商业软件。
具体的安装简介：一、RPM格式软件包的安装：1.简介几乎所有的Linux发行版本都使用某种形式的软件包管理安装、更新和卸载软件。
与直接从源代码安装相比，软件包管理易于安装和卸载；易于更新已安装的软件包；易于保护配置文件；易于跟踪已安装文件。
交叉编译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简介
Makefile简介⼀、为什么要写Makefile⾸先要确定我们的⽬标，Makefile是⽤来⼲嘛的？曾经很长时间我都是在从事Windows环境下的开发，所以根本不知道Makefile是个什么东西。
因为早已经习惯了使⽤VS、Eclipse等等优秀的IDE做开发，只要点⼀个按钮，程序就可以运⾏啦。
但是进⼊公司以后，从事的是Unix环境下的开发⼯作，没有了IDE，要怎么才能让我写的代码编译后运⾏呢？在这⾥，Makefile的作⽤就体现出来了，简单的四个字—— “⾃动编译”。
⼀旦整个项⽬的Makefile都写好了以后，只需要⼀个简单的make命令，就可以实现⾃动编译了。
当然，准确的说，是make这个命令⼯具帮助我们实现了我们想要做的事，⽽Makefile就相当于是⼀个规则⽂件，make程序会按照Makefile所指定的规则，去判断哪些⽂件需要先编译，哪些⽂件需要后编译，哪些⽂件需要重新编译。
俗话说，懒⼈创造了整个世界，程序员就是在不断偷懒的过程中获得进步，使⽤Makefile最根本的⽬的就是简化我们的⼯作。
下⾯我们就从头开始，⼀步⼀步的去学习如何写好⼀个Makefile⽂件吧！⼆、从单个⽂件开始1、单个⽂件的编译为了便于⼤家学习，这篇⽂章是以常见的LInux平台为基础的，系统为Centos6.5，使⽤GNU make⼯具进⾏编译，项⽬⽂件为C++格式。
这⾥假定看到这篇⽂章的都是已经对C++程序的编译等基础知识和相关命令有了⼀定的了解的，鉴于篇幅限制，如果还有不清楚的就请⾃⾏查阅相关资料啦。
假设我们在src⽬录下有⼀个test.cpp⽂件，我们是如何编译它的呢？g++-o test test.cpp在shell界⾯执⾏这句命令，当前⽬录下会⽣成⼀个名为test的可执⾏程序，使⽤./test就可以执⾏该程序，看到输出结果。
现在我们尝试使⽤编写Makefile的⽅式来实现这⼀编译过程。
⾸先在当前⽬录下新建⽂件并命名为“Makefile”，这样编译的时候直接使⽤gmake命令即可，默认使⽤“Makefile”⽂件进⾏编译，也可以是其他名字，那样的话需要使⽤“gmake -f ⽂件名”的格式来指定Makefile⽂件。
讲义3-4-Makefile
韩永昌
什么是编译?
• 编译就是将人们熟悉的语言(高级语言)转换 成计算机熟悉的语言(2进制) • 几个概念：源程序（代码/文件）/source code
编译程序（器）/compiler 目标程序（文件）/object file 库（文件）/Library file file
• 把 ifort 体换成 gfortran • 增加了新的目标文件，只需要调整obj变量 的定义和对应目文件的编译项 • make clean命令 （clean：伪目标）
makefile中使用变量
• 我们可以看到[.o]文件的字符串被重复了两次，如果我们 的工程需要加入一个新的[.o]文 件，那么我们需要在两个 地方加。当然，我们的makefile并不复杂，所以在两个地 方加也不累，但如果 makefile变得复杂，那么我们就有可 能会忘掉一个需要加入的地方，而导致编译失败。所以， 为了makefile的易维护，在makefile中我们 可以使用变量。 makefile的变量也就是一个字符串，理解成C语言中的宏可 能会更好。
小结
• 源文件首先会生成中间目标文件，再由中间目标 文件生成执行文件。在编译时，编译器只检测程 序语法，和函数（子程序）、变量是否被声明。 如果函数未被声明，编译器会给出一个警告，但 可以生成Object File。而在链接程序时，链接器会 在所有的Object File中找寻函数的实现，如果找不 到，那到就会报链接错误码（Linker Error），在 VC下，这种错误一般是：Link 2001错误，意思说 是说，链接器未能找到函数的实现。你需要指定 函数的Object File.
• • • • •
source code：.f90, .for, .f, .c compiler：ifort, gfortran, cc object file：.o Library file：.a executable file：任意扩展名，.exe, .x
makefile详解
makefile详解makefile⼀、初识makefile想要掌握makefile，⾸先需要了解两个概念，⼀个是⽬标（target），另⼀个就是依赖（dependency）。
⽬标就是指要⼲什么，或说运⾏ make 后⽣成什么，⽽依赖是告诉 make 如何去做以实现⽬标。
在 Makefile 中，⽬标和依赖是通过规则（rule）来表达的。
（⼀）、⽬标⾸次编写makefileall:echo "Hello world"上⾯Makefile 中的 all 就是我们的⽬标，⽬标放在‘：’的前⾯，其名字可以是由字⺟和下划线‘_’组成。
echo “Hello World”就是⽣成⽬标的命令，这些命令可以是任何你可以在你的环境中运⾏的命令以及 make 所定义的函数等等。
all ⽬标的定义，其实是定义了如何⽣成 all ⽬标，这我们也称之为规则.makefile定义多个⽬标all:echo "Hello world"test:echo "test game"下⾯是运⾏的结果由此可见，⼀个 Makefile 中可以定义多个⽬标。
调⽤ make 命令时，我们得告诉它我们的⽬标是什么，即要它⼲什么。
当没有指明具体的⽬标是什么时，那么 make 以 Makefile ⽂件中定义的第⼀个⽬标作为这次运⾏的⽬标。
这“第⼀个”⽬标也称之为默认⽬标（和是不是all没有关系）。
当 make 得到⽬标后，先找到定义⽬标的规则，然后运⾏规则中的命令来达到构建⽬标的⽬的。
makefile中取消多余的命令⾏显⽰在上⾯的指令中，多了很多的echo "......"的内容，这部分不是我们所期望的，如果要去掉，需要对上⾯的makefile进⾏⼀个改动，也就是在命令前加上⼀个@，这个符号就是告诉make，在运⾏的时候这⼀⾏命令不显⽰出来。
all:@echo "Hello world"test:@echo "test game"运⾏结果：紧接着对makefile进⾏如下的改动，在all的后⾯加上testall: test@echo "Hello world"test:@echo "test game"运⾏结果如下：如上图所⽰，此时test也被构建了。
makefile入门 PPT课件
makefile：编译使用的文件二 • :=和=的区别：
Q&A
谢谢！
隐式规则 • 看如下的一个编译规则： %.o : %.c $(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o $@ %.o（目标，target） : %.c（依赖， prerequisites ） 是表示把所有的[.c]文件都编译成[.o]文件； $< 是每次匹配到的那个依赖文件 $@ 是每次匹配到的那个目标文件
• 什么是makefile
• 分析一个简单的makefile
makefile的基本结构 helloworld的makefile
• Makefile中经常用到的知识 • 我们常用的makefile是如何组成的
• 什么是makefile • 分析一个简单的makefile
• Makefile中经常用到的知识
• 什么是makefile • 分析一个简单的makefile • Makefile中经常用到的知识
• 我们常用的makefile是如何组成的
m：通用库调用路径 makefile：编译使用的文件
m：通用库调用路径 • “-I” ：定义了你自己的头文件的存储目录。 • “-L”：定义了你自己的库文件存放目录。 • Make中可以定义变量，直接赋值就可以了： ARPS_ROOT = /home/yedeng/arps • 引用变量使用$(APRS_ROOT)，make会自动进行替 换。将$(APRS_ROOT)用“/home/yedeng/arps”来代 替。 实际看我们用的一个m：打开文件
makefile基础教程-GNUmake介绍
第二章：GNU make 介绍make在执行时，需要一个命名为Makefile的文件。
这个文件告诉make以何种方式编译源代码和链接程序。
典型地，可执行文件可由一些.o文件按照一定的顺序生成或者更新。
如果在你的工程中已经存在一个活着多个正确的Makefile。
当对工程中的若干源文件修改以后，需要根据修改来更新可执行文件或者库文件，正如前面提到的你只需要在shell下执行“make”。
make会自动根据修改情况完成源文件的对应.o文件的更新、库文件的更新、最终的可执行程序的更新。
make通过比较对应文件（规则的目标和依赖，）的最后修改时间，来决定哪些文件需要更新、那些文件不需要更新。
对需要更新的文件make就执行数据库中所记录的相应命令（在make读取Makefile以后会建立一个编译过程的描述数据库。
此数据库中记录了所有各个文件之间的相互关系，以及它们的关系描述）来重建它，对于不需要重建的文件make什么也不做。
而且可以通过make的命令行选项来指定需要重新编译的文件。
Problems and Bugs=================If you have problems with GNU `make' or think you've found a bug, please report it to the developers; we cannot promise to do anything but we might well want to fix it.Before reporting a bug, make sure you've actually found a real bug.Carefully reread the documentation and see if it really says you can do what you're trying to do. If it's not clear whether you should be able to do something or not, report that too; it's a bug in the documentation!Before reporting a bug or trying to fix it yourself, try to isolate it to the smallest possible makefile that reproduces the problem. Then send us the makefile and the exact results `make' gave you, including any error or warning messages. Please don't paraphrase these messages: it's best to cut and paste them into your report. When generating this small makefile, be sure to not use any non-free or unusual tools in your commands: you can almost always emulate what such a tool would do with simple shell commands. Finally, be sure to explain what you expected to occur; this will help us decide whether the problem was really in the documentation.Once you have a precise problem you can report it in one of two ways.Either send electronic mail to:bug-make@or use our Web-based project management tool, at:/projects/make/In addition to the information above, please be careful to include the version number of `make' you are using. You can get this information with the command `make --version'. Be sure also to include the type of machine and operating system you are using. One way to obtain this information is by looking at the final lines of output from the command`make --help'.以上时GNU make的bug反馈方式。
Makefie技术详解
makefile 基本结构
上例注意到，第一个字符为 # 的行为注释行。第一个非注释行指定 test.o 为目标，并且依赖于test.C 和 test.h 文件。随后的行指定了如何从目标所 依赖的文件建立目标。 当 test.C 或 test.h 文件在编译之后又被修改，则 make 工具可自动重新编 译 test.o，如果在前后两次编译之间，test.C 和 test.h 均没有被修改，而 且 test.o 还存在的话，就没有必要重新编译。这种依赖关系在多源文件的 程序编译中尤其重要。通过这种依赖关系的定义，make 工具可避免许多不 必要的编译工作。当然，利用 Shell 脚本也可以达到自动编译的效果，但是 ，Shell 脚本将全部编译任何源文件，包括哪些不必要重新编译的源文件， 而 make 工具则可根据目标上一次编译的时间和目标所依赖的源文件的更 新时间而自动判断应当编译哪个源文件。 一个 makefile 文件中可定义多个目标，利用 make target 命令可指定要编 译的目标，如果不指定目标，则使用第一个目标。通常，makefile 中定义 有 clean 目标，可用来清除编译过程中的中间文件，例如： clean: rm -f *.o 运行 make clean 时，将执行 rm -f *.o 命令，最终删除所有编译过程中产 生的所有中间文件。
Makefile示例
1. 多模块项目编译示例 2. 多模块项目共享库编译与使用示例
多模块项目编译示例
• 在示例中有三个模块，它们分别是f1.c，f2.c和f3.c，它 们之间的关系如下图
多模块项目编译示例
项目编译过程分析
按照gcc的工作过程，对模块的编译和链接过程可分为： (1)生成目标代码 gcc -c f1.c gcc -c f2.c gcc -c f3.c (2) 生成可执行程序 gcc -o f f1.o f2.o f3.o
makefile概述
makefile概述【原创实用版】目录1.Makefile 的定义和作用2.Makefile 的组成部分3.Makefile 的执行过程4.Makefile 的优点和应用场景正文1.Makefile 的定义和作用Makefile 是一种用于自动化构建和编译软件的脚本文件，通常用于Unix 和类 Unix 系统，如 Linux 和 macOS。
它定义了一组规则，用于描述如何从源代码文件编译和构建可执行文件、库和文档。
通过使用Makefile，开发者可以轻松地管理项目的构建过程，确保在修改源代码时，只需重新编译受影响的部分，而无需重新编译整个项目。
2.Makefile 的组成部分一个典型的 Makefile 主要包括以下几个部分：（1）变量定义：用于存储项目的配置信息，例如编译器、编译选项和目标文件的路径等。
（2）规则：描述如何将源文件编译成目标文件。
规则通常包含两个部分：依赖项和目标。
依赖项是源文件，目标是编译后生成的文件。
（3）操作：定义了如何处理依赖项和目标的命令。
例如，使用编译器编译源文件或链接目标文件。
（4）伪目标：用于指定构建过程中的特定阶段，例如编译、测试或安装。
3.Makefile 的执行过程当开发者修改源代码文件时，Makefile 会自动执行以下步骤：（1）读取 Makefile 中的变量定义，以获取项目的配置信息。
（2）解析 Makefile 中的规则，确定哪些依赖项需要更新。
（3）根据规则中的操作，编译源文件并生成目标文件。
（4）更新 Makefile 中的伪目标，以反映构建过程的当前阶段。
（5）重复步骤 2-4，直到没有更多的依赖项需要更新。
4.Makefile 的优点和应用场景Makefile 具有以下优点：（1）简化构建过程：Makefile 可以自动化编译、链接和安装等任务，从而减轻开发者的负担。
（2）易于维护：通过使用变量定义和规则，Makefile 可以轻松地管理项目的构建过程。
Linux程序设计基础—Makefile
Makefile 的基本结构（1/2）
• Makefile是一个文本形式的数据库文件，其中包含一些规 则来告诉make处理哪些文件以及如何处理这些文件。 • 规则主要是描述哪些文件是从哪些别的文件（称为 dependency依赖文件）中产生的，以及用什么命令 （command）来执行这个过程。 • 依靠这些信息，make会对磁盘上的文件进行检查，如果 目标文件的生成或被改动时的时间（称为该文件时间戳） 至少比它的一个依赖文件还旧的话，make就执行相应的 命令，以更新目标文件。 • 目标文件不一定是最后的可执行文件，可以是任何一个中 间文件并可以作为其他目标文件的依赖文件。
– 自动变量 – 预定义变量
GNU make 的主要预定义变量
$* $+ 不包含扩展名的目标文件名称。 所有的依赖文件，以空格分开，并以出现的先后为序，可能包含 重复的依赖文件。 $< 第一个依赖文件的名称。 $? 所有的依赖文件，以空格分开，这些依赖文件的修改日期比目标 的创建日期晚。 $@ 目标的完整名称。 $^ 所有的依赖文件，以空格分开，不包含重复的依赖文件。 $% 如果目标是归档成员，则该变量表示目标的归档成员名称。例如， 如果目标名称 为 mytarget.so(image.o)，则 $@ 为 mytarget.so， 而 $% 为 image.o。 AR 归档维护程序的名称，默认值为 ar。 ARFLAGS 归档维护程序的选项。 AS 汇编程序的名称，默认值为 as。 ASFLAGS 汇编程序的选项。
Makefile 的基本结构（2/2）
• Makefile规则的一般形式如下： target：dependency dependency (tab)<command> • 一个Makefile文件主要含有一系列的规则，每条规则包含以下内容。 – 一个目标（target），即make最终需要创建的文件，如可执行文 件和目标文件；目标也可以是要执行的动作，如“clean”。 – 一个或多个依赖文件（dependency）列表，通常是编译目标文 件所需要的其他文件。 – 一系列命今(command)，是make执行的动作，通常是把指定的 相关文件编译成目标文件的编译命令，每个命令占一行，且每个 命令行的起始字符必须为TAB字符。 • 除非特别指定，否则make的工作目录就是当前目录。target是需要 创建的二进制文件或目标文件，dependency是在创建target时需要 用到的一个或多个文件的列表，命令序列是创建target文件所需要执 行的步骤，比如编译命令。
Makefile
定义
概述
Linux环境下的程序员如果不会使用GNU make来构建和管理自己的工程，应该不能算是一个合格的专业程序 员，至少不能称得上是 Unix程序员。在 Linux（unix ）环境下使用GNU的make工具能够比较容易的构建一个属 于你自己的工程，整个工程的编译只需要一个命令就可以完成编译、连接以至于最后的执行。不过这需要我们投 入一些时间去完成一个或者多个称之为Makefile文件的编写。
在 UNIX系统中，习惯使用 Makefile作为 makefile文件。如果要使用其他文件作为 makefile，则可利用 类似下面的 make命令选项指定 makefile文件：
make命令
$ make -f Makefile.debug
Makefile文件工程样例例如，一个名为prog的程序由三个C源文件filea.c、fileb.c和filec.c以及库文件 LS编译生成，这三个文件还分别包含自己的头文件a.h、b.h和c.h。通常情况下，C编译器将会输出三个目标文件 filea.o、fileb.o和filec.o。假设filea.c和fileb.c都要声明用到一个名为defs的文件，但filec.c不用。即 在filea.c和fileb.
所要完成的Makefile文件描述了整个工程的编译、连接等规则。其中包括：工程中的哪些源文件需要编译以 及如何编译、需要创建哪些库文件以及如何创建这些库文件、如何最后产生我们想要的可执行文件。尽管看起来 可能是很复杂的事情，但是为工程编写Makefile的好处是能够使用一行命令来完成“自动化编译”，一旦提供一 个（通常对于一个工程来说会是多个）正确的 Makefile。编译整个工程你所要做的事就是在shell提示符下输入 make命令。整个工程完全自动编译，极大提高了效率。
C++关于Makefile的详解含通用模板
C++关于Makefile的详解含通⽤模板介绍Makefile是⼀个规定了怎么去编译和链接程序的脚本⽂件，在执⾏make命令时会执⾏该⽂件，window环境下的IDE，如visual studio已经集成了该功能，不需要关⼼程序的编译规则，在linux下做C/C++开发时经常⽤到，说到这⾥⾸先要知道⼀个⼯具make。
make是⼀个解释Makefile中指令的命令⼯具，常见的IDE都集成了这个⼯具。
⽬前centos 7.3 GNU的make版本是3.82规则⽬标⽂件：依赖⽂件[Tab]系统指令1 (注意：系统指令前必须有tab)使⽤3.1 简单使⽤现有⽂件main.cpp test.cpp test.h三个⽂件，说些Makefile实现增量编译(当其中有⼀个⽂件变化时，重新编译该⽂件) helloworld: main.o test.og++ main.o test.o -o helloworldmain.o: main.cpp test.hg++ -c main.cpp -o main.otest.o: test.cpp test.hg++ -c test.cpp -o test.oclean:rm *.o helloworld3.2 makefile中使⽤注释，变量和函数注释：⾏前⾯加"#"号，如#g++ main.o test.o -o helloworld 表⽰注释了该⾏变量：⽤=定义⼀个变量，并且赋值(等号两边可以加空格)⽤+=追加字符串⽤$(A)来取得变量的值例：A = srcecho $(A)@echo $(A) ##只输出echo的结果，不显⽰执⾏的命令特殊变量：$@ ⽬标⽂件$^ 依赖项列表$< 依赖项列表第⼀项函数：Makefile中有⼀些预定义函数，形式：$(函数名参数列表)参数列表：以逗号分隔函数名和参数之间⽤空格分开#获取当前⽬录路径PWD = $(shell pwd)#获取当前⽬录下所有.cpp⽂件CXX_SOURCES = $(wildcard *.cpp)#获取当前⽬录下所有.cpp⽂件编译后的所有⽬标⽂件.oCXX_OBJECTS = $(patsubst *.cpp *.o, $(CXX_SOURCES))3.3 优化3.1中MakefileEXE = helloworldGCC = g++$(EXE): main.o test.o$(GCC) $^ -o $(EXE)main.o: main.cpp test.h$(GCC) -c $< -o $@test.o: test.cpp test.h$(GCC) -c $< -o $@clean:rm *.o $(EXE)3.4 优化3.3中Makefile继续优化Makefile，添加⽂件夹，把源码都放⼊src和lib⽂件夹,保持增量编译，即为Makefile通⽤模板EXE = helloworldGCC = g++SUBDIR = src libCPP_SOURCES = $(foreach dir, $(SUBDIR), $(wildcard $(dir)/*.cpp))CPP_OBJECTS = $(patsubst %.cpp, %.o, $(CPP_SOURCES))DEP_FILES = $(patsubst %.o, %.d, $(CPP_OBJECTS))$(EXE): $(CPP_OBJECTS)$(GCC) $(CPP_OBJECTS) -o $@%.o: %.cpp$(GCC) -c -MMD $< -o $@-include $(DEP_FILES)clean:rm $(CPP_OBJECTS) $(EXE)此Makefile可以作为通⽤Makefile模板来编译C/C++项⽬，欢迎收藏总结以上就是这篇⽂章的全部内容了，希望本⽂的内容对⼤家的学习或者⼯作具有⼀定的参考学习价值，谢谢⼤家对的⽀持。
makefile基础
makefile基础Makefile是一种用于自动化编译和构建程序的工具。
它可以根据源代码的依赖关系自动编译和链接程序，从而简化了程序的构建过程。
本文将介绍Makefile的基础知识，包括Makefile的语法、变量、规则和函数等。
一、Makefile的语法Makefile的语法比较简单，它由一系列规则组成，每个规则包含一个目标、依赖和命令三部分。
例如：```target: dependency1 dependency2command1command2```其中，target表示目标文件，dependency1和dependency2表示依赖文件，command1和command2表示执行的命令。
注意，命令必须以一个Tab键开始，否则会报错。
二、Makefile的变量Makefile中可以定义变量，用于存储一些常用的值，例如编译器的路径、编译选项等。
定义变量的语法如下：```variable = value```其中，variable表示变量名，value表示变量的值。
在Makefile中使用变量的语法如下：```$(variable)```例如：```CC = gccCFLAGS = -Wall -O2target: dependency$(CC) $(CFLAGS) -o target dependency```其中，CC表示编译器的路径，CFLAGS表示编译选项，$(CC)和$(CFLAGS)表示使用变量的值。
三、Makefile的规则Makefile中的规则用于描述目标文件和依赖文件之间的关系。
常用的规则包括：1. all规则：用于指定默认的目标文件，例如：```all: target```2. clean规则：用于清除生成的目标文件，例如：```clean:rm -f target```3. .PHONY规则：用于声明一个伪目标，例如：```.PHONY: clean```四、Makefile的函数Makefile中还提供了一些函数，用于处理字符串、文件名等。
Makefile语法简介
Makefile 一个语法简介Linux/Unix环境下的mak e和mak efile详解Pathet ique无论是在Li nux还是在Unix环境中，make都是一个非常重要的编译命令。
不管是自己进行项目开发还是安装应用软件，我们都经常要用到mak e或mak e instal l。
利用make 工具，我们可以将大型的开发项目分解成为多个更易于管理的模块，对于一个包括几百个源文件的应用程序，使用make和make file工具就可以简洁明快地理顺各个源文件之间纷繁复杂的相互关系。
而且如此多的源文件，如果每次都要键入gcc命令进行编译的话，那对程序员来说简直就是一场灾难。
而make工具则可自动完成编译工作，并且可以只对程序员在上次编译后修改过的部分进行编译。
因此，有效的利用m ake和m akefi le工具可以大大提高项目开发的效率。
同时掌握ma ke和ma kefil e之后，您也不会再面对着Lin ux下的应用软件手足无措了。
但令人遗憾的是，在许多讲述L inux应用的书籍上都没有详细介绍这个功能强大但又非常复杂的编译工具。
在这里我就向大家详细介绍一下ma ke及其描述文件ma kefil e。
Makefi le文件Make工具最主要也是最基本的功能就是通过makef ile文件来描述源程序之间的相互关系并自动维护编译工作。
而makef ile 文件需要按照某种语法进行编写，文件中需要说明如何编译各个源文件并连接生成可执行文件，并要求定义源文件之间的依赖关系。
makefi le 文件是许多编译器--包括Window s NT 下的编译器--维护编译信息的常用方法，只是在集成开发环境中，用户通过友好的界面修改 makefi le 文件而已。
makefile讲解(课堂PPT)
Makefile的引用函数
• 调用语法
$(<function> <arguments> ) ${<function> <arguments>}
<function>函数名 <arguments>函数的参数
• 语法要求
参数间以逗号“,”分隔 函数名和参数之间以“空格”分隔 函数调用以“$”开头， 以圆括号或花括号把函数名和参数括起
targets : prerequisites ; command command
targets－－ －－ 文件名，以空格分开 prerequisites－－目标所依赖的文件，以空格分开多个文件 command－－ －命令行， [Tab键]开头，用分号做为分隔
12
Makefile的引用文件
• include <filename1> <filename2>
17
Makefile的引用函数
• 调用举例
$(subst <from>,<to>,<text> )
名称：字符串替换函数——subst。 功能： <from>--被替换前的字符串
<to>------ 被替换后的字符串 <text>-----被替换的字串
$(subst ee,EE,feet on the street) 原为feet on the street 调用函数后为fEEt on the street
15
Makefile的条件语法
• ifeq (<arg1>, <arg2> )
比较两个参数的值是否相同，相同为真
C++学习进阶之Makefile基础用法详解
$(TARGET):$(TESTOBJ) $(LIB) $(CXX) $< -o $@ $(LDFLAGS) $(LDLIBS)
$(LIB):$(OBJS) $(CXX) -shared $^ -o $@
$(TESTOBJ) $(OBJS):%.o:%.cpp $(CXX) $(CXXFLAGS) $< -o $@
makefile 文件可改为：
TARGET = simpletest OBJS = simple.o simpletest.o
$(TARGET):$(OBJS) g++ $(OBJS) -o $(TARGET)
simple.o:simple.cpp simpletest.o:simpletest.cpp clean:
绝大多数的 IDE 开发环境都会为用户自动编写 Makefile。
Make 是怎么工作的？
Make 工作的原则就是：
一个目标文件当且仅当在其依赖文件（dependencies）的更改时间戳比该目标文件的创建时间戳新时，这个目标文件才需要 被重新编译。
Make 工具会遍历所有的依赖文件，并且把它们对应的目标文件进行更新。编译的命令和这些目标文件及它们对应的依赖文件 的关系则全部储存在 Makefile 中。
Makefile 中也指定了应该如何创建，创建出怎么样的目标文件和可执行文件等信息。
除此之外，你甚至还可以在 Makefile 中储存一些你想调用的系统终端的命令，像一个 Shell 脚本一样使用它。
作用：
Makefile 文件告诉 Make 怎样编译和连接成一个程序
可用命令 dnf install make 安装make功能
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
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伪目标
.PHONY: clean: clean
#执行make clean时删除所有的目标文件
rm -f $(objects)
所谓编程库:就是指始终可以被多个linux软件 项目重复使用的代码集。 编程库有两个主要优点 一:可以简化编程，实现代码重复使用； 二:可以直接使用比较稳定的代码
linux下的库文件分为: 共享库（动态库） 静态库
共享库是动态加载(程序运行时); 静态库是编译时静态加载的; 共享库以.so(share object)结尾 静态库以.a（archive）结尾。
依赖:可以是另一条规则的目标,也可以是文件。
每一条规则被这样处理:
1.目标是一个文件:当它的依赖也是文件时,如果依赖文 件的时间比目标文件要新, 则运行规则所包含的命令 来更新目标。 2.如果依赖是另一个目标则用同样的方法先来处理这个 依赖的目标。 3.如目标不是一个存在的文件时,则一定执行。
例如: # Makefile hello:a.c b.o gcc -o hello a.c b.o b.o:b.c gcc -c b.c
������
������ ������
2. 初始化makefile文件中的变量;
3. 分析makefile中的所有规则; 4. 为所有的目标文件创建依赖关系 5. 根据依赖关系,决定性哪些目标文 件要重新生成;
6. 执行生成命令;
例子：8个C文件和3个头文件的Makefile
main.c kdb.c insert.c search.c
我们编译此程序： gcc -lpthread -o example1 example1.c 运行example1，我们得到如下结果： This is the main process. This is a pthread. This is the main process. This is the main process. This is a pthread. This is a pthread. 再次运行，我们可能得到如下结果： This is a pthread. This is the main process. This is a pthread. This is the main process. This is a pthread. This is the main process. 前后两次结果不一样，这是两个线程争夺CPU资源的结果。
defs.h #Makefile command.h
command.c files.c
buffer.h
display.c utils. c
#为生成目标所使用的.o文件
objects=main.o kdb.o command.o display.o insert.o search.o files.o utils.o
# Makefile hello:a.c b.c gcc -o hello a.c b.c
这里是一个Tab(注意一定要有一个Tab)
执行make gcc a.c b.c -o hello 产生一个叫hello的可执行程序.
Makefile:是由规则来组成的,每一条规则都 有三部分组成: 目标(object) 依赖(dependency) 命令(command) 在上面的例子中, Makefile只有一条规则, 其目标Байду номын сангаасhello,期依赖为a.c b.c,其命令为 gcc -o hello a.c b.c.
不会写makefile，从一个侧面说明了一个人是否具备完成大
型软件工程的能力。
makefile关系到了整个工程的编译规则。一个工程 中的源文件不计数，其按类型、功能、模块分别放在若 干个文件中，makefile定义了一系列的规则来指定，哪 些文件需要先编译，哪些文件需要后编译，哪些文件需 要重新编译，甚至于进行更复杂的功能操作。 makefile带来的好处就是——“自动化编译”，一 旦写好，只需要一个make命令，整个工程完全自动编译， 极大的提高了软件开发的效率。
两个函数和一个变量解释: 1.创建新的线程函数
extern int pthread_create __P ((pthread_t *__thread, __const pthread_attr_t *__attr, void *(*__start_routine) (void *), void *__arg));
2.为什么要使用多线程?
理由之一: 和进程相比，多线程是一种非常“节俭”的多任 务操作方式。 在Linux系统下，启动一个新的进程必须分配给 它独立的地址空间，建立众多的数据表来维护它的代 码段、堆栈段和数据段，这是一种“昂贵”的多任务 工作方式。 而运行于一个进程中的多个线程，它们彼此之间 使用相同的地址空间，共享大部分数据，启动一个线 程所花费的空间远远小于启动一个进程所花费的空间， 而且，线程间彼此切换所需的时间也远远小于进程间 切换所需要的时间。 据统计，总的说来，一个进程的开销大约是一个 线程开销的30倍左右
理由之二: 是线程间方便的通信机制。 对不同进程来说，它们具有独立的数 据空间，要进行数据的传递只能通过通信 的方式进行，这种方式不仅费时，而且很 不方便。 线程则不然，由于同一进程下的线程 之间共享数据空间，所以一个线程的数据 可以直接为其它线程所用，这不仅快捷， 而且方便。
多线程程序的优点：
linux库一般放在/lib或者/usr/lib目录下。
在终端下，共享库通常为绿色，而静态库为黑色
Linux编程库举例: Linux线程库 1.进程和线程的概念及区别和联系 进程:资源管理的最小单位; 线程:程序执行的最小单位;
一个进程至少需要一个线程作为它的指令执行体; 进程管理着资源,如文件,内存,CPU等,一个进程 可以拥有多个线程
特殊变量:
在makefile中还有一些特殊的内部变量, 它们根据每一个规则内容定义 $@ 指代当前规则下的目标文件列表
$< 指代依赖文件列表中的第一个依赖的文件 $^ 指代依赖文件列表中所有的依赖文件
$? 指代依赖文件列表中新于对应目标文件的 文件列表
例如 # makefile CC = gcc
2.5 Makefile
什么是makefile？
或许很多Winodws的程序员都不知道这个东西，因为那 些Windows的IDE都为你做了这个工作， 但我个人认为:要想成为一个好的程序员，makefile还
是要懂。这就好像现在有这么多的HTML的编辑器，但如果你
想成为一个专业人士，你还是要了解HTML的标识的含义。特 别在linux下的软件编译，你就不能不自己写makefile了，会
a.o:a.c
CC -c $<
伪目标: .PHONY:target ---伪目标的命令一定会被执行 例如 clean: rm a.o b.o clean的目的很简单,就是要删 除所有的.o的文件.但这样写,如果处 在着一个名为clean的文件时就会产 生问题.加上下面一行: .PHONY:clean
什么是make？
make是一个命令工具，是一个解释 makefile中指令的命令工具，一般来说， 大多数的IDE都有这个命令，比如： Delphi的make，Visual C++的nmake， Linux下GNU的make。
Linux下GNU的make的工作流程: 1. 查找当前目录下的makefile文件;
执行 make ,则是处理hello这个目标. hello依赖于文件a.c和另一个目标 b.o, 则先去处理b.o,调用gcc -c b.c 来更 新b.o,之后返回,调用gcc -o hello a.c 更新hello.
b.o 来
定义变量: 在makefile中可以定义自己的变量, 例如上例: # makefile //定义变量 CC = gcc hello:a.c b.c //引用变量 $(CC) a.c b.c
2.等待线程结束函数
extern int pthread_join __P ((pthread_t __th, void **__thread_return));
3.pthread_t型的变量
pthread_t在头文件/usr/include/bits/pthreadtypes.h中定义 typedef unsigned long int pthread_t; 它是一个线程的标识符。
三、 交叉开发环境
3.1 交叉开发环境介绍 3.2 交叉开发环境建立(实验课中讲述) 3.3 交叉开发工具链(内核知识中讲述)
#生成可执行文件
edit:$(objects) cc -o edit $(objects)
main.o:main.c defs.h cc -c main.c kdb.o:kdb.c defs.h command.h cc –c kdb.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