标签：
在正式使用gcc之前，我们先来侃侃gcc是啥玩意儿？
如今的GCC是GNU Compiler Collection的简称。既然是Collection，就是指一些工具链的集合。
最初的GCC（当时还仅仅有C编译器，GCC还是GNU C Comiler的简写）是由Richard Stallman开发的，Stallman也是GNUproject的首创者。那时还是在1984年。
随着程序设计语言的发展，GCC逐渐開始支持C语言之外的语言，如C++、Objective-C、Java、Fortran以及Ada等，具体可訪问GCC主页http://gcc.gnu.org/
GNU工具链包含：
本文主要讨论gcc。gdb和Makefile的使用。
另外，这里指的gcc还包含了用于编译c++的工具。我们实际使用的g++命令其编译过程调用的是与C语言gcc同样的工具。仅仅只是链接过程有所不同。如无特殊说明。gcc命令的使用g++命令上也都适用。
GCC版本号比較多，还有应用在嵌入式ARM、AVR等平台的交叉编译工具，在RHEL/CentOS Linux下，仅仅要使用
yum install gcc
yum install g++
yum install gdb
默认情况下通常是安装好的。
在Window下，可选择的gcc安装方式包含MinGW和Cygwin。本文的操作环境就基于Cygwin，Cygwin是一个Window下模拟Linux环境的开源软件。除了能使用gcc、gdb等工具外，还能使用其他很多Shell命令，操作方式与Linux下的终端无太大差别。本文后面讲述到的全部操作都是基于终端的。
安装好了工具后。使用
gcc --version
gdb --version
可分别查看gcc和gdb的版本号信息，
你可使用以下的，
gcc --help
gdb --help
g++ --help
或以下的命令获得关于gcc以及gdb的帮助信息。
在使用gcc时偶尔会忘掉一两个參数，这几个命令就很实用。
man gcc
man gdb
man g++
假设在你看来，上网不是那么麻烦的话，则http://linux.die.net/man/1/gcc也能够获得gcc的帮助信息。
好吧，我们如今開始第一个样例（我仅仅熟悉C语言。我们这里讨论的样例都是C语言的样例）。
又遇到学习C语言时的第1个样例——Hello, world!，仅仅只是这次我们更应该说Hello, GCC。
我们就将上面的程序存储到main.c的文件里，以下请跟着我敲命令吧，
gcc main.c
ls
在敲ls命令后你看到了什么？main.c文件夹下多了个a.exe的程序（Linux下可执行程序是a.out）。
好吧，既然你是exe格式，执行吧，
./a.out
看到什么，没错：Hello, GCC.
NOTES:
在Linux/Cygwin下运行程序使用"./可运行文件名称"。默认不设置时可运行文件名称为a.out或a.exe。
到此，你就该说。我已经会使用gcc了，然而，事实上你还差远了：
假设你有哪项不知道，不着急，请Go on！
在这之前，你必须了解C代码生成可运行文件的过程。共4步：预处理、编译、汇编、链接。
还是Hello, GCC的样例，请跟着敲命令。
gcc main.c -o main
-o 选项表示生成目标文件名称为main.exe。
gcc -E main.c -o main.i
-E 选项表示预处理操作，预处理就是将宏定义展开，头文件展开。预处理之后的目标文件保存在main.i，这时，你能够查看main.i的预处理结果。
cat _main.c
gcc -S main.c -o main.s
-S 选项表示编译操作，其结果将生成汇编文件（*.s文件，这里使用-o选项定义目标文件为main.s）。
我们也能够查看分析上述Hello代码的汇编代码，
在DSP、ARM等嵌入式平台上。使用gcc编译得到汇编，再依据汇编代码进行优化是一种经常使用的方法。
NOTES:
生成汇编文件（包括汇编代码的文件）的过程是编译。不是汇编，汇编是将汇编代码转换成目标文件*.obj的过程。 从这点上理解，汇编文件生成可运行文件的过程是没有编译操作的。
gcc -c main.c -o main.obj
-c 选项将源文件生成目标文件main.obj，main.obj事实上已经是一种近似可运行文件了，通过链接操作链接对应的库就能够运行了。
第4步的链接直接使用gcc main.c -o main就能够完毕。
从以下的命令你将更加直观的看到：gcc事实上是一套从预处理、编译、汇编到链接工具的集合。
rm main.i main.s main.obj
cpp main.c > main.i
gcc -S main.i
as main.s -o main.o
上面分别使用了cpp预处理、gcc编译、as汇编。链接能够使用ld命令，只是操作复杂些。
因此。gcc仅仅是帮我们将多个复杂的操作放在一个命令中，是我们的软件开发过程变得更加高效自己主动化。
gcc -E -C main.c -o main.i
gcc -M main.c -o main_makerule
cat main_makerule
main.o: main.c /usr/include/stdio.h /usr/include/_ansi.h /usr/include/newlib.h /usr/include/sys/config.h /usr/include/machine/ieeefp.h /usr/include/sys/features.h /usr/include/cygwin/config.h /usr/lib/gcc/i686-pc-cygwin/3.4.4/include/stddef.h /usr/lib/gcc/i686-pc-cygwin/3.4.4/include/stdarg.h /usr/include/sys/reent.h /usr/include/_ansi.h /usr/include/sys/_types.h /usr/include/machine/_types.h /usr/include/machine/_default_types.h /usr/include/sys/lock.h /usr/include/sys/types.h /usr/include/machine/types.h /usr/include/cygwin/types.h /usr/include/sys/sysmacros.h /usr/include/stdint.h /usr/include/endian.h /usr/include/bits/endian.h /usr/include/byteswap.h /usr/include/sys/stdio.h /usr/include/sys/cdefs.h
NOTES:
在大project编译链接过程中，非常多类似于“Undefined ...”的错误都是由-llibrary、-Idir或-Ldir的设置错误造成的。
对照以下使用和不使用-D_DEBUG的执行结果
gcc -D_DEBUG main.c -o main
./main
gcc main.c -o main
./mian
-O3 优化的很多其它.除了打开-O2所做的一切,它还打开了-finline-functions选项.
-g 以操作系统的本地格式(stabs,COFF,XCOFF,或DWARF)产生调试信息. 仅仅有使用了-g才干使用gdb工具进行调试
gcc -g main.c -o main
gdb main
有关gdb的操作有非常多。将专门详述。
好吧，我们写个多文件小程序：Example2。
main.c
add.c
add.h
使用gcc编译多文件的方法是将多个源文件加入到gcc编译选项中，
gcc -D_DEBUG main.c add.c -o main
./main
显演示样例如以下运行结果。
NOTES:
上面未将add.h加入到编译文件里是由于：C语言的编译是以.c文件为单位的，每一个.c文件都会编译相应到一个.s和.obj文件，而.h文件不会。在上面的样例中，我们仅仅要保 证在main.c在编译的时候可以找到add函数，这是通过#include "add.h"实现的。在链接的时候，main.obj会自己主动找到到add.obj中的add符号，这都是链接器的功劳。
库时编译好的目标文件的一个打包。在链接时被载入到程序中。分为共享库和静态库。如之前使用到的printf定义就在库libc中，我们仅仅要包括stdio.h就能使用了（事实上还要在gcc中使用-llibray选项，仅仅只是gcc默认包括了该选项）。
在链接时将用户程序中使用到外部函数机器码复制到程序可运行区。
共享库：在Linux下是.so文件，在Windows下是.dll文件。
在链接时，仅仅在程序可运行区建立一个索引表，而不拷贝机器代码。在程序运行时。才依据索引表载入外部函数的机器码。共享库相对于静态库的长处是降低了可运行程序代码量的大小。同一时候共享库可同一时候被多个运行程序调用，也能降低内存空间。
![][lib]
不管是静态库还是共享库，在gcc选项中都要使用-l和-L分别制定库名和库路径。
仍以上个add程序为例，说说静态库和共享库的创建和使用，先加入sub函数， sub.c
sub.h
main.c
gcc -c add.c sub.c
ar -r libmymath.a add.o sub.o
这样，我们仅仅要将.a文件和.h文件打包，add和sub就能够在随意地方使用了。
NOTES:
请注意上图给出的在编译main.c时怎样链接到静态库的？（-lmymath -static选项）
之前说过，静态库链接的代码量将比共享库链接要大，我们且先看看静态链接后的代码量。稍后做比較 
gcc -shared -fPIC add.c sub.c -o libmymath.so
ln -s libmymath.so libmymath.dll # Windows下才须要
gcc main.c -lmymath -L./ -o main
-shared 表示共享库。-fPIC 表示生成与位置无关的代码。
NOTES:
在Linux下，共享库链接的的可运行程序运行时还是会出现找不到库问题，这时有两种方法：
- 能够把当前路径增加/etc/ld.so.conf中然后执行ldconfig，或者以当前路径为參数执行ldconfig（要有root权限）
- 把当前路径增加环境变量LD_LIBRARY_PATH 中
相同，来看看使用共享库生成的可运行文件大小。
诶，0x9d4，人家静态库总大小才0x990字节。你怎么说静态库要比共享库大呢？
第一。静态库生成代码量比共享库大指的是——代码量，代码存储在text段。明显嘛，共享库代码段大小1712要比静态库的1728小。
第二， 前面说过。共享库在链接成可运行文件的时候不是直接拷贝目标文件机器码，而是生成符号表。对，符号表。从上面的结果来看。符号表应该存储在data段，所以共享库的data段比静态库要大。由于我们这里的add.c和sub.c的代码量生成的机器码都很小，使用共享库生成符号表的方法反而使可运行文件占用的磁盘空间更大了。仅仅是普通情况下。使用共享库的可运行文件占用的磁盘空间将比静态库的小.
之前已经说过，通过-I能够指定头文件路径。-L指定库路径，-l指定库名。从上一节也看到了它们的使用。
那么系统默认的头文件路径和库路径是在哪呢？
cpp -v
能够查看默认的头文件路径.
gcc -v main.c -lmymath -L. -o main
加入-v选项，就能够查看默认的头文件路径.
gcc提供几个默认的环境变量：
file
显示目标文件格式和执行环境的体系结构（ARM还是x86）
nm
列出目标文件的符号表
ldd
列出可执行文件在执行时所须要的共享库
size
列出目标文件里节的名称和大小。
上面已经使用过该工具。
readelf
显示elf目标文件的完整结构，包含elf头中的编码信息，包含size和nm功能。最经常使用的方法是參数是-d和-h參数。
objdump
全部二进制工具之母。最大作用是反汇编.text节中的二进制信息。
最经常使用的格式是objdump -D -S filename，显示反汇编信息。若要反汇编与源代码同一时候显示。则在gcc编译时要使用-g选项。
NOTES: 上面全部的工具都能够通过 [toolname] --help获得相关的參数帮助信息。
gdb是一个调试工具。与gcc一样，gdb可调试包含C、C++、Java、Fortran、汇编等多种语言。
gdb的原始开发人员是Richard M.Stallman也是开源运动中的一位领袖级级人物。
假设你还不知道malloc分配变量与局部变量的差别的话，那你还不够格称为程序猿。由于程序中的定义或不论什么的内存分配都直接和可运行文件在用户进程虚存空间的布局映射有关，
如上图所看到的。包含：
给定一段程序main.c：
#include <stdio.h>
int add(int a, int b)
{
int c = a + b;
return c;
}
int main(void)
{
int i = 0;
int j = 3;
int k = add(i,j);
printf("i=%d, j=%d, k=%d\n", i,j,k);
return 0;
}
使用gcc编译及gdb调试程序的方法例如以下：
Administrator@DADI-20131210YK /cygdrive/e/MyDesigner/Projects/notes/codes/实例学习gcc+gdb+make/gdb
$ gcc -g main.c -o main ### 注：编译时使用-g选项才干生成符号表用于gdb调试
Administrator@DADI-20131210YK /cygdrive/e/MyDesigner/Projects/notes/codes/实例学习gcc+gdb+make/gdb
$ gdb main
GNU gdb (GDB) 7.3.50.20110821-cvs (cygwin-special)
Copyright (C) 2011 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law. Type "show copying"
and "show warranty" for details.
This GDB was configured as "i686-cygwin".
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>...
Reading symbols from /cygdrive/e/MyDesigner/Projects/notes/codes/实例学习gcc+gdb+make/gdb/main...don
e.
(gdb) l main ### 注：list查看程序，l [函数名/行数]
16
17 return c;
18 }
19
20 int main(void)
21 {
22 int i = 0;
23 int j = 3;
24
25 int k = add(i,j);
(gdb) ### 注：Enter按键接上面继续查看程序
26
27 printf("i=%d, j=%d, k=%d\n", i,j,k);
28
29 return 0;
30 }
31
(gdb) b 23 ### 注：在23行加入断点
Breakpoint 1 at 0x4010d5: file main.c, line 23.
(gdb) b add ### 注：在add函数入口加入断点
Breakpoint 2 at 0x401096: file main.c, line 15.
(gdb) b 29 ### 注：在29行加入断点
Breakpoint 3 at 0x401112: file main.c, line 29.
(gdb) info break ### 注：查看已加入的断点信息
Num Type Disp Enb Address What
1 breakpoint keep y 0x004010d5 in main at main.c:23
2 breakpoint keep y 0x00401096 in add at main.c:15
3 breakpoint keep y 0x00401112 in main at main.c:29
(gdb) r ### 注：运行程序
Starting program: /cygdrive/e/MyDesigner/Projects/notes/codes/实例学习gcc+gdb+make/gdb/main
[New Thread 2492.0x36c]
[New Thread 2492.0x1140]
Breakpoint 1, main () at main.c:23
23 int j = 3;
(gdb) p i ### 注：print打印变量i的值
$1 = 0
(gdb) n ### 注：next下一步（把函数当一条语句直接跳过）
25 int k = add(i,j);
(gdb) s ### 注：step下一步（会运行到函数内部）
Breakpoint 2, add (a=0, b=3) at main.c:15
15 int c = a + b;
(gdb) c ### 注：continue从运行到的当前位置继续往下运行，直到遇到下一个断点
Continuing.
i=0, j=3, k=3
Breakpoint 3, main () at main.c:29
29 return 0;
(gdb) finish ### 注：直接运行到当前函数的结尾处，对main函数不起作用
"finish" not meaningful in the outermost frame.
(gdb) c ### 注：continue继续运行
Continuing.
[Inferior 1 (process 2492) exited normally]
(gdb) q ### 注：程序运行结束。quit退出gdb
Administrator@DADI-20131210YK /cygdrive/e/MyDesigner/Projects/notes/codes/实例学习gcc+gdb+make/gdb
$
好了，就这么简单，仅仅要会了以上几个命令，你就能够开开心心的使用gdb了。
gdb还有非常多高级的内容。本文目标为入门。很多其它内请不吝你的手指依次敲击：
>> gdb
>> help
參见參考文献[6]。这是gdb的一份官方手冊。
Make是构建project的工具。Make工具对用户编写的Makefile进行解析，实现仅仅须要一个命令就能够编译、链接整个project。大部分熟悉VC++的人都漠视了Make工具的存在（VC++的Make工具叫nmake）。这就是为什么使用VC++多文件编译链接能一步搞定的原因所在。
我们这里当然不是去讨论VC++的nmake，而要讨论的是GNU Make的Makefile。Makefile文件用于描写叙述整个project的编译、链接的规则。
仍以Example2为例，源码文件夹下新建Makefile文件（对了，文件名称就是“Makefile”。没.txt等不论什么后缀），
vim Makefile
Makefile文件内容为
main:main.o add.o sub.o # 目标:依赖
gcc main.o add.o sub.o -o main # 命令（必需以TAB开头）
main.o:main.c
gcc -c -D_DEBUG main.c -o main.o
add.o:add.c
gcc -c -D_DEBUG add.c -o add.o
sub.o:sub.c
gcc -c -D_DEBUG sub.c -o sub.o
.PHONY:clean
clean:
-rm main *.o
好了。回到命令行。使用make命令看看Makefile的效果：
make
./main
什么，输出了正确的结果。那就对了。以下我们来分析下上面的Makefile。
目标：依赖
命令（以TAB开头）
目标是链接后的可运行文件名称；依赖是project中的用于编译的c文件和用于连接的*.o文件的集合；就用gcc编译的project而言。命令就是gcc命令，能够使用随意的gcc參数。
使用make命令解析Makefile文件，解析的文件名称能够是Makefile或makefile，假设是其他名称。则须要使用make -f [filename]指定文件名称。
强烈建议使用Makefile作为文件名称（符合Linux的哲学——简洁、首字母大写easy突出文件位置）。
Makefile能够有多个目标（main.o add.o sub.o）。但仅仅能有一个终于目标（main）。
Makefile文件里第一条规则中的目标将确定为终于目标。
make命令默认运行终于目标。若仅仅运行Makefile中其他目标，使用make [Target]。如要清除project下的目标文件，使用
make clean
Makefile中将那些没有不论什么依赖仅仅有运行动作的目标称伪目标（clean），使用.PHONY声明。
伪目标不能作为终于目标。
Makefile中使用变量：Makefile中的变量将是按字符串的方式进行替换。以下是一些系统特殊的变量。
$^: 代表全部依赖文件
$@：代表目标
$<：代表依赖文件里的第一个依赖文件
变量能够大大简化Makefile的编写复杂度。使用变量后的Makefile例如以下：
CC=gcc
OBJS=main.o add.o sub.o
CFLAGS=-D_DEBUG
main:$(OBJS)
$(CC) $(CFLAGS) $^ -o $@
main.o:main.c
$(CC) $(CFLAGS) -c $^ -o $@
add.o:add.c
$(CC) $(CFLAGS) -c $^ -o $@
sub.o:sub.c
$(CC) $(CFLAGS) -c $^ -o $@
.PHONY:clean
clean:
-rm main *.o
当中CC、OBJS、CFLAGS都是自己定义的Makefile变量，$^和$@是系统特殊的变量。
CC=gcc
OBJS=main.o add.o sub.o
CFLAGS=-D_DEBUG
main:$(OBJS)
$(CC) $(CFLAGS) $^ -o $@
%.o:%.c
$(CC) $(CFLAGS) -c $^ -o $@
.PHONY:clean
clean:
-rm main *.o
上面的Makefile使用%用来匹配不论什么非空字符串。
在编写大型程序时，经常project中的.c都有与之相应的.h文件，以上两种使用方法在Makfile非经常常使用。
除了模式匹配。Makefile中还能够使用通配符：。 如上面的伪目标中就使用.o就代表全部后缀为.o的文件。
请注意，这能够简化一些Makefile，但假设你不注意，就可能出错，因此不推荐使用。
CC=gcc
OBJS=main.o add.o sub.o
CFLAGS=-D_DEBUG
main:$(OBJS)
$(CC) $^ -o $@
main.o:
add.o:add.h
sub.o:sub.h
.PHONY:clean
clean:
-rm main *.o
有木有，在生成main.o add.o sub.o目标时连命令都省去了。Makefile能自己主动推导使用gcc命令编译，还知道要加-D_DEBUG选项，这么奇妙？这都要归功于CC和CFLAGS变量。你换成别的变量名试试，看看还行不。所以说：Makefile的自己主动推导规则最好慎用，除非你能确保正确。
以下是将模式匹配和自己主动推导规则结合到一起的Makefile文件。
CC=gcc
OBJS=main.o add.o sub.o
CFLAGS=-D_DEBUG
main:$(OBJS)
$(CC) $^ -o $@
%.o:add.h sub.h
.PHONY:clean
clean:
-rm main *.o
知足常乐，不雅太贪了，能简化到这样就OK了。
Makefile中凝视使用#。在命令前加上@能取消回显
多文件夹的Makefile
VPATH = src:../headers # 搜索路径默认包含当前路径
vpath %.h ../headers # 搜索路径默认包含当前路径
上面提到的4点内容将在之后的Makefile实例中看到。
关于Makefile内嵌函数及很多其它内容请參考文献[5].
本小节将给出两个通用的projectMakefile实例，可作为模板直接应用到自己的project中，这些实例都来源于网络，原作者保留版权。
阅读Makefile也是一种享受，就像喝着牛奶读着小说，热情洋溢的Hacker们，研究去吧！
#############################################################
# Generic Makefile for C/C++ Program
#
# License: GPL (General Public License)
# Author: whyglinux <whyglinux AT gmail DOT com>
# Date: 2006/03/04 (version 0.1)
# 2007/03/24 (version 0.2)
# 2007/04/09 (version 0.3)
# 2007/06/26 (version 0.4)
# 2008/04/05 (version 0.5)
#
# Description:
# ------------
# This is an easily customizable makefile template. The purpose is to
# provide an instant building environment for C/C++ programs.
#
# It searches all the C/C++ source files in the specified directories,
# makes dependencies, compiles and links to form an executable.
#
# Besides its default ability to build C/C++ programs which use only
# standard C/C++ libraries, you can customize the Makefile to build
# those using other libraries. Once done, without any changes you can
# then build programs using the same or less libraries, even if source
# files are renamed, added or removed. Therefore, it is particularly
# convenient to use it to build codes for experimental or study use.
#
# GNU make is expected to use the Makefile. Other versions of makes
# may or may not work.
#
# Usage:
# ------
# 1. Copy the Makefile to your program directory.
# 2. Customize in the "Customizable Section" only if necessary:
# * to use non-standard C/C++ libraries, set pre-processor or compiler
# options to <MY_CFLAGS> and linker ones to <MY_LIBS>
# (See Makefile.gtk+-2.0 for an example)
# * to search sources in more directories, set to <SRCDIRS>
# * to specify your favorite program name, set to <PROGRAM>
# 3. Type make to start building your program.
#
# Make Target:
# ------------
# The Makefile provides the following targets to make:
# $ make compile and link
# $ make NODEP=yes compile and link without generating dependencies
# $ make objs compile only (no linking)
# $ make tags create tags for Emacs editor
# $ make ctags create ctags for VI editor
# $ make clean clean objects and the executable file
# $ make distclean clean objects, the executable and dependencies
# $ make help get the usage of the makefile
#
#===========================================================================
## Customizable Section: adapt those variables to suit your program.
##==========================================================================
# The pre-processor and compiler options.
MY_CFLAGS =
# The linker options.
MY_LIBS =
# The pre-processor options used by the cpp (man cpp for more).
CPPFLAGS = -Wall
# The options used in linking as well as in any direct use of ld.
LDFLAGS =
# The directories in which source files reside.
# If not specified, only the current directory will be serached.
SRCDIRS =
# The executable file name.
# If not specified, current directory name or `a.out‘ will be used.
PROGRAM =
## Implicit Section: change the following only when necessary.
##==========================================================================
# The source file types (headers excluded).
# .c indicates C source files, and others C++ ones.
SRCEXTS = .c .C .cc .cpp .CPP .c++ .cxx .cp
# The header file types.
HDREXTS = .h .H .hh .hpp .HPP .h++ .hxx .hp
# The pre-processor and compiler options.
# Users can override those variables from the command line.
CFLAGS = -g -D_DEBUG -O2
CXXFLAGS= -g -O2
# The C program compiler.
CC = gcc
# The C++ program compiler.
CXX = g++
# Un-comment the following line to compile C programs as C++ ones.
#CC = $(CXX)
# The command used to delete file.
RM = rm -f
CTAGS = ctags
CTAGSFLAGS = --c++-kinds=+p --fields=+iaS --extra=+q -R
## Stable Section: usually no need to be changed. But you can add more.
##==========================================================================
SHELL = /bin/sh
EMPTY =
SPACE = $(EMPTY) $(EMPTY)
ifeq ($(PROGRAM),)
CUR_PATH_NAMES = $(subst /,$(SPACE),$(subst $(SPACE),_,$(CURDIR)))
PROGRAM = $(word $(words $(CUR_PATH_NAMES)),$(CUR_PATH_NAMES))
ifeq ($(PROGRAM),)
PROGRAM = a.out
endif
endif
ifeq ($(SRCDIRS),)
SRCDIRS = .
endif
SOURCES = $(foreach d,$(SRCDIRS),$(wildcard $(addprefix $(d)/*,$(SRCEXTS))))
HEADERS = $(foreach d,$(SRCDIRS),$(wildcard $(addprefix $(d)/*,$(HDREXTS))))
SRC_CXX = $(filter-out %.c,$(SOURCES))
OBJS = $(addsuffix .o, $(basename $(SOURCES)))
DEPS = $(OBJS:.o=.d)
## Define some useful variables.
DEP_OPT = $(shell if `$(CC) --version | grep "GCC" >/dev/null`; then echo "-MM -MP"; else echo "-M"; fi )
DEPEND = $(CC) $(DEP_OPT) $(MY_CFLAGS) $(CFLAGS) $(CPPFLAGS)
DEPEND.d = $(subst -g ,,$(DEPEND))
COMPILE.c = $(CC) $(MY_CFLAGS) $(CFLAGS) $(CPPFLAGS) -c
COMPILE.cxx = $(CXX) $(MY_CFLAGS) $(CXXFLAGS) $(CPPFLAGS) -c
LINK.c = $(CC) $(MY_CFLAGS) $(CFLAGS) $(CPPFLAGS) $(LDFLAGS)
LINK.cxx = $(CXX) $(MY_CFLAGS) $(CXXFLAGS) $(CPPFLAGS) $(LDFLAGS)
.PHONY: all objs tags ctags clean distclean help show
# Delete the default suffixes
.SUFFIXES:
all: $(PROGRAM)
# Rules for creating dependency files (.d).
#------------------------------------------
%.d:%.c
@echo -n $(dir $<) > $@
@$(DEPEND.d) $< >> $@
%.d:%.C
@echo -n $(dir $<) > $@
@$(DEPEND.d) $< >> $@
%.d:%.cc
@echo -n $(dir $<) > $@
@$(DEPEND.d) $< >> $@
%.d:%.cpp
@echo -n $(dir $<) > $@
@$(DEPEND.d) $< >> $@
%.d:%.CPP
@echo -n $(dir $<) > $@
@$(DEPEND.d) $< >> $@
%.d:%.c++
@echo -n $(dir $<) > $@
@$(DEPEND.d) $< >> $@
%.d:%.cp
@echo -n $(dir $<) > $@
@$(DEPEND.d) $< >> $@
%.d:%.cxx
@echo -n $(dir $<) > $@
@$(DEPEND.d) $< >> $@
# Rules for generating object files (.o).
#----------------------------------------
objs:$(OBJS)
%.o:%.c
$(COMPILE.c) $< -o $@
%.o:%.C
$(COMPILE.cxx) $< -o $@
%.o:%.cc
$(COMPILE.cxx) $< -o $@
%.o:%.cpp
$(COMPILE.cxx) $< -o $@
%.o:%.CPP
$(COMPILE.cxx) $< -o $@
%.o:%.c++
$(COMPILE.cxx) $< -o $@
%.o:%.cp
$(COMPILE.cxx) $< -o $@
%.o:%.cxx
$(COMPILE.cxx) $< -o $@
# Rules for generating the tags.
#-------------------------------------
ctags: $(HEADERS) $(SOURCES)
$(CTAGS) $(CTAGSFLAGS) $(HEADERS) $(SOURCES)
# Rules for generating the executable.
#-------------------------------------
$(PROGRAM):$(OBJS)
ifeq ($(SRC_CXX),) # C program
$(LINK.c) $(OBJS) $(MY_LIBS) -o $@
@echo Type ./$@ to execute the program.
else # C++ program
$(LINK.cxx) $(OBJS) $(MY_LIBS) -o $@
@echo Type ./$@ to execute the program.
endif
ifndef NODEP
ifneq ($(DEPS),)
sinclude $(DEPS)
endif
endif
clean:
$(RM) $(OBJS) $(PROGRAM) $(PROGRAM).exe
distclean: clean
$(RM) $(DEPS) TAGS
# Show help.
help:
@echo ‘Generic Makefile for C/C++ Programs (gcmakefile) version 0.5‘
@echo ‘Copyright (C) 2007, 2008 whyglinux <whyglinux@hotmail.com>‘
@echo
@echo ‘Usage: make [TARGET]‘
@echo ‘TARGETS:‘
@echo ‘ all (=make) compile and link.‘
@echo ‘ NODEP=yes make without generating dependencies.‘
@echo ‘ objs compile only (no linking).‘
@echo ‘ tags create tags for Emacs editor.‘
@echo ‘ ctags create ctags for VI editor.‘
@echo ‘ clean clean objects and the executable file.‘
@echo ‘ distclean clean objects, the executable and dependencies.‘
@echo ‘ show show variables (for debug use only).‘
@echo ‘ help print this message.‘
@echo
@echo ‘Report bugs to <whyglinux AT gmail DOT com>.‘
# Show variables (for debug use only.)
show:
@echo ‘PROGRAM :‘ $(PROGRAM)
@echo ‘SRCDIRS :‘ $(SRCDIRS)
@echo ‘HEADERS :‘ $(HEADERS)
@echo ‘SOURCES :‘ $(SOURCES)
@echo ‘SRC_CXX :‘ $(SRC_CXX)
@echo ‘OBJS :‘ $(OBJS)
@echo ‘DEPS :‘ $(DEPS)
@echo ‘DEPEND :‘ $(DEPEND)
@echo ‘COMPILE.c :‘ $(COMPILE.c)
@echo ‘COMPILE.cxx :‘ $(COMPILE.cxx)
@echo ‘link.c :‘ $(LINK.c)
@echo ‘link.cxx :‘ $(LINK.cxx)
## End of the Makefile ## Suggestions are welcome ## All rights reserved ##
##############################################################
我是从这里找到第一个模板的：http://www.iteye.com/topic/774919。使用本文的的Example2測试。
project文件的组织方式为：
该部分内容来自于CSDN的一篇博文：项目有用makefile（http://blog.csdn.net/zhouyulu/article/details/8449263）。
你可參考该博文，或下载源代码研究下，非常有帮助。
作者使用文件名称为make.global的Makefile进行全局编译的一些规则设定，内容例如以下：
# compile macro
CC = g++
CFLAGS = -O2 -Wall
LDFLAGS = -lm
INCLUDES= -I/usr/local/include
# recursive make
.PHONY: subdirs ${SUBDIRS} cleansubdirs
subdirs: ${SUBDIRS}
${SUBDIRS}:
${MAKE} -C $@ all
# recursive make clean
cleansubdirs:
@for dir in ${SUBDIRS}; do ${MAKE} -C $$dir clean; done
# dependence
%.o: %.cpp
${CC} ${CFLAGS} ${INCLUDES} -c $< -o $@
%.o: %.cc
${CC} ${CFLAGS} ${INCLUDES} -c $< -o $@
项目根节点的Makefile使用export和include命令将上面的make.global中的变量信息导出，详细例如以下：
# target, subdir, objects in current dir
TARGET = test
SUBDIRS = src
OBJECTS =
all:subdirs ${OBJECTS}
${CC} -o ${TARGET} $$(find ./${SUBDIRS} -name ‘*.o‘) ${LDFLAGS} ${INCLUDES}
clean:cleansubdirs
rm -f ${TARGET} ${OBJECTS}
# path of "make global scripts"
# NOTE, use absolute path. export once, use in all subdirs
export PROJECTPATH=${PWD}
export MAKEINCLUDE=${PROJECTPATH}/makeconfig/make.global
# include "make global scripts"
include ${MAKEINCLUDE}
其他文件夹下的Makefile比較具有一致性，如src文件夹下Makefile：
# subdir and objects in current dir
SUBDIRS = module-a module-b
OBJECTS = main.o
all:subdirs ${OBJECTS}
clean:cleansubdirs
rm -f ${OBJECTS}
include ${MAKEINCLUDE}
叶子节点的文件夹下，如：
src/module-a
# subdir and objects in current dir
SUBDIRS =
OBJECTS = test.o
all:subdirs ${OBJECTS}
clean:cleansubdirs
rm -f ${OBJECTS}
include ${MAKEINCLUDE}
src/module-b
# subdir and objects in current dir
SUBDIRS =
OBJECTS = test.o
all:subdirs ${OBJECTS}
clean:cleansubdirs
rm -f ${OBJECTS}
include ${MAKEINCLUDE}
因此。仅仅要在项目根文件夹使用一个make命令就能自己主动递归的调用其他文件夹下的Makefile对整个project进行编译，尤其适合多人合作的项目中。
我把作者的这部分代码放在了Example3实例中。
版权声明：本文博客原创文章，博客，未经同意，不得转载。
标签：
原文地址：http://www.cnblogs.com/mengfanrong/p/4678059.html
