Makefile及GCC编译

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。

LinuxMakefile生成*.d依赖文件以及gcchttps:///qq1452008/article/details/50855810 1. 为什么要使用后缀名为 .d 的依赖文件？在 Makefile 中，目标文件的依赖关系需要包含一系列的头文件。

比如main.c 源文件内容如下：#include "stdio.h"#include "defs.h"int main(int argc, char *argv[]){printf("Hello, %s!\n", NAME);return 0;}defs.h 头文件如下：#ifndef _DEFS_H_#define _DEFS_H_#define NAME"makefile"#endif _DEFS_H_那么依赖关系如下（依赖的文件省略了绝对路径）：main.o : main.c stdio.h defs.h ...假设目标文件的依赖关系缺少了 defs.h 文件，当 defs.h 文件中的内容改变后，根本不会重新编译目标文件，这是致命的，因为目标文件内部引用了 defs.h 文件中的宏定义。

如果是一个比较大型的工程，我们必需清楚每一个源文件都包含了哪些头文件，并且在加入或删除某些头文件时，也需要一并修改Makefile，这是一个很没有维护性的工作。

为了避免这种繁重而又容易出错的事情，可以使用 C/C++ 编译器的“-M” 选项，即自动获取源文件中包含的头文件，并生成一个依赖关系。

例如，执行下面的命令：gcc -M main.c其输出如下：main.o : main.c defs.h由编译器自动生成依赖关系，这样做的好处有以下几点：•不必手动书写若干目标文件的依赖关系，由编译器自动生成•不管是源文件还是头文件有更新，目标文件都会重新编译2. 使用说明参数介绍：•-M•生成文件的依赖关系，同时也把一些标准库的头文件包含了进来。

windows makefile编译随着仓库中的代码越来越复杂，对于不同的平台和系统，不同的编译工具都被用来生成可执行文件。

在Windows平台上，Makefile是一种非常流行的编译工具，这篇文章将会详细介绍如何使用Windows Makefile来编译。

下面我们将分步骤阐述这个过程。

1. 安装编译工具首先需要安装MinGW编译工具。

MinGW是一个Windows下基于GNU编译器集合的开发环境，它包含了编译器和各种实用程序。

你可以在MinGW的官网上下载。

下载完成后，进行安装并将MinGW添加到系统路径中。

2. 创建Makefile接下来，需要创建一个Makefile来告诉Make怎么去编译代码以及链接库文件。

在Makefile中，可以定义一些常量和变量，来提高Makefile的重用性。

同时，还需要定义源代码和头文件的位置，以及生成的可执行文件的名称。

3. 编写Makefile下面是一个简单的Makefile的例子：```CC=gccCFLAGS=-c -WallLDFLAGS=-lmSOURCES=main.cOBJECTS=$(SOURCES:.c=.o)EXECUTABLE=myappall: $(SOURCES) $(EXECUTABLE)$(EXECUTABLE): $(OBJECTS)$(CC) $(OBJECTS) $(LDFLAGS) -o $@.c.o:$(CC) $(CFLAGS) $< -o $@```在这个例子中，我们定义了CC变量为gcc编译器，CFLAGS变量为编译选项。

同时，还定义了LDFLAGS变量为链接选项，SOURCES变量为源代码文件名称，OBJECTS变量为生成的目标文件对象名称，EXECUTABLE变量为生成的可执行文件名称。

对于Makefile中的命令，需要使用Tab键缩进来区分命令和规则。

在这个例子中，我们定义了一个默认目标all，它依赖于源代码和可执行文件。

C语言编译器gcc命令如何操作步骤C语言是一种高级编程语言，由于其结构化编程，声明式语法，高效性和可靠性，被广泛用于很多领域。

gcc是一种C语言编译器，是Unix系统中最常用的编译器之一，它可以编译C、C++、JAVA等语言。

本文将为读者介绍对于gcc编译器的基本概念、相关命令以及实践操作步骤。

一、gcc基本概念1. 什么是编译器？先来了解一下编译器的作用。

编译器是将高级语言编写的程序转换成计算机可执行的机器语言的软件程序。

