简单的Makefile

$@表示一个自动变量

$<表示

objects = foo.o bar.o

all: $(objects)

$(objects): %.o: %.c

$(CC) -c $(CFLAGS) $< -o $@

$@表示所有的.o文件

$<表示所有的.c文件

经典简的Makefile

CXX=g++

CXXFLAGS=-I/usr/include/qpid-boost -g

LDFLAGS=-lqpidclient

all: direct_producer listener declare_queues

clean:

rm -f direct_producer listener declare_queues

简单的Makefile

CXX=g++

INCS=/home/sxd/matrix/include/linux

LIBS=/home/sxd/matrix/lib/linux/debug

OUTNAME=test

#DEBUG :subpath=debug/

#DEBUG : CFLAGS=-g $(SLMODINC)

DEBUG :test.o

g++ $(CFLAGS) -I$(INCS) -L$(LIBS) -o $(OUTNAME) test.cpp -lpthread

clean:

@rm *.o $(OUTNAME) -rf

规范一点Makefile

2 CXX=g++ //编辑器

3 AR=ar

4 OUT_NAME=libbk_svr.so //输出的文件名

6 OUT_PATH=./bin/ //输出文件路径

7 SRC_PATH=./

8 OBJ_PATH=./obj/

9 WORKING_ROOT=$(HOME)/matrix //工程目录

11 DEBUG_PATH=debug/

12 RELEASE_PATH=release/

15 INC_DEBUG_PATH=-I $(WORKING_ROOT)/include/linux/ \//DEBUG: 包含的头文件路径

17 INC_RELEASE_PATH=-I $(WORKING_ROOT)/include/linux/ \ //RELASE: 包含的头文件路径

19 LIB_DEBUG_FILE= -lpthread \ //DEBUG: 包含的库文件

20 -L/usr/lib64/mysql -lmysqlclient \

21 $(WORKING_ROOT)/lib/linux/debug/shengli_tool.a \

22 -ldl $(WORKING_ROOT)/lib/linux/debug/matrix_business_base.a \

23 $(WORKING_ROOT)/lib/linux/debug/shengli_db.a \

25 LIB_RELEASE_FILE= -lpthread \ //RELASE: 包含的库文件

26 -L/usr/lib64/mysql -lmysqlclient \

27 -ldl $(WORKING_ROOT)/lib/linux/release/shengli_tool.a \

29 SRC_FILE=$(wildcard $(SRC_PATH) *.cpp)

30 ALL_FILE=$(notdir $(SRC_FILE))

31 OBJ_FILE=$(patsubst %.cpp,%.o,$(ALL_FILE))

33 DEBUG_CXXFLAGS=-g -Wall -fPIC

34 RELEASE_CXXFLAGS=-O2 -fPIC

36 DEBUG_ARFLAGS=cqs

37 RELEASE_ARFLAGS=cqs

39 OUT_DEBUG_FILE=$(OUT_PATH)$(DEBUG_PATH)$(OUT_NAME)

40 OBJ_DEBUG_FILE=$(addprefix $(OBJ_PATH)$(DEBUG_PATH),$(notdir $(OBJ_FILE)))

42 OUT_RELEASE_FILE=$(OUT_PATH)$(RELEASE_PATH)$(OUT_NAME)

43 OBJ_RELEASE_FILE=$(addprefix $(OBJ_PATH)$(RELEASE_PATH),$(notdir $(OBJ_FILE)))

45 debug : pre_debug $(OUT_DEBUG_FILE)//需要建一些目录

47 release :per_release $(OUT_RELEASE_FILE)

//编译debug release

52 -$(shell mkdir $(OBJ_PATH) -p)

53 -$(shell mkdir $(OBJ_PATH)$(DEBUG_PATH) -p)

54 -$(shell mkdir $(OUT_PATH) -p)

55 -$(shell mkdir $(OUT_PATH)$(DEBUG_PATH) -p)

58 per_release :

59 -$(shell mkdir $(OBJ_PATH) -p)

60 -$(shell mkdir $(OBJ_PATH)$(RELEASE_PATH) -p)

61 -$(shell mkdir $(OUT_PATH) -p)

62 -$(shell mkdir $(OUT_PATH)$(RELEASE_PATH) -p)

63 -$(shell cp ./mfe.xml ./app.xml $(OUT_PATH)$(RELEASE_PATH))

65 $(OUT_DEBUG_FILE) : $(OBJ_DEBUG_FILE)

66 $(CXX) $(DEBUG_CXXFLAGS) $(addprefix $(OBJ_PATH)$(DEBUG_PATH),$(notdir $^)) -shared -o $@ $(LIB_DEBUG_FILE)

67 # $(AR) $(DEBUG_ARFLAGS) $(OUT_DEBUG_FILE) $(addprefix $(OBJ_PATH)$(DEBUG_PATH),$(notdir $^)) $@ $(LIB_DEBUG_FILE)

69 $(OUT_RELEASE_FILE) : $(OBJ_RELEASE_FILE)

70 $(CXX) $(RELEASE_CXXFLAGS) $(addprefix $(OBJ_PATH)$(RELEASE_PATH),$(notdir $^)) -shared -o $@ $(LIB_RELEASE_FILE)

71 # $(AR) $(RELEASE_ARFLAGS) $(OUT_RELEASE_FILE) $(addprefix $(OBJ_PATH)$(RELEASE_PATH),$(notdir $^)) $@ $(LIB_RELEASE_FILE)

73 $(OBJ_PATH)$(DEBUG_PATH)%.o : %.cpp

