实验四：Makefile 实验
Makefile编程实验
实验四：Makefile编程实验实验目的：1.学会Makefile基本规则；2.学会make命令的使用方法；3.学会使用Makefile程序的编写。
实验设备：PC机。
实验原理：Makefile是用于自动编译和链接的，一个工程有很多文件组成，每一个文件的改变都会导致工程的重新链接，但是不是所有的文件都需要重新编译，Makefile中纪录有文件的信息，在make时会决定在链接的时候需要重新编译哪些文件。
实验方法：1.编写包含多文件的Makefile（1）用vi在/home/vi目录下编辑hello.c程序，程序内容如下所示：#include“hello.h”int main(){printf(“Hello everyone!\n”);return0;}（2）用vi在同一目录下编辑hello.h程序，程序内容如下所示：#include<stdio.h>（3）在shell命令行中用gcc尝试编译，使用命令：“gcc hello.c-o hello”,并运行hello可执行文件查看结果；（4）删除此次编译的可执行文件：rm hello；（5）用vi在同一目录下编辑Makefile，内容如下所示：hello:hello.c hello.hgcc hello.c-o hello（6）退出保存，在shell中键入：make，查看结果；（7）再次用vi打开Makefile，用变量进行替换，如下所示：OBJS:=hello.oCC:=gcchello:$(OBJS)$(CC)$^-o$@（8）退出保存，在shell中键入make，查看结果；（9）用vi在同一目录下编辑makefile1，内容如下所示：hello:hello.ogcc hello.o-o hellohello.o:hello.c hello.hgcc-c hello.c-o hello.o（10）退出保存，在shell中键入：make-f makefile1，查看结果；（11）再次用vi编辑makefile1，内容如下所示：OBJS1:=hello.oOBJS2:=hello.c hello.hCC:=gcchello:$(OBJS1)$(CC)$^-o$@$(OBJS1):$(OBJS2)$(CC)-c$<-o$@在这里请注意区别“$^”和“$<”；（12）退出保存，在shell中键入：make-f makefile1，查看结果；2.使用autotools生成包含多文件的Makefile（1）在/home/vi目录下新建文件夹auto：#mkdir./auto（2）将/home/vi目录下的hello.c和hello.h文件复制到/home/vi/auto 目录下，然后进入到/home/vi/auto目录里面：#cp/home/vi/hello.*/home/vi/auto#cd/home/vi/auto（3）执行命令：#autoscan（4）使用vi编辑当前目录下的configure.scan文件为，主要是蓝色部分：#-*-Autoconf-*-#Process this file with autoconf to produce a configure script.AC_PREREQ(2.59)AC_INIT(hello, 1.0)AM_INIT_AUTOMAKE(hello,1.0)AC_CONFIG_SRCDIR([hello.h])AC_CONFIG_HEADER([config.h])#Checks for programs.AC_PROG_CC#Checks for libraries.#Checks for header files.#Checks for typedefs,structures,and compiler characteristics.#Checks for library functions.AC_OUTPUT(makefile)（5）保存退出，并重命名为configure.in；（6）执行命令：#aclocal（7）执行命令：#autoconf并用ls或ll命令查看是否生成了configure可执行文件；（8）执行命令：#autoheader（9）在当前目录下用vi创建makefile.am文件为：AUTOMAKE_OPTIONS=foreignbin_PROGRAMS=hellohello_SOURCES=hello.c hello.h（10）执行命令：#automake然后再执行下面的命令：#automake-a（11）执行命令：#./configure（12）执行命令：#make（13）执行命令：#./hello查看结果是否正确；（14）执行命令：#Make install（15）执行命令：#hello查看结果是否正确；（16）执行命令：#make dist（17）在当前目录下解压文件hello-1.0.tar.gz：#tar-zxvf hello-1.0.tar.gz（18）进入解压目录：#cd./hello-1.0（19）下面开始Linux下常见的安装软件步骤：#./configure（20）执行命令：#make（21）执行命令：#./hello注意：在正常安装时这一步可省略；（22）执行命令：#make install（23）执行命令：#hello查看结果是否正确。
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 <stdio.h>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 hello4.用vim编辑Makefile，如下所示：hello:hello.c hello.hgcc hello.c -o hello5.退出保存，在shell中键入：make查看结果6.再次用vim打开Makefile，用变量进行替换，如下所示：OBJS :=hello.oCC :=gcchello:$(OBJS)$(CC) $^ -o $@7.退出保存，在shell中键入：make查看结果8.用vim编辑Makefile1，如下所示：hello:hello.ogcc hello.o -o hellohello.o:hello.c hello.hgcc -c hello.c -o hello.o9.退出保存，在shell中键入：make –f Makefile1查看结果10.再次用vi编辑Makefile1，如下所示：OBJS1 :=hello.oOBJS2 :=hello.c hello.hCC :=gcchello:$(OBJS1)$(CC) $^ -o $@$(OBJS1):$(OBJS2)$(CC) -c $< -o $@在这里请注意区别‘$^’和‘$<’。
c语言makefile编写实例
c语言makefile编写实例Makefile是用来管理程序编译的工具，可以方便地管理程序的编译过程。
使用Makefile可以大大简化程序的编译过程，提高程序的可维护性。
Makefile的语法比较简单，主要由目标、依赖和命令三部分组成。
下面我们以一个简单的C程序为例，来介绍如何使用Makefile进行编译。
假设我们有一个名为hello.c的程序，代码如下：```c#include <stdio.h>int main(){printf("Hello, world!\n");return 0;}```我们需要使用gcc编译器将其编译成可执行文件。
下面是一个简单的Makefile：```makefilehello: hello.cgcc -o hello hello.c```这个Makefile很简单，它定义了一个名为hello的目标，该目标依赖于hello.c文件，并使用gcc命令将其编译成可执行文件。
如果我们在终端中输入make命令，Makefile会自动执行编译过程：```$ makegcc -o hello hello.c```Makefile还可以定义多个目标，每个目标可以有多个依赖和多个命令。
下面是一个稍微复杂一些的Makefile：```makefileCC=gccCFLAGS=-Wall -gall: hello goodbyehello: hello.o$(CC) $(CFLAGS) -o hello hello.ogoodbye: goodbye.o$(CC) $(CFLAGS) -o goodbye goodbye.ohello.o: hello.c$(CC) $(CFLAGS) -c hello.cgoodbye.o: goodbye.c$(CC) $(CFLAGS) -c goodbye.cclean:rm -f *.o hello goodbye```这个Makefile定义了两个目标：all和clean。
makefile实例讲解
Makefile 学习笔记：为什么要学习makefile ：工作经验让我认识到会不会写makefile从一个侧面说明了一个人是否有完成大型工程的能力，makefile 关系到整个工程的编译规则，一个工程的文件不计其数，其按类型，功能，模块分别放在不同的目录下，makefile定义了一些规则来指定，哪些文件需要先编译，哪些文件需要重新编译，甚至进行更复杂的功能操作，因为makefile就像一个shell脚本一样，其中也可以执行操作系统命令。
而make 只是一个命令工具，是一个解释makefile中的指令的命令工具，一般来说IDE即集成开发环境都有这个命令。
Makefile 的环境：我是在linux下进行的实验linux 系列下，我用的是ubuntu ，当然你可以用redhat 红旗后其他，我想都没有什么问题的。
在做实验的时候我会做一些linux写的c/c++例子来演示，以加深理解。
关于程序的编译和链接：一般来说，c或者是c++，首先把源文件（*.c 或*.cpp）编译成为中间代码文件，这个中间代码文件在windows下是*.obj文件在linux 或unix 是*.o文件即object file 目标文件这个动作就叫做编译，即把源文件编译成目标文件的过程就叫做编译（compile）。
这以后，再把大量的*.obj 或*.o 目标文件合成一个可以执行的文件，这个工程就叫做链接link。
编译时，主要是检查程序的语法是否正确，函数，变量是否都有声明。
至于链接呢，主要是链接函数，和全局变量。
一．M akefile 的规则Target：prerequisitesCommand。
Target就是一个目标文件，可以使obj或是可执行文件还可以是一个标签label，关于标签label会在下面的文目标中讲解。
所以我们现在只关注obj 和可执行文件即可，其实大部分还都是obj文件，或许可执行文件就只有一个。
Prerequisites 是先决条件的意识，其实在这里只是依赖的意思，prerequisites在这里是生成target的所需要的文件或目标。
linux内核编译和生成makefile文件实验报告
操作系统实验报告姓名：学号：一、实验题目1.编译linux内核2.使用autoconf和au tomake工具为pro ject工程自动生成Ma kefile，并测试3.在内核中添加一个模块二、实验目的1.了解一些命令提示符，也里了解一些l inux系统的操作。
2.练习使用aut oconf和automa ke工具自动生成Make file，使同学们了解M a kefil e的生成原理，熟悉linux编程开发环境三、实验要求1使用静态库编译链接swa p.c，同时使用动态库编译链接my add.c。
可运行程序生成在src/main目录下。
2要求独立完成，按时提交四、设计思路和流程图（如：包括主要数据结构及其说明、测试数据的设计及测试结果分析）1.Makefil e的流程图：2.内核的编译基本操作1.在ubuntu环境下获取内核源码2.解压内核源码用命令符：tar xvf linux-3.18.12.tar.xz3.配置内核特性：m ake allnoco nfig4.编译内核：make5.安装内核：make install6.测试：cat/boot/grub/grub.conf7.重启系统：sudo reboot,看是否成功的安装上了内核8.详情及结构见附录3.生成makef ile文件：1.用老师给的projec里的m ain.c函数。
2．需要使用aut omake和autoco nf两个工具，所以用命令符：sudo apt-get install autocon f 进行安装。
3．进入主函数所在目录执行命令：autosca n,这时会在目录下生成两个文件a utosca n.log和con figure.scan，将config ure.Scan改名为config ure.ac，同时用gedi t打开，打开后文件修改后的如下：# -*- Autocon f -*-# Process this file with autocon f to produce a configu re script.AC_PRER EQ([2.69])AC_INIT([FULL-PACKAGE-NAME], [VERSION], [BUG-REPORT-ADDRESS])AC_CONF IG_SRC DIR([main.c])AC_CONF IG_HEA DERS([config.h])AM_INIT_AUTOM AKE(main,1.0)# Checksfor program s.AC_PROG_CC# Checksfor librari es.# Checksfor headerfiles.# Checksfor typedef s, structu res, and compile r charact eristi cs.# Checksfor library functio ns.AC_OUTP UT(Makefil e)4.新建Makefi le文件，如下：AUTOMAK E_OPTI ONS=foreignbin_PRO GRAMS=mainfirst_S OURCES=main.c5．运行命令acl ocal命令成功之后，在目录下会产生acloca l.m4和auto m4te.cache两个文件。
makefile工具的使用实验原理
makefile工具的使用实验原理一、Makefile工具概述Makefile是一种自动化编译工具，用于管理程序的编译和链接过程。
它可以根据程序的依赖关系，自动判断哪些文件需要重新编译，从而提高程序的编译效率。
二、Makefile工具的基本语法Makefile文件由一系列规则组成，每个规则包含一个目标、依赖关系和命令。
其中，目标指的是要生成的文件，依赖关系指的是生成该文件所需要依赖的其他文件或目标，命令指的是生成该目标文件所需要执行的命令。
三、Makefile工具中变量和函数在Makefile中可以定义变量和函数来简化代码和提高可维护性。
变量可以用来存储常量或计算结果，函数可以用来处理字符串等操作。
四、Makefile工具中常见命令1. 编译命令：gcc -c source.c -o object.o2. 链接命令：gcc object.o -o target3. 清除命令：rm -f target object.o五、Makefile工具实验步骤1. 创建源代码文件和头文件。
2. 创建Makefile文件，并定义变量和函数。
3. 定义规则，并设置目标、依赖关系和命令。
4. 执行make命令进行编译链接。
5. 执行make clean命令清除生成的目标文件。
六、Makefile工具实验注意事项1. Makefile文件中的变量和函数必须使用$符号进行引用。
2. 目标文件和依赖关系之间必须使用冒号分隔符。
3. 命令必须以Tab键开头，否则会报错。
4. Makefile文件中的注释可以使用#符号。
七、Makefile工具实验示例以下是一个简单的Makefile示例，用于编译一个C语言程序：```# 定义变量CC = gccCFLAGS = -Wall -g# 定义规则target: main.o func.o$(CC) main.o func.o -o targetmain.o: main.c func.h$(CC) $(CFLAGS) -c main.cfunc.o: func.c func.h$(CC) $(CFLAGS) -c func.cclean:rm -f target *.o```在该示例中，定义了两个变量CC和CFLAGS，分别表示编译器和编译选项。
实验八 makefile
实验四Makefile一、实验目的1、了解和掌握makefile文件的编写；2、学会使用交叉编译工具和make工具。
二、实验环境预装Fedora10的pc机一台，CVT-A8系列实验箱，以太网线一根，串口线一根。
三、实验步骤1、连接主机和目标板；（三根线，注意网线和串口线是否连接正常）2、Makefile文件的编写a) 编写一个文件prime.h，包含一个判断unsigned int是否为素数的函数定义。
b) 编写一个文件prime.c，实现上面的那个函数。
c) 编写一个文件main.c，实现用户输入整数，程序告诉用户这个数是否为素数，直到用户输入0结束。
d) 使用gcc编译，查看运行结果。
e) 编写makefile文件实现第d步的功能，并使用make工具编译生成这个可执行文件；运行。
f) 使用定义宏来改写makefile，实现第d步的功能，并使用make工具编译生成这个可执行文件；运行。
g) 使用对依赖文件的预定义变量改写makefile，实现第d 步的功能，并使用make工具编译生成这个可执行文件；运行。
h) 使用标签改写makefile，此标签功能为删除项目编译生成中的所有中间文件，并使用make工具删除项目编译生成中的所有中间文件。
i) 使用CC宏指代编译器命令gcc，修改makefile文件，实现第d步的功能，并使用make工具编译生成这个可执行文件；运行。
j) 使用CC宏指代编译器命令arm-linux-gcc，修改makefile 文件，实现第d步的功能，并使用make工具编译生成这个可执行文件；下载到目标板运行。
k) 使用make CC=gcc 命令生成可执行文件，使用file查看可执行文件信息。
再查看makefile文件。
四、实验要求1、要求随时观察记录实验结果；2、保留编写的源文件和每一步的makefile；3、掌握makefile文件的三种编写方法。
五、实验报告要求1、每人一份实验报告；2、实验报告中要求对每一步操作和出现的结果详细记录并解释；3、你认为做好本实验应该注意哪些方面？六、思考题makefile文件的作用？。
嵌入式编程基础实验报告之Makefile文件的使用
实验内容与分析设计：（1）用Vi打开上述两个代码文件“hello.c”和“hello.h”。
（2）在shell命令行中用Gcc尝试编译，使用命令：”Gcc hello.c –o hello”，并运行hello可执行文件查看结果。
（3）删除此次编译的可执行文件：rm hello。
（4）用Vi编辑Makefile，如下所示：hello:hello.c hello.hGcc hello.c -o hello（5）退出保存，在shell中键入：make，查看结果。
（6）再次用Vi打开Makefile，用变量进行替换，如下所示：OBJS :=hello.oCC :=Gcchello:$(OBJS)$(CC) $^ -o $@（7）退出保存，在shell中键入：make，查看结果。
（8）用Vi编辑Makefile1，如下所示：hello:hello.oGcc hello.o -o hellohello.o:hello.c hello.hGcc -c hello.c -o hello.o（9）退出保存，在shell中键入：make -f Makefile1，查看结果。
（10）再次用Vi编辑Makefile1，如下所示：OBJS1 :=hello.oOBJS2 :=hello.c hello.hCC :=Gcchello:$(OBJS1)$(CC) $^ -o $@$(OBJS1):$(OBJS2)$(CC) -c $< -o $@在这里请注意区别“$^”和“$<”。
退出保存，在shell中键入：make -f Makefile1，查看结果实验结果：各种不同形式的makefile都能完成其正确的功能疑难与小节：通过对包含多文件的Makefile的编写，熟悉各种形式的Makefile，并且进一步加深对Makefile 中用户自定义变量、自动变量及预定义变量的理解主要算法和程序清单：#hello.c#include "hello.h"int main(){printf("Hello everyone!\n"); }#hello.h#include <stdio.h> Makefile：hello:hello.c hello.hGcc hello.c -o hello Makefile：OBJS :=hello.oCC :=Gcchello:$(OBJS)$(CC) $^ -o $@Makefile1：hello:hello.oGcc hello.o -o hello hello.o:hello.c hello.hGcc -c hello.c -o hello.o Makefile1：OBJS1 :=hello.oOBJS2 :=hello.c hello.hCC :=Gcchello:$(OBJS1)$(CC) $^ -o $@ $(OBJS1):$(OBJS2)$(CC) -c $< -o $@。
辽宁工程技术大学linux实验makefile实验
6、重复第2，3步操作，查看并记录所生成的文件和运行的结果。比较这两种操作，写出你的结论。同时指出$^、$@、$<在上述Makefile中的含义。
三、多个.c文件的编译。
1、创建文件hello1.c、hello2.c、hello.h和makefile。
2、先后执行如下命令：[root@local]$make，[root@local]$ls，[root@local]$./hello。
2、XSBase270或XSBase255 ARM实验开发平台一套。
实验
进度
本次共有1个练习，完成1个。
实验
内容
一、用命令行的方式手动编译程序方法
1、利用文本编辑器创建hello.c文件。
2.手动编译hello应用程序。
在hello.c的目录的终端下输入：[root@local]$ gcc –c hello.c，[root@local]$gcc hello.o –o hello。通过ls命令查看当前目录下是否生成源代码hello.c的object文件hello.o和可执行文件hello，运行可执行文件hello。结果[root@local]$./hello
3、修改hello.c文件，重新手动编译应用程序。
4、删除hello.o和hello文件。[root@local]$rm –f hello.o，[root@local]$rm –f hello。
二、利用GNU make自动编译应用程序方法
1、用文本编辑器创建一个makefile文件，保存到与hello.c相同的目录下。
成绩
辽宁工程技术大学上机实验报告
实验名称
makefile实验
院系
软件学院
makefile工具的使用实验原理
makefile工具的使用实验原理1. 引言makefile是一种程序构建工具，它的作用是根据源代码文件之间的依赖关系，自动化地生成可执行文件、库文件或者其他类型的文件。
makefile工具的使用可以大大简化软件开发过程，提高代码的编译效率。
本文将详细介绍makefile工具的原理以及如何使用它进行实验。
2. makefile的原理2.1 什么是makefilemakefile是一个文本文件，它包含了一系列的规则，用于描述源文件之间的依赖关系以及如何生成目标文件。
makefile的格式和语法都是根据约定俗成的规则来定义的，因此可以在不同的平台和编译环境中使用。
2.2 makefile的工作原理makefile的工作原理可以简单概括为以下几个步骤：1.读取makefile文件，解析其中的规则。
2.检查目标文件是否需要重新生成。
如果目标文件不存在、源文件有修改或者依赖文件有修改，则需要重新生成目标文件。
3.根据规则中描述的依赖关系，递归地生成依赖文件及其依赖文件的目标文件。
4.根据生成的依赖文件和目标文件，生成最终的目标文件。
3. makefile的语法makefile的语法可以分为三个部分：变量定义、规则定义和命令定义。
3.1 变量定义在makefile中，变量用来存储一些常用的配置信息，例如编译器的路径、编译选项等。
变量可以使用赋值语句进行定义，例如：CC = gccCFLAGS = -Wall -O23.2 规则定义规则定义了目标文件和依赖文件之间的关系，以及如何生成目标文件。
规则的格式如下：target: dependency1 dependency2 ...command1command2...目标文件（target）是规则中要生成的文件，依赖文件（dependency）是目标文件生成所需要的原始文件或者其他目标文件。
命令（command）是生成目标文件的具体操作。
3.3 命令定义命令定义了如何生成目标文件。
Makefile两个实验
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#include2.仍在同⼀⽬录下⽤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 hello4.⽤vim编辑Makefile，如下所⽰：hello:hello.c hello.hgcc hello.c -o hello5.退出保存，在shell中键⼊：make查看结果6.再次⽤vim打开Makefile，⽤变量进⾏替换，如下所⽰：OBJS :=hello.oCC :=gcchello:$(OBJS)$(CC) $^ -o $@7.退出保存，在shell中键⼊：make查看结果8.⽤vim编辑Makefile1，如下所⽰：hello:hello.ogcc hello.o -o hellohello.o:hello.c hello.hgcc -c hello.c -o hello.o9.退出保存，在shell中键⼊：make –f Makefile1查看结果10.再次⽤vi编辑Makefile1，如下所⽰：OBJS1 :=hello.oOBJS2 :=hello.c hello.hCC :=gcchello:$(OBJS1)$(CC) $^ -o $@$(OBJS1):$(OBJS2)$(CC) -c $< -o $@在这⾥请注意区别…$^?和…$11.退出保存，在shell中键⼊：make –f Makefile1查看结果14.2嵌套Makefile实验【实验⽬的】1、读懂makefile⽂件，能根据makefile⽂件理清程序结构2、能编写简单makefile3、掌握嵌套执⾏makefile【实验环境】PC机、CentOS 5 操作系统，gcc等⼯具。
makefile 文件编写实验原理
makefile 文件编写实验原理Makefile文件编写实验原理Makefile是一个用于自动化构建和管理程序的工具。
它通常用于C/C++项目，但也可以适用于其他语言。
Makefile文件包含了一系列的规则和指令，用于描述编译、链接和安装项目的过程。
本文将一步一步回答“makefile文件编写实验原理”的问题，以便更深入地理解和掌握Makefile的使用。
1. 什么是Makefile？Makefile是一个文本文件，其中包含了一系列的规则(rule)，用于描述如何构建程序。
每个规则由一个目标(target)、依赖(dependencies)和指令(commands)组成。
目标是需要构建的文件，依赖是目标文件的依赖关系，指令则是构建文件的具体操作。
2. Makefile的作用是什么？Makefile的主要作用是自动化构建和管理程序。
通过编写Makefile文件，可以快速地编译、链接和安装项目，而无需手动执行繁琐的编译命令。
Makefile还可以根据文件的修改时间来判断是否需要重新构建，以提高构建的效率。
3. Makefile的基本语法是什么？Makefile的基本语法由目标、依赖和指令组成。
一个简单的规则示例如下：target: dependenciescommands其中，target是需要构建的目标文件，dependencies是目标文件的依赖关系，commands是构建目标文件的指令。
每个指令要求以一个Tab键起头。
4. 如何编写简单的Makefile？编写简单的Makefile可以按照以下步骤进行：- 定义目标：在Makefile中使用变量定义目标文件和依赖关系。
例如：TARGET = programOBJ = main.o func1.o func2.o- 编写规则：根据目标文件和依赖关系，编写对应的规则。
例如：(TARGET): (OBJ)gcc -o ^其中，表示目标文件，^表示所有的依赖文件。
Linux系统Makefile编写与GCC编译实验报告
实验报告实验题目Linux系统Makefile编写与GCC编译实验姓名：学号：课程名称：所在学院：专业班级：任课教师：四、实验过程、步骤及内容（一）GCC编译1、准备环境2、建立相关目录$ cd workdir/linux/application$ mkdir 6-gcc3、将代码从共享目录拷入虚拟机L inux 操作系统下；（可使用【crtl+空格】切换输入法）$ cp /mnt/hgfs/share/实验代码/03.\ Linux 系统GCC 编译器的使用实验/实验代码/* 6-gcc/ -a$ cd 6-gcc/4、编译代码$ arm-none-linux-gnueabi-gcc helloworld.c -o hello$ mkdir /source/rootfs/app$ cp hello /source/rootfs/app/5、执行代码通过tftp 下载内核，nfs 挂载文件系统，启动开发板。
在开发板串口终端执行应用程序。
# cd /app# ./hello6、相关代码：#include <stdio.h>int main (int argc,char **argv){printf("hello,world!\n");return 0;}（二）Makefile编程1、环境准备2、建立相关目录$ cd workdir/linux/application$ mkdir 7-Makefile3、将代码从共享目录拷入虚拟机L inux 操作系统下；（可使用【crtl+空格】切换输入法）$ cp /mnt/hgfs/share/实验代码/05.\ Linux 系统Makefile 编写实验/实验代码/5.2/makefileTest/* 7-Makefile/ -a$ cd 7-Makefile/4、执行代码进入makefileTest 目录，执行make。
$ make CLEAN$ make会出现如下信息：5、在开发板上执行通过tftp下载内核，nfs挂载文件系统，启动开发板6、相关代码：CC = arm-none-linux-gnueabi-gcc SUBDIRS = f1 \f2 \main \objOBJS = f1.o f2.o main.oBIN = myappOBJS_DIR = objBIN_DIR = binexport CC OBJS BIN OBJS_DIR BIN_DIRall : CHECK_DIR $(SUBDIRS)cp bin/myapp /source/rootfs/app CHECK_DIR :mkdir -p $(BIN_DIR) $(SUBDIRS) : ECHOmake -C $@ECHO:@echo $(SUBDIRS)@echo begin compileCLEAN :@$(RM) $(OBJS_DIR)/*.o@rm -rf $(BIN_DIR)五、实验数据（现象）处理分析实验现象如下：（一）GCC编译（二）Makefile编程。
实验指导书 makefile
实验3指导书本次试验的目的是初步掌握make工具的使用和makefile文件的编写规则。
Makefile的规则：target ... : dependency ...command... ...target：一个标志名，可以是Object File，也可以是执行文件，还可以是一个标签（Label）dependency：要生成那个target所需要的文件或是目标内容。
command：上述依赖关系所决定的make需要执行的命令。
（任意的Shell命令）这是一个文件的依赖关系，也就是说，target这一个或多个的目标文件依赖于dependency中的文件，其生成规则定义在command中。
或者说， dependency中如果有一个以上的文件比target文件要新的话，command所定义的命令就会被执行。
这就是Makefile的规则。
也就是Makefile中最核心的内容mytools.tar目录结构如下：本项目提供了5个makefile：Makefile1：最普通的、没有用变量的MakefileMakefile2：使用了变量OBJECTMakefile3：利用了隐含规则，没有用命令行指明目标文件的生成方法Makefile4：使用了自动变量$@ $^ $<Makefile5：使用了自动变量和隐含规则操作方法：在/home/目录下创建自己名字的目录，然后通过文件共享或U盘，将mytools.tar拷贝到home 目录下，并解压：：[1]mkdir /home/xxxx[2]cd /home/xxxx[3]cp /mnt/hgfs/vmshare/mytools.tar .[4]tar ‐xvf mytools.tar然后分别执行：(1)cp Makefile1 Makefile(2)make(3)ls ‐l(4)./mytools1(5)make clean(6)cp Makefile2 Makefile(7)make(8)ls ‐l(9)./mytools2(10)make clean(11)cp Makefile3 Makefile(12)make(13)ls ‐l(14)./mytools3(15)make clean(16)cp Makefile4 Makefile(17)make(18)ls ‐l(19)./mytools4(20)make clean(21)cp Makefile5 Makefile(22)make(23)ls ‐l(24)./mytools5(25)make clean也可直接使用：make –f Makefile1/Makefile2….来直接指定makefile进行编译。
makefile编写实例
makefile编写实例Makefile是软件构建过程中一种重要的文件格式，它让程序员更方便地控制软件的编译、链接和安装过程。
它的使用可以带来更快速的编译效率、更高可靠的编译结果，以及更轻松的多模块应用的组合。
一般来说，在编写一个makefile文件时，会涉及到一些技巧，包括但不限于：规则定义、变量定义、操作符定义和脚本编写。
其中，规则是makefile的核心，它可以将源文件、中间文件和最终文件之间的关系正确地表达出来。
规则定义在阅读makefile文件时，首先要明白makefile有两个重要部分，分别是规则定义和变量定义。
规则定义，简单来讲，就是指定如何生成特定目标文件的过程。
一般来讲，makefile文件里的规则由三部分组成：目标文件，依赖文件和指令。
例如，要将源文件 helloworld.c译成可执行文件 helloworld，可以写下如下一条规则：helloworld：helloworld.cgcc helloworld.c -o helloworld上面的规则的意思是，如果helloworld这个可执行文件不存在，那么就执行gcc命令，把helloworld.c编译成helloworld文件变量定义变量定义的作用是用来简化makefile文件的书写。
变量可以在指令和规则的任何地方使用，从而隐藏信息，使得makefile更灵活、可读性更高。
例如，如果我们想将C源文件编译成为可执行文件，我们可以用一个变量CC来表示编译器，即把所有的gcc命令改为$(CC)：helloworld：helloworld.c$(CC) helloworld.c -o helloworld这样的话，我们可以根据自己的编译器来改变$(CC)的值，从而改变编译器，而不需要去修改这一指令。
操作符定义操作符定义可以使得makefile文件更加简洁，它可以定义和使用特殊字符串，并且它们在每一行的开头和结尾可以省略，有助于减少重复的内容。
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命令。整个工程完全自动编译，极大提高了效率。
makefile使用
makefile使用1 makefile 实际上是一个单行shell脚本，用make来调用。
2 makefile 使用的命令解释器由SHELL这个变量所控制，make 启动时会从用户环保导入所有的变量经作为make有变量，但不包括SHELL变量。
3 每个命令必须以跳格符（tab）开头在工作目标之后，凡是第一个字符为跳格的文本行一律被视为命令。
@放在要执行的命令前，执行时不打印这个命令。
4 $ 符号跟开括号，函数名，空格后跟一列由逗号分隔的参数，最后用关括号结束。
例如 SOURCES = $(wildcard *.c) 这行会产生一个所有以 '.c' 结尾的文件的列表，然后存入变量 SOURCES 里。
5 常用函数。
A， wildcard, 它有一个参数，功能是展开成一列所有符合由其参数描述的文件名，文件间以空格间隔。
$(wildcard *.c）产生一个所有以'.c' 结尾的文件的列表.B， patsubst, 它需要３个参数——第一个是一个需要匹配的式样，第二个表示用什么来替换它，第三个是一个需要被处理的由空格分隔的字列. OBJS = $(patsubst%.c,%.o,$(SOURCES)) 处理所有在 SOURCES 字列中的字（一列文件名），如果它的结尾是 '.c' ，就用 '.o' 把 '.c'取代.C．notdir 去除路径。
6 规则分为三部分，A 工作目标， B 它的必要条件。
C 所要执行的命令。
工作目标是一个必须建造的文件或进行的事情，必要条件或依存对像是工作目标得以被成功创建之前，必须事先存在的那些文件，而所要执行的命令是必要条件成立时将会创建工作目标的那些shell命令。
-l<NAME>,形式的必要条件出现时，make 会搜索libNAME.so 文件，如果没有会再找libNAME.a文件，找到后就进行最后的动作----链接。
makefile的使用
makefile的使用一、什么是makefilemakefile是一种用来描述和指导如何编译和构建程序的文件。
它记录了源文件之间的依赖关系和编译规则，通过解析makefile文件，可以自动化地编译和构建程序。
二、为什么要使用makefile使用makefile有以下几个优点：1.自动化编译: makefile可以在编译过程中自动判断哪些文件需要重新编译，从而减少重复编译的时间和工作量。
2.简化构建流程: makefile可以将复杂的构建过程和编译命令封装成一个命令，简化构建流程，提高工作效率。
3.管理项目依赖: makefile可以记录文件之间的依赖关系，当某个文件发生变化时，只需要重新编译与之相关的文件，从而加快构建速度。
4.提高可维护性: makefile使得代码的组织结构更加清晰和可维护，便于团队协作和后续维护。
三、makefile的基本语法makefile的语法较为简单，包括以下几个基本元素：1.目标(target): 目标是构建过程中的一个步骤或者一个文件，并且有依赖关系。
在makefile中，目标通常是一个需要构建的文件，也可以是一个执行命令的动作。
2.依赖关系(prerequisites): 依赖关系是指目标所依赖的文件或者其他目标。
当一个目标的依赖发生变化时，该目标需要重新构建。
3.命令(command): 命令是指构建过程中的具体操作。
在makefile中，每个目标可以指定一个或多个命令，用于构建该目标。
4.变量(variable): 变量是makefile中定义的一个数据容器，用于存储常量或者计算结果。
可以通过引用变量来简化makefile的书写和维护。
5.规则(rule): 规则是指一个目标和其依赖关系的完整定义，包含了目标、依赖关系和命令。
下面是一个简单的makefile示例：# 定义变量CC = gccCFLAGS = -Wall -O2# 定义目标及其依赖关系和命令hello: main.o utils.o$(CC) $(CFLAGS) -o hello main.o utils.o# 定义目标的依赖关系和命令main.o: main.c utils.h$(CC) $(CFLAGS) -c main.cutils.o: utils.c utils.h$(CC) $(CFLAGS) -c utils.c四、makefile的工作流程makefile的工作流程包括以下几个步骤：1.读取makefile文件: make工具会首先读取当前目录下的makefile文件，如果没有找到，则会寻找默认的文件名（GNUmakefile、makefile或Makefile）。
Linux实验Makefile实验
内容
1.利用文本编辑器创建hello.c文件
2.手动编译hello应用程序
3.利用GNU make自动编译应用程序方法
4.先后执行如下命令
[root@local]]$./hello
5.多个.c文件的编译
先后执行如下命令
[root@local]$make
阅读上机指导，翻阅教材，查阅笔记。
实验
进度
本次共有3个练习，完成3个。
实验
总结
日
通过本次试验，学习运用Makefile文件进行程序的编译。学习了Makefile相关的基本内容以及相关操作。在对Makefile中的变量进行定义时，需要注意Makefile中的变量可以使用在“目标”，“依赖目标”，“命令”或Makefile的其它部分中。
在本次实验中，通过Makefile来完成对应用程序的编译。Makefile是按照某种脚本语法编写的文本文件，而GNU make能够对Makefile中指令进行解释并进行编译。Makefile文件定义了一系列的规则来指定哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作。GNU make包含有一些内置的或隐含的规则，这些规则定义了如何从不同的依赖文件建立特定类型的目标。
在对程序的编辑过程中，由于对命令部分的编写不够熟悉，经常使用多个空格进行分隔，出现了许多次错误，后来经过同学的指点，每行的缩进必须要使用Tab而不能用空格代替。
通过本次实验，我进一步了解了Linux操作系统各种命令的使用。了解到人们通常利用GNU make工具通过一个称为Makefile的文件来完成对应用程序的自动维护和编译工作，而不是手工键入gcc命令对源代码文件逐个进行编译。这对我对Linux的了解进一步加深。
Makefile面试
Makefile⾯试介绍⼀下make? 为什么使⽤make1、包含多个源⽂件的项⽬在编译时有长⽽复杂的命令⾏，可以通过makefile保存这些命令⾏来简化该⼯作2、make可以减少重新编译所需要的时间，因为make可以识别出哪些⽂件是新修改的3、make维护了当前项⽬中各⽂件的相关关系，从⽽可以在编译前检查是否可以找到所有的⽂件makefile：⼀个⽂本形式的⽂件，其中包含⼀些规则告诉make编译哪些⽂件以及怎样编译这些⽂件，每条规则包含以下内容：⼀个target，即最终创建的东西⼀个和多个dependencies列表，通常是编译⽬标⽂件所需要的其他⽂件需要执⾏的⼀系列commands，⽤于从指定的相关⽂件创建⽬标⽂件make执⾏时按顺序查找名为GNUmakefile，makefile或者Makefile⽂件，通常，⼤多数⼈常⽤MakefileMakefile规则：target: dependency dependency [..] command command [..]注意：command前⾯必须是制表符例⼦：editor: editor.o screen.o keyboard.ogcc -o editor editor.o screen.o keyboard.oeditor.o : editor.c editor.h keyboard.h screen.hgcc -c editor.cscreen.o: screen.c screen.hgcc -c screen.ckeyboard.o : keyboard.c keyboard.hgcc -c keyboard.cclean:rm editor *.o。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验四：Makefile 实验
一、实验目的：
1、了解make；
2、了解makefile；
3、掌握makefile 编程；
二、实验内容：
通过makefile 来编译程序
三、实验设备：
PC 机、飞凌6410 开发板
四、实验原理：
1、MAKE
当运行make 命令时,make 命令会在当前目录下按顺序寻找文件名为“GUNmakefile”、“Makefile”、“makefile”的文件,找到后解释这些文件。
所以说make是一个解释makefile 中指令的命令工具。
Makefile 或makefile: 告诉make 维护一个大型程序,该做什么。
Makefile 说明了组成程序的各模块间的相互关系及更新模块时必须进行的动作,make 按照这些说明自动地维护这些模块。
简单的说makefile 就像批处理的脚本文件,里边写好了一些命令的集合,当运行make 命令时,便会按着makefile 提供的命令及顺序来完成编译。
Makefile 文件包含了五部分内容:显示规则、隐式规则、变量定义、文件指示和注释
2、Makeile 中的变量
Makefile 里的变量就像一个环境变量。
事实上,环境变量在make 中也被解释成make 的变量。
这些变量对大小写敏感,一般使用大写宇母。
几乎可以从任何地方引用定义的变量。
Makefile 中的变量是用一个文本串在Makefile 中定义的,这个文本串就是变量的值。
只要在一行的开始写下这个变量的名字,后面跟一个“=”号,以及要设定这个变量的值即可定义变量,下面是定义变量的语法:
VARNAME=string
使用时, 把变量用括号括起来, 并在前面加上$ 符号, 就可以引用变量的
值:${VARNAME}
3、Make 工作时的执行步骤
(1)读入所有的makefile 文件；
(2)读入被include 包括的其他makefile 文件；
(3)初始化文件中的变量；
(4)推到隐士规则，并分析所有规则；
(5)根据依赖关系，决定哪些目标要重新生成；
(6)执行生成命令；
第(1)~(5)步为第一个阶段,第(6)~(7)步为第二个阶段。
第一个阶段中,如果定义的变量被使用了,make 会在它使用的位置把它展开。
但make 并不会马
上完全展开,make 使用的是拖延战术。
如果变量出现在依赖关系的规则中,进当这条依赖关系决定要使用时,变量才会在其内部展开。
五、实验内容
1、敲代码code.c，code.h，prog.c，prog.h，prog.o，test.c 还有
makefile
2、编译及运行
上次课上学习了本机编译和交叉编译，这次的编译也分两种编译，但是由于makefile的存在，使得这两种的编译步骤几乎相同。
1、打开makefile，其中最上面的两行，决定了是使用本机还是交叉编译。
2、本机编译
3、交叉编译
4、开发板运行程序
六、实验心得
本实验实施过程比较简单，由于文件代码在实验指导书中都已经给出，也减少了许多工作量。
但是在实验代码的复制过程中未看清楚格式，导致格式不对，make时失败了好几次。
同时，根据这个实验，见识到了make功能的强大功能，可以方便地集合运行多个文件，
在大型程序中起着至关重要的作用。