程序员可以使用高级语言编写程序，编译器将高级语言转换成计算机能够理解的机器语言。

2. 什么是gcc?GCC是GNU编译器集合（GNU Compiler Collection）的缩写。

它是一个重要的语言编译器，可以编译C、C++、JAVA等语言的程序。

gcc包含了一系列的编译器，每一个编译器都可以编译不同的语言，它不仅是Linux系统中的常用编译器，也被广泛使用于其他操作系统中。

3. gcc优点- 开源软件：可以透明、高效地利用计算机系统资源，让整个编译过程更灵活。

- 软件体积小：由于每次都是重新编译，因此gcc生成的二进制文件体积很小。

- 可移植性：gcc可以在不同的操作系统上进行编译。

同一份源代码，在不同的系统上编译，可以得到相同的结果。

- 动态链接库：gcc支持动态链接库，可以减少程序的代码冗余问题。

二、gcc常用命令以下是gcc编译器的常用命令：1. gcc -ogcc命令使用" -o"选项可以把源文件编译成可执行文件，例如：```$ gcc -o hello hello.c```上述命令的含义是将hello.c文件编译成hello可执行文件。

2. gcc -cgcc命令使用" -c"选项将源文件编译成目标文件。

目标文件是不可执行的文件，它包含了已经编译过的程序的一部分，这些程序可以用作最终的可执行文件中的一部分。

例如：```$ gcc -c hello.c```上述命令的含义是将hello.c文件编译成目标文件hello.o。

makefile中gcc fatal error no input files在Makefile中使用GCC编译器时，如果你遇到"fatal error: no input files" 错误，这通常意味着编译器无法找到要编译的源文件。

这可能是由于几种原因引起的。

以下是一些可能导致此错误的常见原因和解决方法：1. 未指定源文件：-确保在Makefile中指定了要编译的源文件。

-例如，你的Makefile应该包含类似于：`gcc source.c -o output` 的命令。

2. 源文件不存在：-检查指定的源文件是否实际存在于你指定的路径中。

-确保文件名的拼写和大小写都正确。

3. Makefile中的规则错误：-确保Makefile中有正确的规则来指定如何编译源文件。

-例如，确保你的Makefile 中有类似于：```maketarget: source.cgcc source.c -o target```4. Makefile 中的变量问题：-如果你在Makefile中使用变量来表示源文件或目标文件，请确保变量的值是正确的。

-检查Makefile中与源文件相关的变量的定义。

5. 文件路径问题：-如果源文件位于其他目录中，请确保Makefile中的路径是正确的。

-可以使用`cd`命令进入源文件所在的目录，或者在Makefile中使用相对/绝对路径。

6. 文件扩展名问题：-确保文件扩展名正确，例如`.c` 对于C语言源文件。

以下是一个简单的Makefile示例：```make# Makefile# 定义目标和源文件TARGET = myprogramSOURCE = myprogram.c# 编译规则$(TARGET): $(SOURCE)gcc $(SOURCE) -o $(TARGET)# 清理规则clean:rm -f $(TARGET)```确保在你的Makefile中有类似于上述示例中的正确规则，目标文件和源文件的定义都正确。

gcc链接g++编译⽣成的静态库和动态库的makefile⽰例使⽤c++开发程序或者库时，将库提供给其他⼈使⽤。

然⽽使⽤者是使⽤c开发的程序，链接g++编译⽣成的库时，于链接gcc⽣成的库，有所不同。

⾸先是静态库，以链接g++编译⽣成的libmylib.a为例⼦mylib依赖于pthread，rt，math库，链接时必须放在mylib之后。

同时-Wl,--no-as-needed -ldl添加在末尾是必须的。

arm和x86有些不同，就是arm的gcc不会⾃动链接数学库math，需要⼿动添加链接。

