一个C/C++通用的Makefile模板

本文推荐了一个用于对 C/C++ 程序进行编译和连接以产生可执行程序的通用 Makefile。

在使用 Makefile 之前,只需对它进行一些简单的设置即可;而且一经设置,即使以后对源程序文件有所增减一般也不再需要改动 Makefile。因此,即便是一个没有学习过 Makefile 书写规则的人,也可以为自己的 C/C++ 程序快速建立一个可工作的 Makefile。

这个 Makefile 可以在 GNU Make 和 GCC 编译器下正常工作。但是不能保证对于其它版本的 Make 和编译器也能正常工作。

此 Makefile 的使用方法如下:

程序目录的组织
  尽量将自己的源程序集中在一个目录中,并且把 Makefile 和源程序放在一起,这样用起来比较方便。当然,也可以将源程序分类存放在不同的目录中。
  在程序目录中创建一个名为 Makefile 的文本文件,将后面列出的 Makefile 的内容复制到这个文件中。(注意:在复制的过程中,Makfile 中各命令前面的 Tab 字符有可能被转换成若干个空格。这种情况下需要把 Makefile 命令前面的这些空格替换为一个 Tab。)
  将当前工作目录切换到 Makefile 所在的目录。目前,这个 Makefile 只支持在当前目录中的调用,不支持当前目录和 Makefile 所在的路径不是同一目录的情况。

指定可执行文件
  程序编译和连接成功后产生的可执行文件在 Makefile 中的 PROGRAM 变量中设定。这一项不能为空。为自己程序的可执行文件起一个有意义的名字吧。

指定源程序
  要编译的源程序由其所在的路径和文件的扩展名两项来确定。由于头文件是通过包含来使用的,所以在这里说的源程序不应包含头文件
  源程序所在的路径在 SRCDIRS 中设定。如果源程序分布在不同的目录中,那么需要在 SRCDIRS 中一一指定,并且路径名之间用空格分隔
  在 SRCEXTS 中指定程序中使用的文件类型。C/C++ 程序的扩展名一般有比较固定的几种形式:.c、.C、.cc、.cpp、.CPP、.c++、.cp、或者.cxx(参见 man gcc)。扩展名决定了程序是 C 还是 C++ 程序:.c 是 C 程序,其它扩展名表示 C++ 程序。一般固定使用其中的一种扩展名即可。但是也有可能需要使用多种扩展名,这可以在 SOURCE_EXT 中一一指定,各个扩展名之间用空格分隔。
  虽然并不常用,但是 C 程序也可以被作为 C++ 程序编译。这可以通过在 Makefile 中设置 CC = $(CXX) 和 CFLAGS = $(CXXFLAGS) 两项即可实现。
  这个 Makefile 支持 C、C++ 以及 C/C++ 混合三种编译方式:

  如果只指定 .c 扩展名,那么这是一个 C 程序,用 $(CC) 表示的编译命令进行编译和连接。

  如果指定的是除 .c 之外的其它扩展名(如 .cc、.cpp、.cxx 等),那么这是一个 C++ 程序,用 $(CXX) 进行编译和连接。
  如果既指定了 .c,又指定了其它 C++ 扩展名,那么这是 C/C++ 混合程序,将用 $(CC) 编译其中的 C 程序,用 $(CXX) 编译其中的 C++ 程序,最后再用 $(CXX) 连接程序。
  这些工作都是 make 根据在 Makefile 中提供的程序文件类型(扩展名)自动判断进行的,不需要用户干预。