74 $(CXX) -c $(DEBUG_CXXFLAGS) $(INC_DEBUG_PATH) $(SRC_PATH)$< -o $@

76 $(OBJ_PATH)$(RELEASE_PATH)%.o : %.cpp

77 $(CXX) -c $(RELEASE_CXXFLAGS) $(INC_RELEASE_PATH) $(SRC_PATH)$< -o $@

79 cfg:

80 @echo "copy frame work sample config file"

81 -$(shell mkdir $(OUT_PATH) -p)

82 -$(shell mkdir $(OUT_PATH)$(DEBUG_PATH) -p)

83 -$(shell mkdir $(OUT_PATH)$(RELEASE_PATH) -p)

84 $(shell cp $(WORKING_ROOT)/lib/linux/debug/fw_config.xml $(OUT_PATH)$(DEBUG_PATH))

86 fw:

87 @echo "copy frame work to my work path"

88 -$(shell mkdir $(OUT_PATH) -p)

89 -$(shell mkdir $(OUT_PATH)$(DEBUG_PATH) -p)

90 -$(shell mkdir $(OUT_PATH)$(RELEASE_PATH) -p)

91 $(shell cp $(WORKING_ROOT)/lib/linux/debug/frame_work $(OUT_PATH)$(DEBUG_PATH))

92 $(shell cp $(WORKING_ROOT)/lib/linux/debug/liblog_module.so $(OUT_PATH)$(DEBUG_PATH))

93 $(shell cp $(WORKING_ROOT)/lib/linux/debug/libmsg_module.so $(OUT_PATH)$(DEBUG_PATH))

94 $(shell cp $(WORKING_ROOT)/lib/linux/debug/libmatrix_msg.so $(OUT_PATH)$(DEBUG_PATH))

95 $(shell cp $(WORKING_ROOT)/lib/linux/debug/libconfig_module.so $(OUT_PATH)$(DEBUG_PATH))

96 $(shell cp $(WORKING_ROOT)/lib/linux/debug/libmonitor_module.so $(OUT_PATH)$(DEBUG_PATH))

97 $(shell cp $(WORKING_ROOT)/lib/linux/debug/libmatrix_engine.so $(OUT_PATH)$(DEBUG_PATH))

100 @echo "make clean"

101 $(shell rm $(OBJ_PATH) -rf)

102 $(shell rm $(OUT_PATH)$(DEBUG_PATH)$(OUT_NAME) -f)

103 $(shell rm $(OUT_PATH)$(RELEASE_PATH)$(OUT_NAME) -f)

104

手动建立makefile简单实例解析

手动建立makefile简单实例解析假设我们有一个程序由5个文件组成，源代码如下：/*main.c*/ #include "mytool1.h" #include "mytool2.h" int main() { mytool1_print("hello mytool1!"); mytool2_print("hello mytool2!"); return 0; } /*mytool1.c*/ #include "mytool1.h" #include void mytool1_print(char *print_str) { printf("This is mytool1 print : %s ",print_str); } /*mytool1.h*/ #ifndef _MYTOOL_1_H #define _MYTOOL_1_H void mytool1_print(char *print_str); #endif /*mytool2.c*/ #include "mytool2.h" #include void mytool2_print(char *print_str) { printf("This is mytool2 print : %s ",print_str); }

/*mytool2.h*/ #ifndef _MYTOOL_2_H #define _MYTOOL_2_H void mytool2_print(char *print_str); #endif 首先了解一下make和Makefile。GNU make是一个工程管理器，它可以管理较多的文件。我所使用的RedHat 9.0的make版本为GNU Make version 3.79.1。使用make的最大好处就是实现了“自动化编译”。如果有一个上百个文件的代码构成的项目，其中一个或者几个文件进行了修改，make就能够自动识别更新了的文件代码，不需要输入冗长的命令行就可以完成最后的编译工作。make执行时，自动寻找Makefile（makefile）文件，然后执行编译工作。所以我们需要编写Makefile文件，这样可以提高实际项目的工作效率。在一个Makefile中通常包含下面内容： 1、需要由make工具创建的目标体（target），通常是目标文件或可执行文件。 2、要创建的目标体所依赖的文件（dependency_file）。 3、创建每个目标体时需要运行的命令（command）。格式如下： target：dependency_files command target：规则的目标。通常是程序中间或者最后需要生成的文件名，可以是.o文件、也可以是最后的可执行程序的文件名。另外，目标也可以是一个make执行的动作的名称，如目标“clean”，这样的目标称为“伪目标”。 dependency_files：规则的依赖。生成规则目标所需要的文件名列表。通常一个目标依赖于一个或者多个文件。 command：规则的命令行。是make程序所有执行的动作（任意的shell命令或者可在shell下执行的程序）。一个规则可以有多个命令行，每一条命令占一行。注意：每一个命令行必须以[Tab]字符开始，[Tab]字符告诉make此行是一个命令行。make按照命令完成相应的动作。这也是书写Makefile中容易产生，而且比较隐蔽的错误。命令就是在任何一个目标的依赖文件发生变化后重建目标的动作描述。一个目标可以没有依赖而只有动作（指定的命令）。比如Makefile中的目标“clean”，此目标没有依赖，只有命令。它所指定的命令用来删除make过程产生的中间文件（清理工作）。在Makefile中“规则”就是描述在什么情况下、如何重建规则的目标文件，通常规则

LAMMPS手册-中文版讲解之欧阳家百创编