1 CC=arm-linux-gnueabihf-gcc -std=c992 CCLDFLAGS= -L. -lmylib -lstdc++ -pthread -lrt -lm -Wl,--no-as-needed -ldl3 #CC=gcc -m32 -std=c994 #CCLDFLAGS=-L. -lmylib -lstdc++ -pthread -lrt -Wl,--no-as-needed -ldl56 all:test78 test.o:test.c9 $(CC) -I../inc/ test.c -c -o test.o1011 test:test.o libmylib.a12 $(CC) test.o -o test $(CCLDFLAGS)1314 .PHONY: clean1516 clean:17 -rm test test.o -fgcc链接g++⽣成的动态库⽰例：libmylib.so库，使⽤g++编译时，静态链接了stdc++库(-static-libstdc++)。

1 CC=gcc -m32 -std=c992 #CC=arm-linux-gnueabihf-gcc -std=c993 CCLDFLAGS=-lstdc++ -L. -lmylib45 Root:root67 root.o:test.c8 $(CC) -I../inc/ test.c -c -o root.o910 root:root.o libmylib.so11 $(CC) root.o -o root $(CCLDFLAGS)121314 .PHONY: clean1516 clean:17 -rm root *.o。

【原+转】⽤CMake代替makefile进⾏跨平台交叉编译 在开始介绍如何使⽤CMake编译跨平台的静态库之前，先讲讲我在没有使⽤CMake之前所趟过的坑。

因为很多开源的程序，⽐如png，都是⾃带编译脚本的。

我们可以使⽤下列脚本来进⾏编译：./configure --prefix=/xxx/xx --enable-static=YESmakemake install 相信⼿动在类Unix系统上⾯编译过开源程序的同学对上⾯的命令肯定⾮常熟悉。

更悲惨的是，有些开源库是不提供configure配置⽂件的，只有⼀个Makefile或者Makefile.gcc。

我的体会是，Makefile是⼀个很复杂的东西，没有⼀定的积累我们是看不懂的，更别说去修改它了。

⽽本⽂的CMake可以更傻⽠更简单地达到我们的⽬的，你不需要理会复杂的makefile语法。

Just follow me! 如果不配置编译器和⼀些编译、链接参数，这样的操作，最后编译出来的静态库只能在本系统上⾯被链接使⽤。

⽐如你在mac上⾯运⾏上⾯的命令，编译出来的静态库就只能给mac程序链接使⽤。

如果在Linux上⾯运⾏上述命令，则也只能给Linux上⾯的程序所链接使⽤。

如果我们想要在Mac上⾯编译出ios和android的静态库，就必须要⽤到交叉编译。

要进⾏交叉编译，⼀般来说要指定⽬标编译平台的编译器，通常是指定⼀个CC环境变量，根据编译的是c库还是c++库，要分别指定C_flags和CXX_flag，当然还需要指定c/c++和系统sdk的头⽂件包含路径。

总之，⾮常之繁琐。

为什么要使⽤CMake 为什么我们不使⽤autoconf？为什么我们不使⽤QMake,JAM,ANT呢？具体原因⼤家可以参考我在本⽂最后的参考链接⾥⾯的⼀书的第⼀章。

我⾃⼰使⽤CMake的感受就是：我原来编写bash，配置configure参数，读各个开源库的INSTALL⽂件(因为不同库的configure参数有差别)，配置各种编译flag，头⽂件包含等。

makefile gcc编译
Makefile 是一个用来组织代码编译的工具，而 GCC 是一个常用的 C 和 C++ 编译器。

在 Makefile 中使用 GCC 进行编译可以通过以下步骤完成：
1. 创建一个名为 "Makefile" 的文本文件，并确保它位于你的项目根目录下。

2. 在 Makefile 中定义你的编译规则。

例如，假设你有一个名为 "main.c" 的源文件需要编译成可执行文件 "app"，你可以这样编写 Makefile：
make.
app: main.c.
gcc -o app main.c.
在这个例子中，我们定义了一个名为 "app" 的目标，它依赖于"main.c" 这个源文件。

当你运行 "make" 命令时，Make 工具会根
据这个规则来执行编译。

3. 打开终端，进入到包含 Makefile 的项目目录下。

4. 运行命令 "make"。

Make 工具会读取 Makefile 文件，并执行其中定义的编译规则。

在这个例子中，它会使用 GCC 编译器来编译 "main.c" 并生成可执行文件 "app"。