指定编译选项
  编译选项由三部分组成:预处理选项、编译选项以及连接选项,分别由 CPPFLAGS、CFLAGS与CXXFLAGS、LDFLAGS 指定。
  CPPFLAGS 选项可参考 C 预处理命令 cpp 的说明,但是注意不能包含 -M 以及和 -M 有关的选项。如果是 C/C++ 混合编程,也可以在这里设置 C/C++ 的一些共同的编译选项。
  CFLAGS 和 CXXFLAGS 两个变量通常用来指定编译选项。前者仅仅用于指定 C 程序的编译选项,后者仅仅用于指定 C++ 程序的编译选项。其实也可以在两个变量中指定一些预处理选项(即一些本来应该放在 CPPFLAGS 中的选项),和 CPPFLAGS 并没有明确的界限。
  连接选项在 LDFLAGS 中指定。如果只使用 C/C++ 标准库,一般没有必要设置。如果使用了非标准库,应该在这里指定连接需要的选项,如库所在的路径、库名以及其它联接选项。
  现在的库一般都提供了一个相应的 .pc 文件来记录使用库所需要的预编译选项、编译选项和连接选项等信息,通过 pkg-config 可以动态提取这些选项。与由用户显式指定各个选项相比,使用 pkg-config 来访问库提供的选项更方便、更具通用性。在后面可以看到一个 GTK+ 程序的例子,其编译和连接选项的指定就是用 pkg-config 实现的。

编译和连接

  上面的各项设置好之后保存 Makefile 文件。执行 make 命令,程序就开始编译了。
  命令 make 会根据 Makefile 中设置好的路径和文件类型搜索源程序文件,然后根据文件的类型调用相应的编译命令、使用相应的编译选项对程序进行编译。
  编译成功之后程序的连接会自动进行。如果没有错误的话最终会产生程序的可执行文件。
  注意:在对程序编译之后,会产生和源程序文件一一对应的 .d 文件。这是表示依赖关系的文件,通过它们 make 决定在源程序文件变动之后要进行哪些更新。为每一个源程序文件建立相应的 .d 文件这也是 GNU Make 推荐的方式。

Makefile 目标(Targets)

下面是关于这个 Makefile 提供的目标以及它所完成的功能:

make
编译和连接程序。相当于 make all。

make objs
仅仅编译程序产生 .o 目标文件,不进行连接(一般很少单独使用)。

make clean
删除编译产生的目标文件和依赖文件。

make cleanall
删除目标文件、依赖文件以及可执行文件。

make rebuild
重新编译和连接程序。相当于 make clean && make all。

关于这个 Makefile 的实现原理不准备详细解释了。如果有兴趣的话,可参考文末列出的“参考资料”。