LAMMPS手册-中文解析一、欧阳家百（2021.03.07）二、简介本部分大至介绍了LAMMPS的一些功能和缺陷。 1．什么是LAMMPS? LAMMPS是一个经典的分子动力学代码，他可以模拟液体中的粒子，固体和汽体的系综。他可以采用不同的力场和边界条件来模拟全原子，聚合物，生物，金属，粒状和粗料化体系。LAMMPS可以计算的体系小至几个粒子，大到上百万甚至是上亿个粒子。 LAMMPS可以在单个处理器的台式机和笔记本本上运行且有较高的计算效率，但是它是专门为并行计算机设计的。他可以在任何一个按装了C++编译器和MPI的平台上运算，这其中当然包括分布式和共享式并行机和Beowulf型的集群机。 LAMMPS是一可以修改和扩展的计算程序，比如，可以加上一些新的力场，原子模型，边界条件和诊断功能等。通常意义上来讲，LAMMPS是根据不同的边界条件和初始条件对通过短程和长程力相互作用的分子，原子和宏观粒子集合对它们的牛顿运动方程进行积分。高效率计算的LAMMPS通过采用相邻清单来跟踪他们邻近的粒子。这些清单是根据粒子间的短程互拆力的大小进行优化过的，目的是防止局部粒子密度过高。在

并行机上，LAMMPS采用的是空间分解技术来分配模拟的区域，把整个模拟空间分成较小的三维小空间，其中每一个小空间可以分配在一个处理器上。各个处理器之间相互通信并且存储每一个小空间边界上的”ghost”原子的信息。LAMMPS(并行情况)在模拟3维矩行盒子并且具有近均一密度的体系时效率最高。 2．LAMMPS的功能总体功能：可以串行和并行计算分布式MPI策略模拟空间的分解并行机制开源高移植性C++语言编写 MPI和单处理器串行FFT的可选性（自定义）可以方便的为之扩展上新特征和功能只需一个输入脚本就可运行有定义和使用变量和方程完备语法规则在运行过程中循环的控制都有严格的规则只要一个输入脚本试就可以同时实现一个或多个模拟任务粒子和模拟的类型：（atom style命令）原子粗粒化粒子全原子聚合物，有机分子，蛋白质，DNA

LINUX编程 Makefile中的变量详解应用

第六章：Makefile中的变量 -------------------------------------------------------------------------------- 在Makefile中，变量就是一个名字（像是C语言中的宏），代表一个文本字符串（变量的值）。在Makefile的目标、依赖、命令中引用一个变量的地方，变量会被它的值所取代（与C语言中宏引用的方式相同，因此其他版本的make也把变量称之为“宏”）。在Makefile中变量的特征有以下几点： 1. Makefile中变量和函数的展开（除规则的命令行以外），是在make读取makefile文件时进行的，这里的变量包括了使用“=”定义和使用指示符“define”定义的。 2. 变量可以用来代表一个文件名列表、编译选项列表、程序运行的选项参数列表、搜索源文件的目录列表、编译输出的目录列表和所有我们能够想到的事物。 3. 变量名是不包括“:”、“#”、“=”、前置空白和尾空白的任何字符串。需要注意的是，尽管在GNU make中没有对变量的命名有其它的限制，但定义一个包含除字母、数字和下划线以外的变量的做法也是不可取的，因为除字母、数字和下划线以外的其它字符可能会在以后的make版本中被赋予特殊含义，并且这样命名的变量对于一些shell来说不能作为环境变量使用。 4. 变量名是大小写敏感的。变量“foo”、“Foo”和“FOO”指的是三个不同的变量。Makefile 传统做法是变量名是全采用大写的方式。推荐的做法是在对于内部定义定义的一般变量（例如：目标文件列表objects）使用小写方式，而对于一些参数列表（例如：编译选项CFLAGS）采用大写方式，这并不是要求的。但需要强调一点：对于一个工程，所有Makefile中的变量命名应保持一种风格，否则会显得你是一个蹩脚的程序员（就像代码的变量命名风格一样）。 5. 另外有一些变量名只包含了一个或者很少的几个特殊的字符（符号）。称它们为自动化变量。像“$<”、“$@”、“$?”、“$*”等。 6.1 变量的引用当我们定义了一个变量之后，就可以在Makefile的很多地方使用这个变量。变量的引用方式是：使用“$（VARIABLE_NAME）”或者“${ VARIABLE_NAME }”来引用一个变量的定义。例如：“$(foo) ”或者“${foo}”就是取变量“foo”的值。美元符号“$”在Makefile中有特殊的含义，所有在命令或者文件名中使用“$”时需要用两个美元符号“$$”来表示。对一个变量的引用可以在Makefile的任何上下文中，目标、依赖、命令、绝大多数指示符和新变量的赋值中。这里有一个例子，其中变量保存了所有.o文件的列表： objects = program.o foo.o utils.o program : $(objects) cc -o program $(objects)

windows下的makefile教程