需要注意的是，Makefile 可以包含更复杂的规则和变量定义，以及支持多个源文件的编译。

你可以根据你的项目需求来进一步扩展和定制 Makefile 文件。

总之，通过合理编写 Makefile 并结合使用 GCC 编译器，你可以高效地组织和管理你的代码编译过程。

文章标题：深度探讨makefile中的gcc -c -o语法在makefile中，gcc -c -o是一个非常重要的语法结构，用于编译源文件并生成目标文件。

在本文中，我将对这个语法进行深入探讨，帮助你更好地理解它的用途和功能，并运用到实际的项目中。

1. gcc -c -o的基本概念在makefile中，gcc -c -o用于将源文件编译成目标文件。

其中，-c表示编译但不信息，-o用于指定编译后生成的目标文件名。

这个语法结构在实际的项目中非常常见，尤其是在大型的软件开发过程中。

2. 深入理解gcc -c -o的作用通过gcc -c -o，我们可以将源文件编译成目标文件，然后再将多个目标文件信息起来，生成可执行文件。

这样的分步编译方式可以提高编译的效率，尤其是在一个项目中包含大量源文件的情况下。

另外，通过指定-o参数，我们可以自定义目标文件的生成规则和命名规范，让项目结构更加清晰和灵活。

3. 实际应用案例举一个实际的例子，比如我们有一个项目包含多个源文件，分别是main.c、function1.c和function2.c。

我们可以使用gcc -c -o将这些源文件分别编译成目标文件main.o、function1.o和function2.o，然后通过gcc将这些目标文件信息起来，生成可执行文件。

这样的分步编译方式可以提高项目的维护性和灵活性。

4. 对于gcc -c -o的个人观点和理解个人认为，gcc -c -o是一个非常实用的编译选项，尤其是在大型的软件开发项目中。

通过这个选项，我们可以更加灵活地管理项目的结构，提高编译效率，同时也让代码更加清晰和易于维护。

在实际的项目中，我经常使用这个选项来进行分步编译，以便更好地管理和组织代码。

5. 总结通过本文的深入探讨，相信你对makefile中的gcc -c -o语法有了更深入的理解。

这个语法不仅在软件开发中非常常见，而且也非常实用。

通过灵活运用这个选项，我们可以更好地管理和组织项目，提高代码的可维护性和开发效率。

c++ linux编译命令
C++Linux编译命令是指在Linux系统下，使用C++语言进行程序开发时所需的编译命令。

下面是一些常用的C++ Linux编译命令： 1. g++命令：用于编译C++程序。

语法：g++ [options] file1.cpp file2.cpp ... -o output 选项说明：
- -o output：指定输出文件的文件名。

- -c：仅编译源文件，生成目标文件（.o文件）。

- -g：生成调试信息。

- -O：优化编译过程。

- -Wall：显示全部警告。

2. make命令：用于自动化编译。

语法：make [target]
选项说明：
- target：指定要编译的目标（默认为Makefile中的第一个目标）。

3. cmake命令：用于生成Makefile文件。

语法：cmake [options] source_directory
选项说明：
- -G：指定生成的Makefile文件类型。

- -D：设置变量的值。

4. gdb命令：用于调试程序。

语法：gdb [options] [executable-file [core-file or process-id]]
选项说明：
- -tui：启动GDB的文本模式界面。

- -q：禁止显示版权和欢迎信息。

- -x：执行指定的GDB脚本。

以上就是一些常用的C++ Linux编译命令，开发者们可以根据需要使用相应的命令，提高编译效率和程序质量。

Makefile中用宏定义进行条件编译-CSDN博客在源代码里面如果这样是定义的：#ifdef MACRONAME//可选代码#endif那在makefile里面gcc -D MACRONAME=MACRODEF或者gcc -D MACRONAME这样就定义了预处理宏，编译的时候可选代码就会被编译进去了。

对于GCC编译器，有如下选项：-D macro=string，等价于在头文件中定义：#define macro string。

例如：-D TRUE=true，等价于：#define TRUE true-D macro，等价于在头文件中定义：#define macro 1，实际上也达到了定义：#define macro的目的。

