(完整版)浅谈手动书写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不是个明智之举。
我们在手动书写Makefile时（此心得面向是略微看过Makefile的编写规则。如果没看过，可以参考这个文章“大家一起写Makefile”里面有蛮详细的介绍）一个简单的makefile的书写。我们只需要把握编译选项，链接选项目标依赖文件等
给大家分享下自己的自己对编译和链接的领悟（勿拍砖）编译就是将检测各种源文件的语法是否正确。我们称之为是从.c→到.o的过程。这个过程中只是检测语法错误。而链接过程我称之为从.o→.a或者.la 然后从.a(la)到可执行文件的过程。其中有心的各位会发现.a或者.la 是一个很大的文件。笔者以为这只是个中间连接文件。就是把所有的函数。调用子函数。以及嵌套调用的函数在中间文件里铺开的过程。
现在以笔者最近的一个例子作为分析进入到Makefile文件的编写中；CROSSCOMPILE :=arm-linux-
CC :=$(CROSSCOMPILE)gcc
LD :=$(CROSSCOMPILE)ld
LDFLAGS := -lm
CLFAGS := -Wall -02 -c -g
CFLAGS += -I $(PWD)
OBJS :=bitstream.o\
mask.o\
mmask.o\
mqrspec.o\
qren.o\
qrencode.o\
qrinput.o\
qrspec.o\
rscode.o\
split.o
.PHONY:%.o
%.o:%.c
$(CC) $(CFLAGS) $< -o $@
all:$(OBJS)
$(CC) $(LDFLAGS) -o qrencode $^
.PHONY:clean
clean:
rm -rf $(OBJS) qrencode
很明显这是个属于极其简单的Makefile文件。有初学者会认为。很多我拿到的代码里已经有了Makefile 我干嘛还有学习Makefile编写呢？我觉得对于只想移植。不想开发的朋友来说或许足够了。但是对于我们要往深水区来游的小同志来说。显然Makefile的编写和shellscript 的编写。很明显是我们的必修课。这是我们对大工程把握水平的体现。
结束废话：开始分析Makefile的写法：
首先进come到我们面前的是CROSSCOMPILE :=arm-linux
CROSSCOMPILE :=这是个变量定义而且是一个可以传递到底层Makefile文件的定义变量。而且必须是传递到底层。然而一旦传递的底层。它必然是个环境变量。所以可以选择export linux 下的命令来全局化。所以Makefile中变量的定义是如果需要引入到环境变量中请选择全程大写。如果仅是这个Makefile中使用。不会用到子目录Makefile中，请选择小写。当然即使大写我们也需要配合export后才可传递到底层Makefile
按照进程的思想，当前Makefile层是一个进程，调用下一层Makefile的过程就是开启一个新的进程。调用下一个进程使用include + Makefile文件
第二个符号：= 这是个环境变量的定义。
= 表示定义一个新的变量。：=表示是如果前边定义过了则选择是覆盖之前的定义。+=表示追加。？=则是表示如果询问定义，既是如果前边定义了，这里不在定义。
而arm-linux-gcc这里所说的是arm下交叉编译工具而gcc则是linux下的编译工具
当然如果选择的是C++ 则是g++ 和arm-linux-g++ 这里采用C语言。毕竟编译和链接过程跟C++ 类似。
上述二位是非常敬畏的了编译器。因为linux下它的出现解决了编译工具的问题。
而编译对应的是链接。链接分别对应的是arm-linux-ld 和ld 当然不同的交叉编译版本不同。可能略有差别。只有交叉编译的概念。如有误解请问伟大的度娘或者强大的360
CC以及LD这里定义的是编译器和链接器这里采用可以方便修改的做法。用的是变量替代。往下走时是我们的参数传递。我们知道在linux命令行下使用gcc 或者arm-linux-gcc时我们也会有参数传入，这里就是我们所说的参数传递。参数传递的意思则是
-lm则是告诉编译器如果数学库找不到请到/libs下找。我们是需要数学库的
数学函数位于libm.so库文件中（这些库文件通常位于/lib目录下），-lm选项告诉编译器，我们程序中用到的数学函数要到这个库文件里找
一般参数很多我们这里只介绍必须的。很多是缺省的。就是了解有这回事。未必一定要用的-c 告诉编译器你编译的对象是.c
-o 告诉编译器编译无错后输出文件格式为.o
-static告诉编译器不用动态库，只是使用静态库（动态库和静态库的去一个是.so一个是.a）这个编译后会产生很大的文件。一般不使用
与之对应的这是只是使用动态库–share 这一般是我们的选择。
还有就是-S生成汇编文件
-E生成预处理文件
-wall 启动警告检测
-02 是编译器的级别一共00 01 02 03 四个编译器级别。-00表示没有优化,-01为缺省值，-03优化级别最高
-g 为在编译的时候，产生条是信息
-I指定头文件目录
$(PWD) 表示执行linux下命令pwd一个生成当前位置的变量。并替代了。
其余的参数如果有需要的可以自己查看拉。毕竟编译器是个很强大的。
参数的废话结束了那么我们进入到我们的目标定义
目标定义的一个显著符号则是：
如ALL：$(OBJS) 这里说明我们这就是编译的总目标
Makefile文件里可以定义编译一个目标，也可以定义编译多个目标（设计伪定义）
就是下面使用的关键字.PHONY
Makefile文件中总是默认第一个定义的目标作为总体的生成目标。使用上诉关键字后编译器就是知道了这里不是，只是一个伪目标。
通常配合着clean distclean 来使用。那就是后边的删除
Clean:
rm –rf $(OBJS) qrencode
这里指的是删除所有生成的目标文件
rm是linux下一个命令。不在叙述。
下边进入到奇怪的字符的解释：
$ 是一个用了很多遍的字符是一个具有替代功能的字符
如$(OBJS)就是替代我们定义的所有的变量。
还有就是$@ 是在编译过程中的所生成的目标文件
$<是我们所依赖的文件
$(CC) $(CFLAGS) $< -o $@
上述的语句就是CC替代arm-linux-gcc CGLAGS 用来替代我们的参数传递
$<表示依赖所有的.C 文件–c的参数传递在CFLAGS -o目的是生成.o 文件
所以S@则是目标文件
还有语句
%.o:%.c
“%”的意思是匹配零或若干字符
就是自动匹配这里的o和c 文件
$(CC) $(LDFLAGS) -o qrencode $^
这句话的解释则是编译生成qrencode的可执行文件。
$^的意思则是自动依赖所有的文件
所以看者不知道是否明白了一个手写Makefile的语法写的过程？
其实就是把我们平时写的arm-linux-gcc –c mian.c –o mian.o
原理类似。
至于Makefile中的自动查询的方式：
我们知道上述是一个隐式的Makefile的编写方式。
Makefile中* 为通配符这个玩过Linux肯定知道。还有就是换行符\
特别声明下如果在命令下加入@ 表示该条命令只是执行但不输出该条命令。
输出执行命令结果。
显式的编写方式往往看者很明白。但是很繁琐。
隐式的写法就是使用了自动匹配和静态编写的方式写成了上诉的Makefile
当然复杂的makefile还会有linux的shell命令的使用
还有就是我们的字符命令这里的简单书写个人感觉暂时用不着。
还有就是简单命令的使用
如ifeq
If neq
#ifdefne
Else
#end if
VPATH 用于声明代码的路径
Vpath %.c file
Vpath %.c file1
路径声明优先搜索file 和file1
Makefile下每条命令下执行正确了都会返回0 错误返回非0 然后检测退出。
Make –t =touch 更新目标文件时间但不进行新的编译。
Make –q =question 如果目标不在。打印输出。目标在，不显示
Make –f=file指定编译文件
这里感觉使用的就是这么几个。
至于字符函数的处理。笔者的功力真的没有那么深。暂时手动写Makefile过程中未使用过。
自动生成Makefile的过程为：
1．执行autoscane 生成configure.scan
2．然后手动修改configure.scan为configure.in 有的平台直接为configure.ac
3．修改configure.in 里面的内容。怎么修改。下文讲，这给给看客一个大致全过程。4．执行autoheader生成文件configure.h.in（现在一般改为configure.ac）。configure.in里有宏AC_CONFIG_HEADER()时用
5．运行libtoolize生成一些libtool 的文件这些文件跟平台适应性有关系。
6．运行autoconf 执行过程中会生成configure 文件
7．手动写makefile.am 写的过程下文详细介绍
8．执行automake –a 将makefile.am 生成Makefile.in 同时生成选项可以补齐文件config.guess，config.sub，install-sh，missing，depcomp
9．然后执行./configure 后边会有缺省的参数比如
生成文件生成config.status，config.h，makefile
对于符合GNU的源码通常目录下包含那些文件又有哪些组成？
必须有一个README主要是介绍源码包的详细信息。
一个INSTALLIN文件介绍安装包的使用方法和安装方式
一个configure文件主要配合Makefile.in 生成Makefile文件。
一个CONPYING 包含版本信息
一个CHANGELOG 包含软件的变化过程。
通常我们做顶层目录可以包含任何的信息，然后才是做底层的目录。分别设置其配置文件
我们用linux-2.26.32来分析：
顶层目录：
这里我们就可以看到一个大型工程里顶层目录的基本文件：
README CONPYING 等当然很多文件是我们后期执行make zImage时生成的。
但是我们通过这里见识到了源码的分类存放和基本的配置文件。
Arch架构下存放各种的关于架构的信息如：
当然linux系统下的跟我们这里讲的还是有差别的。Linux下不可能手动书写makefile 而是采用makemenuconfig 或者make Xconfig 来配置不同的执行对应着不同的脚本文件如make menuconfig 对应着是Kconfig 最后会被选择后进入到.configure 然后配合顶层makefile使用。而我们这里说的是应用软件的编写。
所以做GNU的文件源码我们一定要会源码分类放，同时学会修改configure.in
和手动编写Makefile.am
下文将着重介绍Makefile.am 编写和configure.in 修改
例如我们随便建立三个文件一个是main.c
一个是hello目录下main.c
#include
int main(int argc,int *argv)
{
int num[100];
int val=0;
int val2=0;
printf("argv[1]===%d \n",argv[0]);
printf("argv[2]===%d \n",argv[2]);
val=add(argv[1],argv[2]);
val2=lsl(argv[1],argv[2]);
printf("val=%d \n",val);
printf("val2=%d \n",val2);
return 0;
}
我们在add目录下建立add.c
#include
int add(int i,int j)
{
int num=i+j;
printf("here is add.c:\n");
return num;
}
在hello 下建立lsl
Lsl.c
#include
int lsl(int i,int j)
{
int val=i*j;
printf("here is lsl\n");
return val;
}
我们执行完autoscan后生成configure.scan 和autoscan.log
其实configure.scan就是configure.in的模板
于是我们的configure.scan内容就是
# -*- Autoconf -*-
# Process this file with autoconf to produce a configure script.
AC_PREREQ([2.63])
AC_INIT([FULL-PACKAGE-NAME],[VERSION],[BUG-REPORT-ADDRESS])
AC_CONFIG_HEADERS([config.h])
# Checks for programs.
AC_PROG_CC
# Checks for header files.
# Checks for typedefs, structures, and compiler characteristics.
# Checks for library functions.
AC_OUTPUT
而我们手动修改成configure.in后为
# -*- Autoconf -*-
# Process this file with autoconf to produce a configure script.
AC_PREREQ(2.61)
AC_INIT(hello, 1.0, [])
AM_INIT_AUTOMAKE(hello, 1.0)
AC_CONFIG_SRCDIR([main.c])
AC_CONFIG_HEADER([config.h])
# Checks for programs.
AC_PROG_CC
AC_PROG_LIBTOOL
# Checks for libraries.
# Checks for header files.
# Checks for typedefs, structures, and compiler characteristics.
# Checks for library functions.
AC_OUTPUT(Makefile add/Makefile lsl/Makefile)
通过对比我们发现其实我们只是更改了部分文件。
AC_PREREQ(2.61)
指的是我们使用的内核版本号
当然这里的输入接口AC_INIT(hello, 1.0, [])
分别指的是输入接口，源码包，源码包版本号，缺省
AM_INIT_AUTOMAKE(hello, 1.0) 这句话指的是我们要使用automake 所传入的宏定义。里面参数顾名思义也是源码包和版本号。
AC_CONFIG_HEADER([config.h])
这两句话一个指的是需要检查的目下下的文件，一个是config.h文件
如果confi.h文件不在，我们需要手动输入很多参数，如下：
Gcc-DPACKAGE_NAME=\"hellobb\"-DPACKAGE_TARNAME=\"hellobb\"-DPACKAGE-VERSION=\"1.
0\" -DPACKAGE_STRING=\"hellobb\ 1.0\" -DPACKAGE_BUGREPORT=\"\"
-DPACKAGE=\"hellobb\" -DVERSION=\"1.0\" -DSTDC_HEADERS=1 _DHAVE_SYS_TYPES_H=1 -DHAVE_UNISTDLIB_H=1 -DHAVE_STING_H=1 -DHAVE_MEMORY_H=1 -dHAVE_STRINGS_H=1 -DHAVE_INTTYPES_H=1 -DHAVE_STDINT_H=1 -DHAVE_UNISTD_H=1 -DHAVE_DLFCN_H=1 -DLT_OBJDIR=\"./libs/\" -I. -g -O2 -MT main.o -MD -MP -MF .deps/main.Tpo -c -o main.c
所以离开了config.h 是何等的麻烦。还有就是我们使用的
AC_PROG_CC
AC_PROG_LIBTOOL
一个指定的是CC 所替代的编译工具，工具的指定可以在configure处指定，也可是make 处指定
下一行这是指定使用LIBTOOL编译成库
最后的输出接口则是
AC_OUTPUT(Makefile add/Makefile lsl/Makefile)
指定生成的makefile文件
以上是简单地更改过程。
然后是makefile.am 书写过程
AUTOMAKE_OPTIONS = foreign
SUBDIRS = add lsl
bin_PROGRAMS = main
main_SOURCES = main.c
main_LDADD = add/https://www.360docs.net/doc/558323499.html, lsl/https://www.360docs.net/doc/558323499.html,
一个简单地makefile.am 顶层的书写
而各个底层也需要有自己的makefile.am
如下：
lib_LTLIBRARIES = https://www.360docs.net/doc/558323499.html,
liblsl_la_SOURCES = lsl.c
书写完成后，进过上述几步后你会发现我们看到GNU的文件基本都有了
然后就可以放心的执行make make install 等
如果想制作一个基于arm 平台的我们只需要在./configure 处加上交叉编译选项即可：
那么我们所需要更改的是
--host =arm-linux
指定软件运行的系统平台.如果没有指定,将会运行`config.guess'来检测
-build=BUILD
指定软件包安装的系统平台.如果没有指定,默认值将是'--host'选项的值.
--host=HOST
指定软件运行的系统平台.如果没有指定,将会运行`config.guess'来检测.
-srcdir=DIR
这个选项对安装没有作用.他会告诉'configure'源码的位置.一般来说不用指定此选项,因为
'configure'脚本一般和源码文件在同一个目录下.
--program-prefix=PREFIX
指定将被加到所安装程序的名字上的前缀.例如,使用'--program-prefix=g'来configure一个名为'tar'的程序将会使安装的程序被命名为'gtar'.当和其他的安装选项一起使用时,这个选项只有当他被`Makefile.in'文件使用时才会工作.
有时候你可能不想让你的软件包与系统已有的软件包交互.例如,你可能不想让你的新编译器使用GNU ld.通过使用这个选项可以做到这一点:
$ ./configure --without-gnu-ld
跟我一起写Makefile
跟我一起写Makefile 陈皓 1 概述 什么是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。 2 关于程序的编译和链接 在此，我想多说关于程序编译的一些规范和方法，一般来说，无论是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中找寻函数的实现，如果找不到，那到就会报链接错
手动建立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中“规则”就是描述在什么情况下、如何重建规则的目标文件，通常规则
Makefile下编写Helloworld的例子
什么是makefile？或许很多Windows的程序员都不知道这个东西，因为那些Windows的IDE都为你做了这个工作，但我觉得 要作一个好的和professional的程序员，makefile还是要懂。这就好像现在有这么多的HTML的编辑器，但如果你想成为一个专 业人士，你还是要了解HTML的标识的含义。特别在Unix下的软件编译，你就不能不自己写makefile了，会不会写makefile， 从一个侧面说明了一个人是否具备完成大型工程的能力。 因为，makefile关系到了整个工程的编译规则。一个工程中的源文件不计数，其按类型、功能、模块分别放在若干个目录中， makefile定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复 杂的功能操作，因为makefile就像一个Shell脚本一样，其中也可以执行操作系统的命令。 makefile带来的好处就是——“自动化编译”，一旦写好，只需要一个make 命令，整个工程完全自动编译，极大的提高了软件 开发的效率。make是一个命令工具，是一个解释makefile中指令的命令工具，一般来说，大多数的IDE都有这个命令，比如： Delphi的make，VisualC++的nmake，Linux下GNU的make。可见，makefile都成为了一种在工程方面的编译方法。 更新版本 hello.c程序 ＃include
return 0;}=== makefile开始=== Helloworld: hello.o gcc hello.o–o Helloworld Hello.o: hello.c hello.h gcc–MM hello.c gcc–c hello.c–o hello.o .PHONY: clean Clean: rm–rf*.o hellworld === makefile结束===
makefile新手教程
makefile新手教程 2013-11-08 本文翻译自https://www.360docs.net/doc/558323499.html,/tutorials/ Makefiles --通过示例说明 编译源代码是沉闷的，尤其是当你想要include一些源代码，却又每次都需要手动敲编译命令的时候。 恩，我有个好消息告诉你...你用手敲命令行去编译的日子（基本上）一去不复返了，因为你将会学习如何编写Makefile。Makefile是配合make命令使用的特殊文件，make命令则会帮助你自动地、神奇般地管理你的工程。 这里你需要先准备以下文件： main.cpp
hello.cpp factorial.cpp functions.cpp 我建议你新建一个空的目录，然后将上述4个文件放入其中。
注意：我使用g++命令编译。你完全可以换成别的编译器 make工具 如果你运行make 它会去寻找当前目录下名字为makefile的文件，并按里面的内容执行。 如果你有很多makefile文件，那么可以用这个命令来执行： 当然还有其他的参数来使用make工具，详情请man make。 构建过程 1.编译器编译源代码文件，输出到目标文件 2.链接器将目标文件链接，并创建可执行文件 手动编译 手动编译并获得可执行文件，是一种琐碎的方式： 基本的Makefile
基本的makefile文件组成如下： 将此语法应用到我们的例子中，就是: all: g++ main.cpp hello.cpp factorial.cpp -o hello 我们将此文件保存为Makefile-1。要运行此makefile，则输入：make -f Makefile-1 在这个例子中可以看到，我们的target叫做all。这是makefile中的默认target。若无指定参数，make工具将按这个target 执行。 我们同时发现，这个例子中的target，也就是all，没有dependencies（依赖文件），因此make会安全地执行后续的system commands（系统命令）。 最后，make根据我们设定的命令完成了编译。 使用依赖文件 有时候使用多个不同的target会很有用，因为当你只修改了工程中的一个文件时，不必重新编译所有代码，只需要编译修改过的部分。比如：
windows下的makefile教程
windows下的makefile教程 https://www.360docs.net/doc/558323499.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 特殊符号
make工程管理器及其Makefile 及其使用
make工具及其使用 make工程管理器是一种能够自动识别更新了文件代码的工具，同时又不需要重复输入冗长的命令行，当文件较多是比较实用 Autoconf和Automake等是这样的工具可以自动生成Makefile文件 1：Make命令和Makefile 要使用make，必须编写一个叫Makefile的文件，它描述了软件包中各个文件之间的关系，提供了更新每个文件的命令 Make程序利用Makefile的数据和每个文件最近一次更改的时间来确定哪个文件需要更新，对每个更新文件，make程序使用Makefile中定义的命令来更新它，Makefile在文件说明如何编译个源文件并链接生成可执行文件，并要求源文件之间的依赖关系 Makefile文件的格式： 目标：依赖项列表 [命令] 其中，通常目标是要产生的文件的名称，目标可以是可执行文件或OBJ文件，也可以是一个执行的动作名称，比如clean。命令所在的行首要有空格，空格数为一个制表位（Tab），Makefile文件也可以在描述语句行前加“#”表示注释，make程序将跳过此行不执行，相关命令如果过长，还可以使用反斜杠“\”作为后接行符来续行。Make程序执行Makefile的相关行的默认情况是将执行状态显示出来，如果在相关行前加“@”，就可以避免显示该行 Makefile的最大特点是“自动化编译”，只需一个make命令，整个工程完全自动编译，极大的提高了软件开发效率，如果想要删除执行文件和所有的中间目标文件，那么只需要简单地执行一下“make clean”即可，这里要说明的一点是，clean不是一个文件，它只不过是一个动作名词，也可称为标签，其后的冒号什么都没有。这样make就不会自动去查找文件之间的依赖性，因此也就不会自动执行其后所定义的命令 make的命令格式：#make [选项] [宏] [目标] 宏是执行make时使用的宏值 其中选项有： -f 指定Makefile文件名 -p 打印出Makefile中变量数据库和隐含规则 -i 忽略linux命令返回的错误，继续执行下面的命令，如果没有该选项，则遇到linux命令 出错就会停止-s 表示执行不显示执行命令 -r 忽略内部规则 -n 按实际运行时的执行顺序显示命令，包括以“@”开头的命令，但并不真正执行，这个 选项常用来检查Makefile文件的正确性-d Debug模式，输出有关文件和检测时间的详细信息 -t 修改每个目标文件的更新日期，但不重写创建这些文件 -c dir 在读取Makefile之前改变到指定的目录dir -I dir 指定使用的Makefile所在的目录 -w 在处理Makefile之前和之后，都显示工作目录 如果只输入 #make
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文件
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语言
程序员之路——如何学习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 作者：陈皓 整理：祝冬华
第一部分、概述 (6) 第二部分、关于程序的编译和链接 (6) 第三部分、Makefile 介绍 (7) 一、Makefile的规则 (7) 二、一个示例 (8) 三、make是如何工作的 (9) 四、makefile中使用变量 (10) 五、让make自动推导 (11) 六、另类风格的makefile (12) 七、清空目标文件的规则 (13) 第四部分、Makefile 总述 (13) 一、Makefile里有什么？ (13) 1、显式规则。 (14) 2、隐晦规则。 (14) 3、变量的定义。 (14) 4、文件指示。 (14) 5、注释。 (14) 二、Makefile的文件名 (15) 三、引用其它的Makefile (15) 四、环境变量 MAKEFILES (16) 五、make的工作方式 (16) 第五部分、书写规则 (17) 一、规则举例 (17) 二、规则的语法 (17) 三、在规则中使用通配符 (18) 四、文件搜寻 (19) 五、伪目标 (20) 六、多目标 (22) 七、静态模式 (22) 八、自动生成依赖性 (24) 第六部分书写命令 (25) 一、显示命令 (26) 二、命令执行 (26) 三、命令出错 (27) 四、嵌套执行make (28) 五、定义命令包 (30) 第七部分使用变量 (30) 一、变量的基础 (31) 二、变量中的变量 (32) 三、变量高级用法 (34) 四、追加变量值 (37) 五、override 指示符 (37) 六、多行变量 (38)
八、目标变量 (39) 九、模式变量 (40) 第八部分使用条件判断 (40) 一、示例 (40) 二、语法 (42) 第九部分使用函数 (43) 一、函数的调用语法 (44) 二、字符串处理函数 (44) 1、subst (44) 2、patsubst (45) 3、strip (45) 4、findstring (46) 5、filter (46) 6、filter-out (46) 7、sort (47) 8、word (47) 9、wordlist (47) 10、words (47) 11、firstword (48) 12、字符串函数实例 (48) 三、文件名操作函数 (48) 1、dir (48) 2、notdir (48) 3、suffix (49) 4、basename (49) 5、addsuffix (49) 6、addprefix (49) 7、join (50) 四、foreach 函数 (50) 五、if 函数 (50) 六、call函数 (51) 七、origin函数 (51) “undefined” (52) “default” (52) “file” (52) “command line” (52) “override” (52) “automatic” (52) 八、shell函数 (53) 九、控制make的函数 (53) 1、error (53) 2、warning (54) 第十部分 make 的运行 (54)
linux内核编译和生成makefile文件实验报告
操作系统实验报告 姓名：学号： 一、实验题目 1.编译linux内核 2.使用autoconf和automake工具为project工程自动生成Makefile，并测试 3.在内核中添加一个模块 二、实验目的 1.了解一些命令提示符，也里了解一些linux系统的操作。 2.练习使用autoconf和automake工具自动生成Makefile，使同学们了解Makefile的生成原理，熟悉linux编程开发环境 三、实验要求 1使用静态库编译链接swap.c，同时使用动态库编译链接myadd.c。可运行程序生成在src/main目录下。 2要求独立完成，按时提交 四、设计思路和流程图（如：包括主要数据结构及其说明、测试数据的设计及测试结果分析） 1.Makefile的流程图： 2.内核的编译基本操作 1.在ubuntu环境下获取内核源码 2.解压内核源码用命令符：tar xvf linux- 3.18.12.tar.xz 3.配置内核特性：make allnoconfig 4.编译内核：make 5.安装内核：make install
6.测试：cat/boot/grub/grub.conf 7.重启系统：sudo reboot,看是否成功的安装上了内核 8.详情及结构见附录 3.生成makefile文件： 1.用老师给的projec里的main.c函数。 2．需要使用automake和autoconf两个工具，所以用命令符：sudo apt-get install autoconf 进行安装。 3．进入主函数所在目录执行命令：autoscan,这时会在目录下生成两个文件 autoscan.log和configure.scan，将configure.Scan改名为configure.ac，同时用gedit打开，打开后文件修改后的如下： # -*- Autoconf -*- # Process this file with autoconf to produce a configure script. AC_PREREQ([2.69]) AC_INIT([FULL-PACKAGE-NAME], [VERSION], [BUG-REPORT-ADDRESS]) AC_CONFIG_SRCDIR([main.c]) AC_CONFIG_HEADERS([config.h]) AM_INIT_AUTOMAKE(main,1.0) # 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) 4.新建Makefile文件，如下： AUTOMAKE_OPTIONS=foreign bin_PROGRAMS=main first_SOURCES=main.c 5．运行命令aclocal 命令成功之后，在目录下会产生aclocal.m4和autom4te.cache两个文件。 6.运行命令autoheader 命令成功之后，会在目录下产生config.h.in这个新文件。 7.运行命令autoconf 命令成功之后，会在目录下产生configure这个新文件。 8.运行命令automake --add-missing输出结果为： Configure.ac:11:installing./compile’ Configure.ac:8:installing ‘.install-sh’ Configure.ac:8:installing ‘./missing’ Makefile.am:installing ‘./decomp’ 9. 命令成功之后，会在目录下产生depcomp，install-sh和missing这三个新文件和执行下一步的Makefile.in文件。 10.运行命令./configure就可以自动生成Makefile。 4.添加内核模块
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指令将它包含到类声明的后面。这样的文件称为一个内联函数定
实例—使用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命令。