windows下的makefile教程 https://www.360docs.net/doc/d915411969.html,/mirror_hc/archive/2008/03/26/2221117.aspx joeliu 制作4/19/2011 22:10:29 1. 先说几句废话以前看书时经常遇到makefile，nmake这几个名词，然后随之而来的就是一大段莫名其妙的代码，把我看得云里雾里的。在图书馆和google上搜了半天，也只能找到一些零零星星的资料，把我一直郁闷得不行。最近因缘巧合，被我搞到了一份传说中的MASM6手册，终于揭开了NMAKE的庐山真面目。想到那些可能正遭受着同样苦难的同志以及那些看到E文就头晕的兄弟，所以就写了这篇文章。假如大家觉得有帮助的话，记得回复一下，当作鼓励！如果觉得很白痴,也请扔几个鸡蛋.本文是总结加翻译，对于一些关键词以及一些不是很确定的句子，保留了英文原版，然后再在括号里给出自己的理解以作参考。由于水平有限，加上使用NMAKE的经验尚浅，有不对的地方大家记得要指正唷。MASM6手册在AOGO（好像是）可以download，在我的BLOG上有到那的链接。 2. 关于NMAKE Microsoft Program Maintenance Utility，外号NMAKE，顾名思义，是用来管理程序的工具。其实说白了，就是一个解释程序。它处理一种叫做makefile的文件（以mak为后缀），解释里面的语句并执行相应的指令。我们编写makefile文件，按照规定的语法描述文件之间的依赖关系，以及与该依赖关系相关联的一系列操作。然后在调用NMAKE时，它会检查所有相关的文件，如果目标文件（target file，下文简称target，即依赖于其它文件的文件）的time stamp（就是文件最后一次被修改的时间，一个32位数，表示距离1980年以来经过的时间，以2秒为单位）小于依赖文件（dependent file，下文简称dependent，即被依赖的文件）的time stamp，NMAKE就执行与该依赖关系相关联的操作。请看下面这个例子：foo.exe : first.obj second.obj link first.obj,second.obj 第一行定义了依赖关系，称为dependency line；第二行给出了与该依赖关系相关联的操作，称为command line。因为foo.exe由first.obj和second.obj连接而成，所以说foo.exe依赖于first.ogj和second.obj，即foo.exe为target，first.obj和second.obj为dependent。如果first.obj和second.obj中的任何一个被修改了（其time stamp更大），则调用link.exe，重新连接生成foo.exe。这就是NMAKE的执行逻辑。综上，NMAKE的核心就是这3个家伙——依赖关系，操作和判定逻辑（target.timestamp < dependent.timestamp，如果为true，就执行相应操作）。 3. MAKEFILE的语法现在详细讨论一下makefile的语法。makefile就像一个玩具型的程序语言，麻雀虽小，但五脏具全。makefile的组成部分包括：描述语句（description block），推导规则（inference rules），宏和指令（directive）。描述语句就是dependent lines和command lines的组合；推导规则就是预先定义好的或用户自己定义的依赖关系和关联命令；宏就不用说了吧；指令就是内定的一些可以被NMAKE识别的控制命令，提供了很多有用的功能。 3.1 特殊符号

Linux如何写makefile文件

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

make_Makefile 结构分析

Makefile结构分析 -----uClinux （2.6.x内核）系统映像过程刘江欧阳昭暐吕熙隆 1、源代码文件及目录构成解压缩uClinux-dist-20070130.tar.gz压缩文件，在uClinux-dist原始子目录下主要有：config、Bin、linux-2.4.x、linux-2.6.x 、lib、tools、Include、user和vendors，以及文件Makefile。另外，在编译后生成子目录images和romfs，以及文件autoconfig.h、config.in和两个隐含文件：.config和.depend。 config子目录包含文件及下一级子目录，如 config.in、configure.help、Fixconfig、Makefile、 Mkconfig、Setconfig所有这些文件及子目录 Scripts均与系统配置有关； linux-2.6.x子目录是嵌入式操作系统 uClinux-2.6.x的核心目录，包括下一级子目录 arch、include、init、drivers、fs、ipc、kernel、 lib、Mm、scripts和关键文件Makefile、 rules.make，编译后还要生成新文件romfs.o、linux 和system.map；lib子目录为嵌入式操作系统提供压缩和改进了的函数库支持；tools子目录包含 romfs-inst.sh文件，通过调用此文件，可以把目录或文件加入到romfs子目录中；user子目录包含各种驱动程序文件目录，根据用户的配置情况，不同的驱动程序会被编译进最后形成的操作系统中； vendors子目录包括与特定硬件平台相关的分类目录组。目录结构如图1所示。 Makefile的详细介绍情况在 uClinux-dist\linux-2.6.x\Documentation\kbuil d中，如图2所示。图1、目录结构即Linux 内核中的 Makefile 以及与 Makefile 直接相关的文件有：

3-Makefile书写规则

3 Makefile书写规则规则包含两个部分，一个是依赖关系，一个是生成目标的方法。在Makefile中，规则的顺序是很重要的，因为，Makefile中只应该有一个最终目标，其它的目标都是被这个目标所连带出来的，所以一定要让make知道你的最终目标是什么。一般来说，定义在Makefile中的目标可能会有很多，但是第一条规则中的目标将被确立为最终的目标。如果第一条规则中的目标有很多个，那么，第一个目标会成为最终的目标。make所完成的也就是这个目标。好了，还是让我们来看一看如何书写规则。 3.1 规则举例 foo.o : foo.c defs.h # foo模块 cc -c -g foo.c 看到这个例子，各位应该不是很陌生了，前面也已说过，foo.o是我们的目标，foo.c和defs.h是目标所依赖的源文件，而只有一个命令“cc -c - g foo.c”（以Tab键开头）。这个规则告诉我们两件事： 1. 文件的依赖关系，foo.o依赖于foo.c和defs.h的文件，如果foo.c 和defs.h的文件日期要比foo.o文件日期要新，或是foo.o不存在，那么依赖关系发生。 2. 如果生成（或更新）foo.o文件。也就是那个cc命令，其说明了，如何生成foo.o这个文件。（当然foo.c文件include了defs.h 文件） 3.2 规则的语法 targets : prerequisites command