例如：-D LINUX，等价于：#define LINUX 1（与#define LINUX作用类似）。

--define-macro macro=string与-D macro=string作用相同。

如：TEST.C 文件#include <stdio.h>#include <stdlib.h>main(){#ifdef p1 printf('Hello p1');#else printf('Hello p2');#endif }1.编译： gcc -o test test.c运行： ./test输出： Hello p22.编译： gcc -o test test.c -D p1运行： ./test输出： Hello p1还有另外一种使用方式：Makefile写法：$(SERVER_NAME):$(SERVER_OBJ) $(COM_OBJS) $(CC) -Wall -pthread -D KRC_SERVER_NAME=$(SERVER_NAME)_FLAG C代码中用法：#if KRC_SERVER_NAME == krc_search_FLAG#elif KRC_SERVER_NAME == krc_feedback_FLAG#else#endif注意：其中的两个参数为宏定义，不能使用常量定义，因为需要在预编译阶段就要确定其值！#define krc_search_FLAG 1#define krc_feedback_FLAG 2这种用法也能实现条件编译的作用，而且更好！。

makefile 语法Makefile是一种常用的构建工具，用于自动化构建和管理软件项目。

它是一种文本文件，包含一系列规则，用于指定如何编译、链接和构建源代码。

本文将介绍 Makefile 的语法和使用方法。

一、Makefile 的基本语法Makefile 文件由一系列规则组成，每个规则由一个目标和一个或多个依赖项组成。

目标是要生成的文件名，依赖项是生成目标所需要的文件或命令。

当目标文件不存在或依赖项的时间戳比目标文件的时间戳更晚时，Makefile 将自动执行规则中的命令，生成目标文件。

一个简单的 Makefile 示例：```hello: main.cgcc -o hello main.c```这个 Makefile 包含了一个规则，目标是 hello，依赖项是main.c。

当 main.c 文件的时间戳比 hello 文件的时间戳更晚时，Makefile 将执行 gcc 命令编译 main.c 文件，并生成可执行文件hello。

Makefile 的规则语法如下：```target: dependenciescommand1command2...```其中，target 是规则的目标，dependencies 是规则的依赖项，command1、command2 等是要执行的命令。

命令必须以一个制表符或多个空格开头，否则 Makefile 将无法识别。

二、Makefile 的变量Makefile 中可以定义变量，用于存储常用的值或命令。

变量以$ 符号开头，可以在规则中使用。

变量的定义语法如下：```VARNAME = value```或者```VARNAME := value```其中，等号和冒号加等号的区别在于，等号定义的变量是递归展开的，而冒号加等号定义的变量是简单展开的。

递归展开的变量可以包含其他变量的引用，而简单展开的变量只能包含直接的值。

示例：```CC = gccCFLAGS = -Wall -O2hello: main.c$(CC) $(CFLAGS) -o hello main.c```这个 Makefile 中定义了两个变量 CC 和 CFLAGS，用于存储编译器和编译选项。

使⽤makefile编译多个⽂件（.c,.cpp,.h等）有时候我们要⼀次运⾏多个⽂件，这时候我们可以使⽤Makefile◊make是什么？ make是⼀个命令⼯具，是⼀个解释makefile中指令的命令⼯具。

它可以简化编译过程⾥⾯所下达的指令，当执⾏make 时，make 会在当前的⽬录下搜寻 Makefile (or makefile) 这个⽂本⽂件，执⾏对应的操作。

make 会⾃动的判别原始码是否经过变动了，⽽⾃动更新执⾏档。

◊为什么要使⽤make？ 假设，现在⼀个项⽬⾥⾯包含了100个程序⽂件，如果要对这个项⽬进⾏编译，那么光是编译指令就有100条。

如果要重新进⾏编译，那么就⼜得像之前⼀样重新来⼀遍。

这样重复且繁琐的⼯作实在是让我们很不爽啊。

所以，⽤make来进⾏操作，间接调⽤gcc岂不是很⽅便？如果我们更动过某些原始码档案，则 make 也可以主动的判断哪⼀个原始码与相关的⽬标⽂件档案有更新过，并仅更新该档案。