Makefile 的内容如下:

  1. #############################################################
  2. # Generic Makefile for C/C++ Program
  3. #
  4. # License: GPL (General Public License)
  5. # Author: whyglinux <whyglinux AT gmail DOT com>
  6. # Date: 2006/03/04 (version 0.1)
  7. # 2007/03/24 (version 0.2)
  8. # 2007/04/09 (version 0.3)
  9. # 2007/06/26 (version 0.4)
  10. # 2008/04/05 (version 0.5)
  11. #
  12. # Description:
  13. # ------------
  14. # This is an easily customizable makefile template. The purpose is to
  15. # provide an instant building environment for C/C++ programs.
  16. #
  17. # It searches all the C/C++ source files in the specified directories,
  18. # makes dependencies, compiles and links to form an executable.
  19. #
  20. # Besides its default ability to build C/C++ programs which use only
  21. # standard C/C++ libraries, you can customize the Makefile to build
  22. # those using other libraries. Once done, without any changes you can
  23. # then build programs using the same or less libraries, even if source
  24. # files are renamed, added or removed. Therefore, it is particularly
  25. # convenient to use it to build codes for experimental or study use.
  26. #
  27. # GNU make is expected to use the Makefile. Other versions of makes
  28. # may or may not work.
  29. #
  30. # Usage:
  31. # ------
  32. # 1. Copy the Makefile to your program directory.
  33. # 2. Customize in the "Customizable Section" only if necessary:
  34. # * to use non-standard C/C++ libraries, set pre-processor or compiler
  35. # options to <MY_CFLAGS> and linker ones to <MY_LIBS>
  36. # (See Makefile.gtk+-2.0 for an example)
  37. # * to search sources in more directories, set to <SRCDIRS>
  38. # * to specify your favorite program name, set to <PROGRAM>
  39. # 3. Type make to start building your program.
  40. #
  41. # Make Target:
  42. # ------------
  43. # The Makefile provides the following targets to make:
  44. # $ make compile and link
  45. # $ make NODEP=yes compile and link without generating dependencies
  46. # $ make objs compile only (no linking)
  47. # $ make tags create tags for Emacs editor
  48. # $ make ctags create ctags for VI editor
  49. # $ make clean clean objects and the executable file
  50. # $ make distclean clean objects, the executable and dependencies
  51. # $ make help get the usage of the makefile
  52. #
  53. #===========================================================================

  54. ## Customizable Section: adapt those variables to suit your program.
  55. ##==========================================================================

  56. # The pre-processor and compiler options.
  57. MY_CFLAGS =

  58. # The linker options.
  59. MY_LIBS =

  60. # The pre-processor options used by the cpp (man cpp for more).
  61. CPPFLAGS = -Wall

  62. # The options used in linking as well as in any direct use of ld.
  63. LDFLAGS =

  64. # The directories in which source files reside.
  65. # If not specified, only the current directory will be serached.
  66. SRCDIRS =

  67. # The executable file name.
  68. # If not specified, current directory name or `a.out' will be used.
  69. PROGRAM =

  70. ## Implicit Section: change the following only when necessary.
  71. ##==========================================================================

  72. # The source file types (headers excluded).
  73. # .c indicates C source files, and others C++ ones.
  74. SRCEXTS = .c .C .cc .cpp .CPP .c++ .cxx .cp

  75. # The header file types.
  76. HDREXTS = .h .H .hh .hpp .HPP .h++ .hxx .hp

  77. # The pre-processor and compiler options.
  78. # Users can override those variables from the command line.
  79. CFLAGS = -g -O2
  80. CXXFLAGS= -g -O2

  81. # The C program compiler.
  82. #CC = gcc

  83. # The C++ program compiler.
  84. #CXX = g++

  85. # Un-comment the following line to compile C programs as C++ ones.
  86. #CC = $(CXX)

  87. # The command used to delete file.
  88. #RM = rm -f

  89. ETAGS = etags
  90. ETAGSFLAGS =

  91. CTAGS = ctags
  92. CTAGSFLAGS =

  93. ## Stable Section: usually no need to be changed. But you can add more.
  94. ##==========================================================================
  95. SHELL = /bin/sh
  96. EMPTY =
  97. SPACE = $(EMPTY) $(EMPTY)
  98. ifeq ($(PROGRAM),)
  99. CUR_PATH_NAMES = $(subst /,$(SPACE),$(subst $(SPACE),_,$(CURDIR)))
  100. PROGRAM = $(word $(words $(CUR_PATH_NAMES)),$(CUR_PATH_NAMES))
  101. ifeq ($(PROGRAM),)
  102. PROGRAM = a.out
  103. endif
  104. endif
  105. ifeq ($(SRCDIRS),)
  106. SRCDIRS = .
  107. endif
  108. SOURCES = $(foreach d,$(SRCDIRS),$(wildcard $(addprefix $(d)/*,$(SRCEXTS))))
  109. HEADERS = $(foreach d,$(SRCDIRS),$(wildcard $(addprefix $(d)/*,$(HDREXTS))))
  110. SRC_CXX = $(filter-out %.c,$(SOURCES))
  111. OBJS = $(addsuffix .o, $(basename $(SOURCES)))
  112. DEPS = $(OBJS:.o=.d)

  113. ## Define some useful variables.
  114. DEP_OPT = $(shell if `$(CC) --version | grep "GCC" >/dev/null`; then \
  115. echo "-MM -MP"; else echo "-M"; fi )
  116. DEPEND = $(CC) $(DEP_OPT) $(MY_CFLAGS) $(CFLAGS) $(CPPFLAGS)
  117. DEPEND.d = $(subst -g ,,$(DEPEND))
  118. COMPILE.c = $(CC) $(MY_CFLAGS) $(CFLAGS) $(CPPFLAGS) -c
  119. COMPILE.cxx = $(CXX) $(MY_CFLAGS) $(CXXFLAGS) $(CPPFLAGS) -c
  120. LINK.c = $(CC) $(MY_CFLAGS) $(CFLAGS) $(CPPFLAGS) $(LDFLAGS)
  121. LINK.cxx = $(CXX) $(MY_CFLAGS) $(CXXFLAGS) $(CPPFLAGS) $(LDFLAGS)

  122. .PHONY: all objs tags ctags clean distclean help show

  123. # Delete the default suffixes
  124. .SUFFIXES:

  125. all: $(PROGRAM)

  126. # Rules for creating dependency files (.d).
  127. #------------------------------------------

  128. %.d:%.c
  129. @echo -n $(dir $<) > $@
  130. @$(DEPEND.d) $< >> $@

  131. %.d:%.C
  132. @echo -n $(dir $<) > $@
  133. @$(DEPEND.d) $< >> $@

  134. %.d:%.cc
  135. @echo -n $(dir $<) > $@
  136. @$(DEPEND.d) $< >> $@

  137. %.d:%.cpp
  138. @echo -n $(dir $<) > $@
  139. @$(DEPEND.d) $< >> $@

  140. %.d:%.CPP
  141. @echo -n $(dir $<) > $@
  142. @$(DEPEND.d) $< >> $@

  143. %.d:%.c++
  144. @echo -n $(dir $<) > $@
  145. @$(DEPEND.d) $< >> $@

  146. %.d:%.cp
  147. @echo -n $(dir $<) > $@
  148. @$(DEPEND.d) $< >> $@

  149. %.d:%.cxx
  150. @echo -n $(dir $<) > $@
  151. @$(DEPEND.d) $< >> $@

  152. # Rules for generating object files (.o).
  153. #----------------------------------------
  154. objs:$(OBJS)

  155. %.o:%.c
  156. $(COMPILE.c) $< -o $@

  157. %.o:%.C
  158. $(COMPILE.cxx) $< -o $@

  159. %.o:%.cc
  160. $(COMPILE.cxx) $< -o $@

  161. %.o:%.cpp
  162. $(COMPILE.cxx) $< -o $@

  163. %.o:%.CPP
  164. $(COMPILE.cxx) $< -o $@

  165. %.o:%.c++
  166. $(COMPILE.cxx) $< -o $@

  167. %.o:%.cp
  168. $(COMPILE.cxx) $< -o $@

  169. %.o:%.cxx
  170. $(COMPILE.cxx) $< -o $@

  171. # Rules for generating the tags.
  172. #-------------------------------------
  173. tags: $(HEADERS) $(SOURCES)
  174. $(ETAGS) $(ETAGSFLAGS) $(HEADERS) $(SOURCES)

  175. ctags: $(HEADERS) $(SOURCES)
  176. $(CTAGS) $(CTAGSFLAGS) $(HEADERS) $(SOURCES)

  177. # Rules for generating the executable.
  178. #-------------------------------------
  179. $(PROGRAM):$(OBJS)
  180. ifeq ($(SRC_CXX),) # C program
  181. $(LINK.c) $(OBJS) $(MY_LIBS) -o $@
  182. @echo Type ./$@ to execute the program.
  183. else # C++ program
  184. $(LINK.cxx) $(OBJS) $(MY_LIBS) -o $@
  185. @echo Type ./$@ to execute the program.
  186. endif

  187. ifndef NODEP
  188. ifneq ($(DEPS),)
  189. sinclude $(DEPS)
  190. endif
  191. endif

  192. clean:
  193. $(RM) $(OBJS) $(PROGRAM) $(PROGRAM).exe

  194. distclean: clean
  195. $(RM) $(DEPS) TAGS

  196. # Show help.
  197. help:
  198. @echo 'Generic Makefile for C/C++ Programs (gcmakefile) version 0.5'
  199. @echo 'Copyright (C) 2007, 2008 whyglinux <[email protected]>'
  200. @echo
  201. @echo 'Usage: make [TARGET]'
  202. @echo 'TARGETS:'
  203. @echo ' all (=make) compile and link.'
  204. @echo ' NODEP=yes make without generating dependencies.'
  205. @echo ' objs compile only (no linking).'
  206. @echo ' tags create tags for Emacs editor.'
  207. @echo ' ctags create ctags for VI editor.'
  208. @echo ' clean clean objects and the executable file.'
  209. @echo ' distclean clean objects, the executable and dependencies.'
  210. @echo ' show display variables (for debug use only).'
  211. @echo ' help print this message.'
  212. @echo
  213. @echo 'Report bugs to <whyglinux AT gmail DOT com>.'

  214. # Show variables (for debug use only.)
  215. show:
  216. @echo 'PROGRAM :' $(PROGRAM)
  217. @echo 'SRCDIRS :' $(SRCDIRS)
  218. @echo 'HEADERS :' $(HEADERS)
  219. @echo 'SOURCES :' $(SOURCES)
  220. @echo 'SRC_CXX :' $(SRC_CXX)
  221. @echo 'OBJS :' $(OBJS)
  222. @echo 'DEPS :' $(DEPS)
  223. @echo 'DEPEND :' $(DEPEND)
  224. @echo 'COMPILE.c :' $(COMPILE.c)
  225. @echo 'COMPILE.cxx :' $(COMPILE.cxx)
  226. @echo 'link.c :' $(LINK.c)
  227. @echo 'link.cxx :' $(LINK.cxx)

  228. ## End of the Makefile ## Suggestions are welcome ## All rights reserved ##
  229. ##############################################################

 

下面提供两个例子来具体说明上面 Makefile 的用法。
例一 Hello World 程序

这个程序的功能是输出 Hello, world! 这样一行文字。由 hello.h、hello.c、main.cxx 三个文件组成。前两个文件是 C 程序,后一个是 C++ 程序,因此这是一个 C 和 C++ 混编程序。

  1. /* File name: hello.h
  2. * C header file
  3. */

  4. #ifndef HELLO_H
  5. #define HELLO_H

  6. #ifdef __cplusplus
  7. extern "C" {
  8. #endif

  9. void print_hello();
  10. #ifdef __cplusplus
  11. }

  12. #endif
  13. #endif


  14. /* File name: hello.c
  15. * C source file.
  16. */

  17. #include "hello.h"
  18. #include <stdio.h>

  19. void print_hello()
  20. {
  21. puts( "Hello, world!" );
  22. }


  23. /* File name: main.cxx
  24. * C++ source file.
  25. */

  26. #include "hello.h"

  27. int main()
  28. {
  29. print_hello();
  30. return 0;
  31. }

建立一个新的目录,然后把这三个文件拷贝到目录中,也把 Makefile 文件拷贝到目录中。之后,对 Makefile 的相关项目进行如下设置:

PROGRAM := hello # 设置运行程序名

SRCDIRS := . # 源程序位于当前目录下

SRCEXTS := .c .cxx # 源程序文件有 .c 和 .cxx 两种类型

CFLAGS := -g # 为 C 目标程序包含 GDB 可用的调试信息

CXXFLAGS := -g # 为 C++ 目标程序包含 GDB 可用的调试信息 

  由于这个简单的程序只使用了 C 标准库的函数(puts),所以对于 CFLAGS 和 CXXFLAGS 没有过多的要求,LDFLAGS 和 CPPFLAGS 选项也无需设置。

  经过上面的设置之后,执行 make 命令就可以编译程序了。如果没有错误出现的话,./hello 就可以运行程序了。

  如果修改了源程序的话,可以看到只有和修改有关的源文件被编译。也可以再为程序添加新的源文件,只要它们的扩展名是已经在 Makefile 中设置过的,那么就没有必要修改 Makefile。

例二 GTK+ 版 Hello World 程序

  这个 GTK+ 2.0 版的 Hello World 程序可以从下面的网址上得到:http://www.gtk.org/tutorial/c58.html#SEC-HELLOWORLD。当然,要编译 GTK+ 程序,还需要你的系统上已经安装好了 GTK+。
  跟第一个例子一样,单独创建一个新的目录,把上面网页中提供的程序保存为 main.c 文件。对 Makefile 做如下设置:
PROGRAM := hello # 设置运行程序名
SRCDIRS := . # 源程序位于当前目录下
SRCEXTS := .c # 源程序文件只有 .c 一种类

CFLAGS := `pkg-config --cflags gtk+-2.0` # CFLAGS
LDFLAGS := `pkg-config --libs gtk+-2.0` # LDFLAGS

这是一个 C 程序,所以 CXXFLAGS 没有必要设置——即使被设置了也不会被使用。
编译和连接 GTK+ 库所需要的 CFLAGS 和 LDFLAGS 由 pkg-config 程序自动产生。
现在就可以运行 make 命令编译、./hello 执行这个 GTK+ 程序了。

================================================================================

 如何为多目录源文件建立makefile

转载自:http://blog.sina.com.cn/s/blog_4fcd1ea30100uo2k.html

举例说明:

1、代码源文件目录关系如下
manyFiletest/
Complex/
Complex.h
Complex.m
Fraction/
Fraction.h
Fraction.m
Main.m

2、实践环境:GNUStep工具;代码语言:Objective-C

3、在manyFiletest建立manyfile.makefile
内如如下:
CC = gcc
CFLAGS = -g
LIBS = -lobjc -lgnustep-base
SRC=Complex/Complex.m Complex/Complex.h Fraction/Fraction.m Fraction/Fraction.h Main.m
OBJ=Complex/Complex.o Fraction/Fraction.o Main.o
HeaderPath=-I/GNUstep/System/Library/Headers
LibraryPath=-L/GNUstep/System/Library/Libraries
Constant=-fconstant-string-class=NSConstantString

ComplexMain:$(OBJ)
$(CC) -o ComplexMain $(OBJ) $(HeaderPath) $(Constant) $(LibraryPath) $(LIBS)
Complex/Complex.o:Complex/Complex.m Complex/Complex.h
$(CC) -o Complex/Complex.o -c Complex/Complex.m $(HeaderPath) $(Constant) $(LibraryPath) $(LIBS)
Fraction/Fraction.o:Fraction/Fraction.m Fraction/Fraction.h
$(CC) -o Fraction/Fraction.o -c Fraction/Fraction.m $(HeaderPath) $(Constant) $(LibraryPath) $(LIBS)
Main.o:main.m Fraction/Fraction.h Complex/Complex.h
$(CC) -c main.m $(HeaderPath) $(Constant) $(LibraryPath) $(LIBS)

clean:
rm ComplexMain $(OBJ)

make -f manyfile.makefile
实践结果如下图目录文件:
manyFiletest/
Complex/
Complex.h
Complex.m
Complex.o 生成
Fraction/
Fraction.h
Fraction.m
Fraction.o 生成
Main.m
Main.o 生成
ComplexMain.exe 生成
manyfile.makefile

也就是说目标文件创建在各自的目录下的

注意,在此makefile中
Complex/Complex.o:Complex/Complex.m Complex/Complex.h
$(CC) -o Complex/Complex.o -c Complex/Complex.m $(HeaderPath) $(Constant) $(LibraryPath) $(LIBS)

如果要把目标文件创建在各自目下,需要-o Complex/Complex.o,且Complex/Complex.o:不能写成Complex.o:

4、为了简化manyfile.makefile,可以如下编写,新建manyfile01.makefile
CC = gcc
CFLAGS = -g
LIBS = -lobjc -lgnustep-base
HeaderPath=-I/GNUstep/System/Library/Headers
LibraryPath=-L/GNUstep/System/Library/Libraries
Constant=-fconstant-string-class=NSConstantString

P1=Complex/
P2=Fraction/

SRC=$(P1)Complex.m $(P1)Complex.h $(P2)Fraction.m $(P2)Fraction.h Main.m
OBJ=$(P1)Complex.o $(P2)Fraction.o Main.o

ComplexMain:$(OBJ)
$(CC) -o ComplexMain $(OBJ) $(HeaderPath) $(Constant) $(LibraryPath) $(LIBS)
$(P1)Complex.o:$(P1)Complex.m $(P1)Complex.h
$(CC) -o $(P1)Complex.o -c $(P1)Complex.m $(HeaderPath) $(Constant) $(LibraryPath) $(LIBS)
$(P2)Fraction.o:$(P2)Fraction.m $(P2)Fraction.h
$(CC) -o $(P2)Fraction.o -c $(P2)Fraction.m $(HeaderPath) $(Constant) $(LibraryPath) $(LIBS)
Main.o:main.m $(P2)Fraction.h $(P1)Complex.h
$(CC) -c main.m $(HeaderPath) $(Constant) $(LibraryPath) $(LIBS)

clean:
rm ComplexMain $(OBJ)

你可发现
P1=Complex/
P2=Fraction/

替换了对应的目录

使用make -f manyfile01.makefile也是成功的,目录效果同manyfile.makefile

5、继续实践
把所有目标文件建立在同一目录下
manyfile02.makefile
内容如下:
CC = gcc
CFLAGS = -g
LIBS = -lobjc -lgnustep-base
SRC=Complex/Complex.m Complex/Complex.h Fraction/Fraction.m Fraction/Fraction.h Main.m
OBJ=Complex.o Fraction.o Main.o
HeaderPath=-I/GNUstep/System/Library/Headers
LibraryPath=-L/GNUstep/System/Library/Libraries
Constant=-fconstant-string-class=NSConstantString

ComplexMain:$(OBJ)
$(CC) -o ComplexMain $(OBJ) $(HeaderPath) $(Constant) $(LibraryPath) $(LIBS)
Complex.o:Complex/Complex.m Complex/Complex.h
$(CC) -c Complex/Complex.m $(HeaderPath) $(Constant) $(LibraryPath) $(LIBS)
Fraction.o:Fraction/Fraction.m Fraction/Fraction.h
$(CC) -c Fraction/Fraction.m $(HeaderPath) $(Constant) $(LibraryPath) $(LIBS)
Main.o:main.m Fraction/Fraction.h Complex/Complex.h
$(CC) -c main.m $(HeaderPath) $(Constant) $(LibraryPath) $(LIBS)

clean:
rm ComplexMain $(OBJ)

make -f manyfile02.makefile
实践结果如下图目录文件:
manyFiletest/
Complex/
Complex.h
Complex.m
Fraction/
Fraction.h
Fraction.m
Main.m
Main.o 生成
ComplexMain.exe 生成
Fraction.o 生成
Complex.o 生成
manyfile.makefile
manyfile01.makefile
manyfile02.makefile

6、为了让gcc输出到特定的目录上
manyfile03.makefile
内容如下:
CC = gcc
CFLAGS = -g
LIBS = -lobjc -lgnustep-base
HeaderPath=-I/GNUstep/System/Library/Headers
LibraryPath=-L/GNUstep/System/Library/Libraries
Constant=-fconstant-string-class=NSConstantString

P1=Complex/
P2=Fraction/

ComplieOut=Out/

SRC=$(P1)Complex.m $(P1)Complex.h $(P2)Fraction.m $(P2)Fraction.h Main.m
OBJ=$(ComplieOut)Complex.o $(ComplieOut)Fraction.o $(ComplieOut)Main.o

$(ComplieOut)ComplexMain:$(OBJ)
$(CC) -o $(ComplieOut)ComplexMain $(OBJ) $(HeaderPath) $(Constant) $(LibraryPath) $(LIBS)
$(ComplieOut)Complex.o:$(P1)Complex.m $(P1)Complex.h
$(CC) -o $(ComplieOut)Complex.o -c $(P1)Complex.m $(HeaderPath) $(Constant) $(LibraryPath) $(LIBS)
$(ComplieOut)Fraction.o:$(P2)Fraction.m $(P2)Fraction.h
$(CC) -o $(ComplieOut)Fraction.o -c $(P2)Fraction.m $(HeaderPath) $(Constant) $(LibraryPath) $(LIBS)
$(ComplieOut)Main.o:main.m $(P2)Fraction.h $(P1)Complex.h
$(CC) -o $(ComplieOut)Main.o -c main.m $(HeaderPath) $(Constant) $(LibraryPath) $(LIBS)

clean:
rm ComplexMain $(OBJ)

首先要先建立输出目录,与makefile同目录下

编译效果目录关系效果如下:
manyFiletest/
Complex/
Complex.h
Complex.m
Fraction/
Fraction.h
Fraction.m
Main.m
manyfile.makefile
manyfile01.makefile
manyfile02.makefile
manyfile03.makefile
Out/
Main.o 生成
ComplexMain.exe 生成
Fraction.o 生成
Complex.o 生成

个人建议采用最后manyfile03.makefile来为多文件编译建立makefile

最后,说明一下:
简单的可以手工编写makefile,一般都是使用工具来处理,这里仅仅学习或应用在较少的文件处理

关于工具AutoTools的实践用法看看这个例子http://blogold.chinaunix.net/u/21948/showart_175235.html

另外网友说 可以使用vpath来处理目录查询(如在使用模式规则时,先于变量vpath中指定各种类型文件的路径),我没有实践。
我看了
vpath %c func1:func1/func2:func1/func2/func3
意思是:把这3个目录下.c文件通配查询。

=====================================
SHELL = /bin/sh

CC = gcc
FLAG = -Wall
LDFLAGS = -Wl,-soname,-O2

AR = ar -cr
RM = rm -rf

INC =# -I.
SRC = soa.c
OBJS = soa.o
LIBA = libsoa.a
LIBSO = libsoa.so

all:soa
soa:$(OBJS)
#    $(CC) $(INC) -shared -o $(OBJS) $(SRC)
    $(AR) $(LIBA) $(OBJS)
#    $(RM) $(OBJS)
    $(CC) $(INC) -shared -fpic -o $(LIBSO) $(SRC)
.c.o:
    $(CC) $(INC) -c $<

.PHONY:clean
clean:
    $(RM) *.o

============
SHELL = /bin/sh

CXX = g++
CXXFLAGS = -c -g -o2 -Wall

RM = rm -rf

LIBS = -lpthread -lsoa
HEADERS = Test.h Condition.h Mutex.h type.h soa.h
SOURCES = Main.cpp Test.cpp Condition.cpp Mutex.cpp
OBJS = Main.o Test.o Condition.o Mutex.o
TARG = Test

all: $(TARG)
$(TARG): $(OBJS)
    $(CXX) $(LIBS) $^ -o $@
    @echo Type ./$@ to execute the program.

.c.o:
    $(CXX) $(CXXFLAGS) $(LIBS) $< -o $@

.PHONY: distclean
distclean:
    $(RM) $(TARG) *.o

你可能感兴趣的:(一个C/C++通用的Makefile模板)