... 或是这样： targets : prerequisites ; command command ... targets是文件名，以空格分开，可以使用通配符。一般来说，我们的目标基本上是一个文件，但也有可能是多个文件。 command是命令行，如果其不与“target:prerequisites”在一行，那么，必须以[Tab键]开头，如果和prerequisites在一行，那么可以用分号做为分隔。（见上） prerequisites也就是目标所依赖的文件（或依赖目标）。如果其中的某个文件要比目标文件要新，那么，目标就被认为是“过时的”，被认为是需要重生成的。这个在前面已经讲过了。如果命令太长，你可以使用反斜框（‘\’）作为换行符。make对一行上有多少个字符没有限制。规则告诉make两件事，文件的依赖关系和如何成成目标文件。一般来说，make会以UNIX的标准Shell，也就是/bin/sh来执行命令。3.3 在规则中使用通配符如果我们想定义一系列比较类似的文件，我们很自然地就想起使用通配符。make支持三各通配符：“*”，“?”和“[...]”。这是和Unix的B-Shell是相同的。波浪号（“~”）字符在文件名中也有比较特殊的用途。如果是“~/test”，这就表示当前用户的$HOME目录下的test目录。而“~hchen/test”则表示用户hchen的宿主目录下的test目录。（这些都是Unix下的小知识了，make也支持）而在Windows或是MS-DOS下，用户没有宿主目录，那么波浪号所指的目录则根据环境变量“HOME”而定。

Linux下Makefile简单教程

目录一：Makefile基本规则 1.1示例 1.2 隐式规则 1.3 伪目标 1.4 搜索源文件二：变量 2.1使用变量定义变量值 2.2追加变量三：条件判断四：函数

Linux下Makefile总结 ——一步 MakeFile可以看做是一种简单的编程语言，其诞生的本质目的是实现自动化编译。以Linux下gcc-c编译器为例，编译一个c语言程序需要经过以下几个步骤： 1.将c语言源程序预处理，生成.i文件； 2.预处理后的.i语言编译成汇编语言，生成.s文件； 3.汇编语言经过汇编，生成目标文件.o文件； 4.将各个模块的.o文件链接起来，生成一个可执行程序文件。我们知道，在Visual C++6.0中，可以新建一个工程，在一个工程当中能够包含若干个c语言文件，则编译的时候直接编译整个工程便可。Linux下无法为多个c语言文件新建工程，但可以通过MakeFile实现它们的整合编译。如上gcc-c编译步骤，如果使用Makefile则过程为： .C文件——>.o文件——>可执行文件当然，Makefile中也加入了自己的设置变量方法与集成了一些函数，能够更有效地方便用户使用。 /**************************分隔符********************************/

一：Makefile基本规则 1.1示例 target ... : prerequisites ... command ... ... target也就是一个目标文件，可以是Object File，也可以是执行文件。prerequisites就是，要生成那个target所需要的文件或是目标。command也就是make需要执行的命令。（任意的Shell命令）为了方便理解，我们来看一个示例： /*Makefile示例*/ edit : main.o kbd.o command.o display.o / insert.o search.o files.o utils.o gcc -o edit main.o kbd.o command.o display.o / insert.o search.o files.o utils.o main.o : main.c defs.h #生成main.o gcc -c main.c

Makefile 语法分析

Makefile 语法分析第一部分 VERSION = 2 # 给变量VERSION赋值 PATCHLEVEL = 6 # 给变量PATCHLEVEL赋值 SUBLEVEL = 22 # 给变量SUBLEVEL赋值 EXTRAVERSION = .6 # 给变量EXTRAVERSION赋值 NAME = Holy Dancing Manatees, Batman! # 给变量NAME赋值 # *DOCUMENTATION* # To see a list of typical targets execute "make help" # More info can be located in ./README # Comments in this file are targeted only to the developer, do not # expect to learn how to build the kernel reading this file. # Do not: # o use make's built-in rules and variables # (this increases performance and avoid hard-to-debug behavour); # o print "Entering directory ..."; MAKEFLAGS += -rR --no-print-directory # 操作符“+=”的作用是给变量（“+=”前面的MAKEFLAGS）追加值。 # 如果变量（“+=”前面的MAKEFLAGS）之前没有定义过，那么，“+=”会自动变成“=”； # 如果前面有变量（“+=”前面的MAKEFLAGS）定义，那么“+=”会继承于前次操作的赋值符；# 如果前一次的是“:=”，那么“+=”会以“:=”作为其赋值符 # 在执行make时的命令行选项参数被通过变量“MAKEFLAGS”传递给子目录下的make程序。# 对于这个变量除非使用指示符“unexport”对它们进行声明，它们在整个make的执行过程中始终被自动的传递给所有的子make。 # 还有个特殊变量SHELL与MAKEFLAGS一样，默认情况（没有用“unexport”声明）下在整个make的执行过程中被自动的传递给所有的子make。 # # -rR --no-print-directory # -r disable the built-in impilict rules. # -R disable the built-in variable setttings. # --no-print-directory。 # We are using a recursive build, so we need to do a little thinking # to get the ordering right. # # Most importantly: sub-Makefiles should only ever modify files in # their own directory. If in some directory we have a dependency on # a file in another dir (which doesn't happen often, but it's often # unavoidable when linking the built-in.o targets which finally # turn into vmlinux), we will call a sub make in that other dir, and

如何学好并精通C语言