这样可以减少重新编译所需要的时间，也会更加⽅便。

◊makefile⼜是⼲什么的？ makefile其实就是⼀个⽂档，⾥⾯定义了⼀系列的规则指定哪些⽂件需要先编译，哪些⽂件需要后编译，哪些⽂件需要重新编译，它记录了原始码如何编译的详细信息！ makefile⼀旦写好，只需要⼀个make命令，整个⼯程完全⾃动编译，极⼤的提⾼了软件开发的效率。

先看⼀下makefile的规则： ⽬标（target)：⽬标⽂件1 ⽬标⽂件2 <Tab>gcc -o 欲建⽴的执⾏⽂件⽬标⽂件1 ⽬标⽂件2先举⼀个运⾏多个c语⾔⽂件。

⾸先下⾯是⼀个完整的 c语⾔⽂件，实现了统计⽤户输⼊的字符串中⼤⼩写字母的个数#include<unistd.h>#include<sys/types.h>#include<sys/wait.h>void test(){char str[50]={0};scanf("%s",str);int m=0;int n=0;pid_t p=fork();if(p<0){printf("fork failed");}if(p == 0){for(int i=0;i<sizeof(str);i++){if( str[i]<='Z'&& str[i]>='A'){m++;}}printf("⼤写字母⼀共有");printf("%d",m);printf("个");}if(p>0){for(int i=0;i<sizeof(str);i++){if(str[i]>='a' && str[i]<='z'){n++;}}printf("⼩写字母⼀共有");printf("%d",n);printf("个");}}int main(){test();return 0;}此时我们可以把该⽂件拆成三份，⼀份是.h⽂件，⽤来放头⽂件等信息，另外两个是.c⽂件，⼀个⽤来放main⽅法，⼀个放声明的函数，如下三图则在终端进⾏⼀下操作成功运⾏多个⽂件下⾯介绍运⾏cpp⽂件，⼤致步骤相同。

makefile 条件编译MakefileUnix/Linux译系统编写程序所必需的文件，其中包含了定义规则以及编译程序所必需的指令。

通常情况下，一个规则描述了从一个或多个源文件到一个或多个目标文件之间的变换过程。

在特定的编译环境中，定义的规则必须能够生成所有需要的目标文件及时准确的。

有时候，一个源文件或多个源文件具有不同的编译条件，此时Makefile件编译的技术就派上用场了。

这种技术可以根据指定的编译条件自动生成 Makefile则，使得编译器只有在满足编译条件时才会编译特定的源文件。

Makefile件编译基本依赖于 make令，它可以根据给定的源文件及编译条件，自动生成 Makefile则。

Make令使用 C言编写，可以从一个或多个文本文件中读取输入，比如源文件，然后根据相应的编译条件，使用 if句来生成 Makefile则。

要想理解 Makefile件编译，首先必须明白 Makefile几个基本概念。

Makefile 中有若干规则，每个规则由一个目标文件，一个或多个依赖文件，以及一系列的命令组成。

它们通常以三个元素表示： target: dependenciestcommands其中，target 代表目标文件，dependencies该目标文件的依赖文件，commands该目标文件生成所需的命令。

为了利用 Makefile件编译，可以将每个文件的编译条件定义为一个 Makefile量，这样 Make编译文件时就可以根据指定的编译条件来生成 Makefile则。

例如，对于两个源文件 A B，A编译条件为BUILD_A，B编译条件为 BUILD_B，只有当 BUILD_A 为真，A会被编译，当 BUILD_B 为真，B会被编译。

要实现 Makefile件编译，可以使用 Make 中的 if件语句：ifeq (BUILD_A,1)A: ../A.cpptg++ -o A ../A.cppendififeq (BUILD_B,1)B: ../B.cpptg++ -o B ../B.cppendif上面的 Makefile 中，对于 A B两个源文件，它们的编译条件分别是 BUILD_A BUILD_B，即 BUILD_A 为真时，A会被编译，BUILD_B 为真时，B会被编译。