程序员之路——如何学习C语言并精通C语言程序员之路——如何学习C语言学习C语言不是一朝一夕的事情，但也不需要花费十年时间才能精通。如何以最小的代价学习并精通C 语言是本文的主题。请注意，即使是“最小的代价”，也绝不是什么捷径，而是以最短的时间取得最多的收获，同时也意味着你需要经历艰苦的过程。一、要读就读好书，否则不如不读所有初学者面临的第一个问题便是：如何选择教材。好的开始是成功的一半，选择一本优秀的教材是事半功倍的关键因素。不幸的是，学校通常会帮你指定一本很差劲的C语言课本；而幸运的是，你还可以再次选择。大名鼎鼎的谭浩强教授出了一本《C语言程序设计》，据说发行量有超过400万，据我所知，很多学校都会推荐这本书作为C语言课本。虽然本人的名字（谭浩宇）跟教授仅仅一字之差，但我是无比坚定地黑他这本书的。这本书不是写给计算机专业的学生的，而是给那些需要考计算机等级考试的其它专业学生看的。这本书的主要缺点是：例子程序非常不专业，不能教给你程序设计应该掌握的思考方式；程序风格相当地不好，会让你养成乱写代码的恶习；错误太多，曾经有人指出过这本书的上百个错误，其中不乏关键的概念性错误。好了，这本书我也不想说太多了，有兴趣大家可以百度一下：） Kernighan和Ritchie的《The C Programming Language》（中译名《C程序设计语言》）堪称经典中的经典，不过旧版的很多内容都已过时，和现在的标准C语言相去甚远，大家一定要看最新的版本，否则不如不看。另外，即使是最经典最权威的书，也没有办法面面俱到，所以手边常备一本《C语言参考手册》是十分必要的。《C语言参考手册》就是《C Reference Manual》，是C语言标准的详细描述，包括绝大多数C标准库函数的细节，算得上是最好的标准C语言的工具书。顺便提一句，最新的《C程序设计语言》是根据C89标准修订的，而《C语言参考手册》描述的是C99标准，二者可能会有些出入，建议按照C99标准学习。还有一本《C和指针》，写得也是相当地不错，英文名是《Pointers on C》，特别地强调指针的重要性，算是本书的一个特点吧。不过这本书并不十分适合初学者，如果你曾经学过C语言，有那么一些C语言的基础但又不是很扎实，那么你可以尝试一下这本书。我相信，只要你理解了指针，C语言便不再神秘。如果你已经啃完了一本C语言教材，想要更进一步，那么有两本书你一定要看。首先是《C Traps and Pitfalls》（中译名《C陷井与缺陷》），很薄的一本小册子，内容非常非常地有趣。要注意一点，这本书是二十多年前写成的，里面提到的很多C语言的缺陷都已被改进，不过能够了解一些历史也不是什么坏事。然后你可以挑战一下《Expert C Programming》（中译名《C专家编程》），书如其名，这本书颇具难度，一旦你仔细读完并能透彻理解，你便可以放心大胆地在简历上写“精通C语言”了。切记一个原则，不要读自己目前还看不懂的书，那是浪费生命。如果你看不懂，那你一定是缺失了某些必需基础知识。此时，你要仔细分析自己需要补充哪些内容，然后再去书店寻找讲述的这些内容的书籍。把基础知识补充完毕再回头来学习，才会真正的事半功倍。二、Unix/Linux还是Windows，这是个很大的问题不同的编程环境会造就出不同思维的程序员。Windows的程序员大多依赖集成开发环境，比如Visual Studio，而Unix程序员更加钟爱Makefile与控制台。显而易见，集成开发环境更容易上手，在Windows上学习C语言，只需要会按几个基本的Visutal C++工具栏按钮就可以开始写Hello, World!了，而在Unix下，你需要一些控制台操作的基本知识。有人也许认为Unix的环境更简洁，但习惯的力量是很大的，大家都很熟悉Windows的基本操作，而为了学习C语言去专门装一个Unix系统，似乎有点不划算。对于一个只懂得Windows基本操作、连DOS是什么都不知道的新手而言，尽快做一些有趣而有意义的事情才是最重要的。用C语言写一个小程序远比学习ls、cat等命令有趣，况且我们要专注于C语言本身，就不得不暂时忽略一些东西，比如编译链接的过程、Makefile的写法等等等等。所以我建议初学者应该以Visual C++ 6.0（不是VisualC++ .NET）或者Dev C++作为主要的学习环境，而且千万不要在IDE的使用技巧上过多纠缠，因为今后你一定要转向Unix环境的。Visual C++ 6.0使用很方便，调试也很直观，但其默认的编译器对C标准的支持并不好，而Dev C++使用gcc编译器，对C99的标准都支持良好。使用顺带提一下，很多大学的C语言课程还在使用Turbo C 2.0作为实验环境，这是相当不可取的，原因其一是TC 2.0对C标准几乎没有支持，其二是TC 2.0编译得到的程序是16位的，这对今后理解32位的程序会造成极大的困扰（当然,用djgpp之类的东西可以使TC

MAKEfile教程

概述 —— 什么是makefile？或许很多Winodws的程序员都不知道这个东西，因为那些Windows的IDE 都为你做了这个工作，但我觉得要作一个好的和professional的程序员，makefile还是要懂。这就好像现在有这么多的HTML的编辑器，但如果你想成为一个专业人士，你还是要了解HTML 的标识的含义。特别在Unix下的软件编译，你就不能不自己写makefile了，会不会写makefile，从一个侧面说明了一个人是否具备完成大型工程的能力。因为，makefile关系到了整个工程的编译规则。一个工程中的源文件不计数，其按类型、功能、模块分别放在若干个目录中，makefile定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作，因为makefile就像一个Shell脚本一样，其中也可以执行操作系统的命令。 makefile带来的好处就是——―自动化编译‖，一旦写好，只需要一个make命令，整个工程完全自动编译，极大的提高了软件开发的效率。make是一个命令工具，是一个解释makefile中指令的命令工具，一般来说，大多数的IDE都有这个命令，比如：Delphi的make，Visual C++的nmake，Linux下GNU的make。可见，makefile都成为了一种在工程方面的编译方法。现在讲述如何写makefile的文章比较少，这是我想写这篇文章的原因。当然，不同产商的make 各不相同，也有不同的语法，但其本质都是在―文件依赖性‖上做文章，这里，我仅对GNU的make进行讲述，我的环境是RedHat Linux 8.0，make的版本是3.80。必竟，这个make 是应用最为广泛的，也是用得最多的。而且其还是最遵循于IEEE 1003.2-1992 标准的（POSIX.2）。在这篇文档中，将以C/C++的源码作为我们基础，所以必然涉及一些关于C/C++的编译的知识，相关于这方面的内容，还请各位查看相关的编译器的文档。这里所默认的编译器是UNIX 下的GCC和CC。关于程序的编译和链接 —————————— 在此，我想多说关于程序编译的一些规范和方法，一般来说，无论是C、C++、还是pas，首先要把源文件编译成中间代码文件，在Windows下也就是 .obj 文件，UNIX下是 .o 文件，即Object File，这个动作叫做编译（compile）。然后再把大量的Object File合成执行文件，这个动作叫作链接（link）。编译时，编译器需要的是语法的正确，函数与变量的声明的正确。对于后者，通常是你需要告诉编译器头文件的所在位置（头文件中应该只是声明，而定义应该放在C/C++文件中），只要所有的语法正确，编译器就可以编译出中间目标文件。一般来说，每个源文件都应该对应于一个中间目标文件（O文件或是OBJ文件）。

c 程序的书写格式

c 程序的书写格式 c++程序的书写格式2010-05-18 17：03文件结构文件头注释所有C++的源文件均必须包含一个规范的文件头，文件头包含了该文件的名称、功能概述、作者、版权和版本历史信息等内容。标准文件头的格式为：/*！@file*PRE模块名：文件所属的模块名称文件名：文件名相关文件：与此文件相关的其它文件文件实现功能：描述该文件实现的主要功能作者：作者部门和姓名版本：当前版本号--备注：其它说明--修改记录：日期版本修改人修改内容YYYY/MM/DD X.Y作者或修改者名修改内容/PRE*/如果该文件有其它需要说明的地方，还可以专门为此扩展一节：/*！@file*PRE模块名：文件所属的模块名称文件名：文件名相关文件：与此文件相关的其它文件文件实现功能：描述该文件实现的主要功能作者：作者部门和姓名版本：当前版本号--备注：其它说明--修改记录：日期版本修改人修改内容YYYY/MM/DD X.Y作者或修改者名修改内容/PRE**项目1-项目1.1-项目1.2==*项目2-项目2.1-项目2.2.*/每行注释的长度都不应该超过80个半角字符。还要注意缩进和对其，以利阅读。关于文件头的完整例子，请参见：文件头例子关于文件头的模板，请参见：文件头注释模板头文件头文件通常由以下几部分组成：文件头注释每个头文件，无论是内部的还是外部的，都应该由一个规范的文件头注释作为开始。预处理块为了防止头文件被重复引用，应当用ifndef/define/endif结构产生预处理块。函数和类/结构的声明等声明模块的接口需要包含的内联函数定义文件(如果有的话)如果类中的内联函数较多，或者一个头文件中包含多个类的定义(不推荐)，可以将所有内联函数定义放入一个单独的内联函数定义文件中，并在类声明之后用 "#include"指令把它包含进来。头文件的编码规则：引用文件的格式用 #include filename.h格式来引用标准库和系统库的头文件(编译器将从标准库目录开始搜索)。用#include"filename.h"格式来引用当前工程中的头文件(编译器将从该文件所在目录开始搜索)。分割多组接口(如果有的话)如果在一个头件中定义了多个类或者多组接口(不推荐)，为了便于浏览，应该在每个类/每组接口间使用分割带把它们相互分开。关于头文件的完整例子，请参见：头文件例子内联函数定义文件如上所述，在内联函数较多的情况下，为了避免头文件过长、版面混乱，可以将所有的内联函数定义移到一个单独的文件中去，然后再用#include指令将它包含到类声明的后面。这样的文件称为一个内联函数定

makefile 中文手册第六章 _ Makefile中的变量

第六章：Makefile中的变量在Makefile中，变量是一个名字（像是C语言中的宏），代表一个文本字符串（变量的值）。在Makefile的目标、依赖、命令中引用变量的地方，变量会被它的值所取代（与C语言中宏引用的方式相同，因此其他版本的make也把变量称之为“宏”）。在Makefile中变量有以下几个特征： 1.Makefile中变量和函数的展开（除规则命令行中的变量和函数以外），是在make读取makefile文件时进行的，这里的变量包括了使用“=”定义和使用指示符“define”定义的。 2.变量可以用来代表一个文件名列表、编译选项列表、程序运行的选项参数列表、搜索源文件的目录列表、编译输出的目录列表和所有我们能够想到的事物。 3.变量名是不包括“:”、“#”、“=”、前置空白和尾空白的任何字符串。需要注意的是，尽管在GNU make中没有对变量的命名有其它的限制，但定义一个包含除字母、数字和下划线以外的变量的做法也是不可取的，因为除字母、数字和下划线以外的其它字符可能会在make的后续版本中被赋予特殊含义，并且这样命名的变量对于一些shell来说是不能被作为环境变量来使用的。 4.变量名是大小写敏感的。变量“foo”、“Foo”和“FOO”指的是三个不同的变量。Makefile传统做法是变量名是全采用大写的方式。推荐的做法是在对于内部定义定义的一般变量（例如：目标文件列表objects）使用小写方式，而对于一些参数列表（例如：编译选项CFLAGS）采用大写方式，但这并不是要求的。但需要强调一点：对于一个工程，所有Makefile中的变量命名应保持一种风格，否则会显得你是一个蹩脚的程序员（就像代码的变量命名风格一样）。 5.另外有一些变量名只包含了一个或者很少的几个特殊的字符（符号）。称它们为自动化变量。像“$<”、“$@”、“$?”、“$*”等。 6.1变量的引用当我们定义了一个变量之后，就可以在Makefile的很多地方使用这个变量。变量的引用方式是：“$（VARIABLE_NAME）”或者“${ VARIABLE_NAME }”来引用一个变量的定义。例如：“$(foo)”或者“${foo}”就是取变量“foo”的值。美元符号“$”在Makefile中有特殊的含义，所有在命令或者文件名中使用“$”时需要用两个美元符号“$$”来表示。对一个变量的引用可以在Makefile的任何上下文中，目标、依赖、命令、绝大多数指示符和新变量的赋值中。这里有一个例子，其中变量保存了所有.o文件的列表： objects = program.o foo.o utils.o program : $(objects) cc -o program $(objects) $(objects) : defs.h 变量引用的展开过程是严格的文本替换过程，就是说变量值的字符串被精确的展开在变量被引用的地方。因此规则： foo = c prog.o : prog.$(foo) $(foo) $(foo) -$(foo) prog.$(foo) 被展开后就是：

实例—使用make及Makefile文件

2.3 实例—使用make及Makefile文件一个工程有3个头文件（head1.h、head2.h、exam2.h）和8个C文件（main.c、exam1.c、exam2.c、exam3.c、exam4.c、exam5.c、exam6.c、exam7.c），建立一个Makefile文件（文件名为makefile），内容如下。注意，上述12个文件位于同一个目录中。 example : main.o exam1.o exam2.o exam3.o exam4.o exam5.o exam6.o exam7.o gcc -o example main.o exam1.o exam2.o exam3.o exam4.o exam5.o exam6.o exam7.o main.o : main.c head1.h gcc -c main.c exam1.o : exam1.c head1.h exam2.h gcc -c exam1.c exam2.o : exam2.c head1.h exam2.h gcc -c exam2.c exam3.o : exam3.c head1.h head2.h gcc -c exam3.c exam4.o : exam4.c head1.h head2.h gcc -c exam4.c exam5.o : exam5.c head1.h head2.h gcc -c exam5.c exam6.o : exam6.c head1.h head2.h exam2.h gcc -c exam6.c exam7.o : exam7.c head1.h gcc -c exam7.c clean : rm example main.o exam1.o exam2.o exam3.o exam4.o exam5.o exam6.o exam7.o makefile文件告诉make命令如何编译和链接这几个文件。在当前路径下执行make命令，就可以生成可执行文件example。如果要删除可执行文件和所有的中间目标文件，只需执行make clean命令即可。 Makefile文件的操作规则是： ①如果该工程没有编译过，所有C文件都要编译并被链接。 ②如果该工程的某几个C文件被修改，只需编译被修改的C文件，并链接目标程序。 ③如果该工程的头文件被改变，需要编译包含这些头文件的C文件，并链接目标程序。在这个Makefile文件中，目标文件（target）有：执行文件example和中间目标文件（*.o）；依赖文件（prerequisites）有：冒号后面的.c文件和.h文件。每一个.o文件都有一组依赖文件，而这些.o文件又是执行文件example的依赖文件。依赖关系是指目标文件由哪些文件生成。在定义好依赖关系后，规则命令定义了如何生成目标文件，其一定要以一个Tab键打头。 make会比较targets文件和prerequisites文件的时间戳，如果prerequisites文件的日期比targets文件的日期要新，或者target不存在，make就会执行相应的规则命令。默认方式下，执行make命令时，make会在当前目录下找Makefile，如果找到，make 会找文件中的第一个目标文件（target），上面的例子是example文件，并把这个文件作为最终的目标文件。如果example文件不存在，或example所依赖的.o文件的修改时间比example 文件新，make就会执行相应的规则命令生成example文件。如果example所依赖的.o文件不存在，make会在当前目录中找目标为.o文件的依赖文件（C文件和H文件），如果找到，则根据规则生成.o文件，然后再用.o文件生成make的最终结果，也就是可执行文件example。有上可知，make会一层一层地去找文件的依赖关系，直到最终编译出第一个目标文件。在寻找的过程中，如果出现错误（比如被依赖的文件找不到）make就会直接退出，并报错。 clean不是一个文件，只是一个动作名字，类似于C语言中的lable，冒号后什么也没有，这样make就不会自动去找文件的依赖性，也就不会自动执行其后所定义的规则命令。要执行其后的命令，就要在make命令后显式的指出这个lable的名字，例如执行make clean命令。

简单的Makefile

手动建立makefile简单实例解析

LAMMPS手册-中文版讲解之欧阳家百创编

LINUX编程 Makefile中的变量详解应用

windows下的makefile教程

Linux如何写makefile文件

make_Makefile 结构分析

3-Makefile书写规则

Linux下Makefile简单教程

Makefile 语法分析

如何学好并精通C语言

MAKEfile教程

c 程序的书写格式

makefile 中文手册 第六章 _ Makefile中的变量

实例—使用make及Makefile文件

makefile 中文手册第六章 _ Makefile中的变量