GNU Makefile教程入门

Intro

1 GCC 官方文档

GCC 官方文档网站：https://gcc.gnu.org/onlinedocs/

  • 官方文档是最权威的，网上所有的答案都来自官方文档
  • 适应英语阅读，中文是母语，很多词我们自己有根深蒂固的含义和概念，再重新赋予新含义非常不容易理解或有歧义
  • 英语用词、逻辑比较严谨，网上的翻译水平参差不齐，坑很多
  • 国内论坛找到好答案全凭运气，好的答案可以节省时间，没有好的答案还是得花时间看官方文档，所以还是自己靠谱一点，锻炼一下英语能力

 

2 GCC的介绍

  GCC 是 GNU项目的一个产品。

  GCC（GNU Compiler Collection，GNU编译程序集合）是最重要的开放源码软件。其他所有开放源码软件都在某种层次上依赖于它。甚至其他语言，例如 Python，都是由 C 语言开发的，由 GNU 编译程序编译的。

  这个软件对于整个自由软件运动而言具有根本性的意义。如果没有它或类似的软件，就不可能有自由软件运动。GCC 为 Linux 的出现提供了可能性。

  GCC 是由许多组件组成的，但它们也并不总是出现的。有些部分是和语言相关的，所以如果没有安装某种特定语言，系统中就不会出现相关的文件。

 

2.1 GCC常见的组成部分

  • c++： gcc 的一个版本，默认语言设置为 C++，而且在链接的时候自动包含标准 C++ 库。这和 g++ 一样

  • configure： GCC 源代码树根目录中的一个脚本。用于设置配置值和创建 GCC 编译程序必需的 make 程序文件

  • g++： gcc 的一个版本，默认语言设置为 C++，而且在链接的时候自动包含标准 C++库。这和 c++ 一样

  • gcc： 该驱动程序等同于执行编译程序和连接程序以产生需要的输出

  • libgcc： 该库包含的例程被作为编译程序的一部分，是因为它们可被链接到实际的可执行程序中。它们是特殊的例程，链接到可执行程序，来执行基本的任务，例如浮点运算。这些库中的例程通常都是平台相关的

  • libstdc++： 运行时库，包括定义为标准语言一部分的所有的 C++类和函数

 

2.2 GCC包含的常见的软件

  • ar： 这是一个程序，可通过从文档中增加、删除和析取文件来维护库文件。通常使用该工具是为了创建和管理连接程序使用的目标库文档。该程序是 binutils 包的一部分

  • as： GNU 汇编器。实际上它是一族汇编器，因为它可以被编译或能够在各种不同平台上工作。该程序是 binutjls 包的一部分
    autoconf：产生的 shell 脚本自动配置源代码包去编译某个特定版本的 UNIX

  • gdb： GNU 调试器，可用于检查程序运行时的值和行为
    GNATS：GNU 的调试跟踪系统（GNU Bug Tracking System）。一个跟踪 GCC和其他 GNU 软件问题的在线系统

  • gprof： 该程序会监督编译程序的执行过程，并报告程序中各个函数的运行时间，可以根据所提供的配置文件来优化程序。该程序是 binutils 包的一部分

  • ld： GNU 连接程序。该程序将目标文件的集合组合成可执行程序。该程序是 binutils 包的一部分

  • libtool： 一个基本库，支持 make 程序的描述文件使用的简化共享库用法的脚本

  • make： 一个工具程序，它会读 makefile 脚本来确定程序中的哪个部分需要编译和连接，然后发布必要的命令。它读出的脚本（叫做 makefile 或 Makefile）定义了文件关系和依赖关系

 

3 GCC默认头文件搜索路径

查看命令

echo | gcc -v -x c -E -
  • /usr/lib/gcc/x86_64-linux-gnu/7/include
  • /usr/local/include
  • /usr/lib/gcc/x86_64-linux-gnu/7/include-fixed
  • /usr/include/x86_64-linux-gnu
  • /usr/include

 

简单编译原理

1 hello, world在计算机的表示

hello 程序的生命周期是从一个源程序（或者说源文件）开始的，即程序员通过编辑器创建并保存的文本文件，文件名是 hello.c。源程序实际上就是一个由值 0 和 1组成的位（又称为比特）序列，8 个位被组织成一组，称为字节。每个字节表示程序中的某些文本字符

大部分计算机使用 ASCII 标准来表示文本字符

  • 用一个唯一的单字节大小的整数值息来表示每个字符
  • hello.c 程序是以字节序列的方式储存在文件中的

hello.c 的表示方法说明了一个基本思想∶ 系统中所有的信息——包括磁盘文件、内存中的程序、内存中存放的用户数据以及网络上传送的数据，都是由一串比特表示的

在这里插入图片描述

 

2 编译过程

hello 程序的生命周期从一个高级 C 语言程序开始

为了在系统上运行 hello.c 程序，每条 C 语句都必须被其他程序转化为一系列的低级机器语言指令

然后这些指令按照一种称为可执行目标程序的格式打好包，并以二进制磁盘文件的形式存放起来

GCC 编译器读取源程序文件 hello.c，并把它翻译成一个可执行目标文件 hello。这个翻译过程可分为四个阶段完成，如下图所示

执行这四个阶段的程序（预处理器、编译器、汇编器和链接器）一起构成了编译系统（compilation system）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iebLFNTc-1681369322961)(images/compilesystem.png)]

 

2.1 预处理阶段

预处理器（cpp）根据以字符#开头的命令，修改原始的 C 程序。比如 hello.c中第 1行的#include < stdio.h>命令告诉预处理器读取系统头文件 stdio.h 的内容，并把它直接插入程序文本中。结果就得到了另一个 C程序，通常是以.i作为文件扩展名。

 

2.2 编译阶段

编译器（ccl）将文本文件 hello.i翻译成文本文件 hello.s，它包含一
个汇编语言程序。该程序包含函数 main 的定义，如下所示：

            main:
            subq    $8, %rsp 
            mov1    $.LCO,%edi 
            call    puts 
            mov1    $0,%eax 
            addq    $8,%rsp 
            ret

每条语句都以一种文本格式描述了一条低级机器语言指令。汇编语言非常有用，它为不同高级语言的不同编译器提供了通用的输出语言

 

2.3 汇编阶段

汇编器（as）将 hello.s 翻译成机器语言指令，把这些指令打包成一种叫做可重定位目标程序（relocatable object program）的格式，并将结果保存在目标文件 hello.o中。

hello.o 文件是一个二进制文件，它包含的17 个字节是函数 main的指令编码。如果我们在文本编辑器中打开 hello.o文件，将看到一堆乱码。

 

2.4 链接阶段

注意，hello程序调用了 printf 函数，它是每个 C 编译器都提供的标准 C 库中的一个函数。printf 函数存在于一个名为 printf.o 的单独的预编译好了的目标文件中，而这个文件必须以某种方式合并到我们的 hello.o 程序中。

链接器（ld）就负责处理这种合并。结果就得到 hello 文件，它是一个可执行目标文件（或者简称为可执行文件），可以被加载到内存中，由系统执行。

 

3 hello, world的执行过程

第一步

  • shell 等待我们输入一个命令
  • 当我们在键盘上输入字符串"./hello"（注意这里是编译好的可执行目标文件）后
  • shell 程序将字符逐一读入寄存器
  • 再把它存放到内存中

在这里插入图片描述

第二步

  • 当我们在键盘上敲回车键时，shell 程序就知道我们已经结束了命令的输人
  • 然后 shell 执行一系列指令来加载可执行的 hello 文件
  • 这些指令将 hello 目标文件中的代码和数据从磁盘复制到主存
  • 数据包括最终会被输出的字符串"hello，world\n"。

在这里插入图片描述

第三步

  • 一旦目标文件 hello 中的代码和数据被加载到主存
  • 处理器就开始执行 hello 程序的 main 程序中的机器语言指令
  • 这些指令将 “hello，world\n” 字符串中的字节从主存复制到寄存器文件
  • 再从寄存器文件中复制到显示设备，最终显示在屏幕上
    在这里插入图片描述

 

4 程序在计算机内的存储

上面的例子揭示了一个重要的问题，即系统“似乎”花费了大量的时间和步骤把信息从一个地方挪到另一个地方

  • hello程序的机器指令最初是存放在磁盘上
  • 当程序加载时，它们被复制到主存
  • 当处理器运行程序时，指令又从主存复制到处理器

相似地，数据串 "hello，world\n"开始时在磁盘上，然后被复制到主存，最后从主存上复制到显示设备

 

1 Fundamental Compiling

编译 C 语言相关的后缀
在这里插入图片描述

 

2 Compiling C

2.1 Preprocessing

# 不会生成 .i 文件
gcc -E main.c
gcc -E main.c -o helloworld.i
  • -E 选项告诉编译器只进行预处理操作
  • -o 选项把预处理的结果输出到指定文件

 

2.2 Generating Assembly Language

gcc -S main.c
gcc -S main.c -o xxx.s
  • -S 选项告诉编译器，进行预处理和编译成汇编语言操作

每个平台对应的汇编语言的形式是不同的，例如有很多型号的开发板，有很多型号的 CPU

 

2.3 Source File to Object File

gcc -c main.c
gcc -c main.c -o xxx.o
# 编译多个 .c 文件
gcc -c main.c add.c minus.c

 

2.4 Single Source to Executable

  • 注意：后面三个命令执行后并没有按编译过程出现 .i .s 或 .o 文件，并不意味着没有经历这些过程
gcc main.c
gcc main.c -o xxx

执行程序

./可执行文件

2.5 Multiple Sources to Executable

gcc main.c add.c minus.c -o exec
./exec

 

3 Creating a Static Library

  • 编译成 .o 的文件
    gcc -c [.c] -o [自定义文件名] 
gcc -c [.c] [.c] ...
  • 编静态库
    ar -r [lib自定义库名.a] [.o] [.o] ...
  • 链接成可执行文件
    gcc [.c] [.a] -o [自定义输出文件名]
gcc [.c] -o [自定义输出文件名] -l[库名] -L[库所在路径]

 

4 Creating a Shared Library

编译二进制.o文件

gcc -c -fpic [.c/.cpp][.c/.cpp]...

编库

gcc -shared [.o][.o]... -o [lib自定义库名.so]
  • 链接库到可执行文件
gcc [.c/.cpp] -o [自定义可执行文件名]  -l[库名] -L[库路径] -Wl,-rpath=[库路径]

 

总结

1 编译过程

源文件.c文件 -> 预编译成.i文件 -> 编译成汇编语言.s -> 汇编成.o文件 -> 链接成可执行文件（名字自定义，后缀没关系）

2 编译过程命令

  • 预处理：
    gcc -E [.c源文件] -o [自定义输出文件名.i]
  • 编译成汇编语言(隐藏了预处理操作) :
    gcc -S [.c源文件]
  • 会变成.o的object文件（二进制文件，可用于链接） :
    gcc -c [.c源文件] [.c源文件] [...] (可选选项：-o [自定文件名])

3 库

静态库

  • 编库（先转成.o文件，再编成lib[自定库名].a）
    gcc -c [.c源文件] [.c源文件] [...] (可选选项：-o [自定文件名])

    ar -r lib[自定库名].a [.o文件] [.o文件] [...]
  • 链接
    gcc [main文件] -o [自定义输出可执行文件名] -l[库名] -L[库的路径]

动态库

  • 编库

    • 第一种做法， 先转成.o文件，再编成.so文件
      gcc -c -fpic [.c源文件] [.c源文件] [...]

      gcc -shared [.o文件] [.o文件] [...] -o lib[库名].so
    • 第二种做法，直接转成.so
      gcc -fpic -shared [.c源文件] [.c源文件] [...] -o lib[库名].so

  • 链接

    gcc [main文件] -o [自定义输出可执行文件名] -l[库名] -L[库所在路径] -Wl,-rpath=[库所在路径]

 

Makefile

  • GNU Make 官方网站：https://www.gnu.org/software/make/
  • GNU Make 官方文档下载地址：https://www.gnu.org/software/make/manual/
  • Makefile Tutorial：https://makefiletutorial.com/

 

1 基本格式

targets : prerequisties
[tab键]command
  • target：目标文件，可以是 OjectFile，也可以是执行文件，还可以是一个标签（Label），对于标签这种特性，在后续的“伪目标”章节中会有叙述。
  • prerequisite：要生成那个 target 所需要的文件或是目标。
  • command：是 make 需要执行的命令，

 

2 Makefile 规则

  • make 会在当前目录下找到一个名字叫 Makefile 或 makefile 的文件
  • 如果找到，它会找文件中第一个目标文件（target），并把这个文件作为最终的目标文件
  • 如果 target 文件不存在，或是 target 文件依赖的 .o 文件(prerequities)的文件修改时间要比 target 这个文件新，就会执行后面所定义的命令 command 来生成 target 这个文件
  • 如果 target 依赖的 .o 文件（prerequisties）也存在，make 会在当前文件中找到 target 为 .o 文件的依赖性，如果找到，再根据那个规则生成 .o 文件

 

3 伪目标

“伪目标” 不是一个文件，只是一个标签。我们要显示地指明这个 “目标” 才能让其生效

“伪目标” 的取名不能和文件名重名，否则不会执行命令

为了避免和文件重名的这种情况，我们可以使用一个特殊的标记 .PHONY 来显示地指明一个目标是“伪目标”，向 make 说明，不管是否有这个文件，这个目标就是 “伪目标”

.PHONY : clean

只要有这个声明，不管是否有“clean”文件，要运行 “clean” 这个目标，只有"make clean" 这个命令

 

Makefile 的变量

变量在声明时需要给予初值，而在使用时，需要给在变量名前加上 $ 符号，并用小括号 () 把变量给包括起来。

 

1 变量的定义

cpp := src/main.cpp 
obj := objs/main.o

2 变量的引用

  • 可以用 () 或 {}
cpp := src/main.cpp 
obj := objs/main.o

$(obj) : ${cpp}
	@g++ -c $(cpp) -o $(obj)

compile : $(obj)

 

3 预定义变量

  • $@: 目标(target)的完整名称
  • $<: 第一个依赖文件（prerequisties）的名称
  • $^: 所有的依赖文件（prerequisties），以空格分开，不包含重复的依赖文件
cpp := src/main.cpp 
obj := objs/main.o

$(obj) : ${cpp}
	@g++ -c $< -o $@
	@echo $^

compile : $(obj)
.PHONY : compile

Makefile 常用符号

1 =

  • 简单的赋值运算符
  • 用于将右边的值分配给左边的变量
  • 如果在后面的语句中重新定义了该变量，则将使用新的值

示例

HOST_ARCH   = aarch64
TARGET_ARCH = $(HOST_ARCH)

# 更改了变量 a
HOST_ARCH   = amd64

debug:
	@echo $(TARGET_ARCH)

2 :=

  • 立即赋值运算符
  • 用于在定义变量时立即求值
  • 该值在定义后不再更改
  • 即使在后面的语句中重新定义了该变量

示例

HOST_ARCH   := aarch64
TARGET_ARCH := $(HOST_ARCH)

# 更改了变量 a
HOST_ARCH := amd64

debug:
	@echo $(TARGET_ARCH)

 

3 ?=

  • 默认赋值运算符
  • 如果该变量已经定义，则不进行任何操作
  • 如果该变量尚未定义，则求值并分配
HOST_ARCH  = aarch64
HOST_ARCH ?= amd64

debug:
    @echo $(HOST_ARCH)

 

4 累加 +=

CXXFLAGS := -m64 -fPIC -g -O0 -std=c++11 -w -fopenmp

CXXFLAGS += $(include_paths)

 

5 \

  • 续行符

示例

LDLIBS := cudart opencv_core \
          gomp nvinfer protobuf cudnn pthread \
          cublas nvcaffe_parser nvinfer_plugin

 

6 * 与 %

  • *: 通配符表示匹配任意字符串，可以用在目录名或文件名中
  • %: 通配符表示匹配任意字符串，并将匹配到的字符串作为变量使用

 

Makefile 的常用函数

函数调用，很像变量的使用，也是以 “$” 来标识的，其语法如下：

$(fn, arguments) or ${fn, arguments}
  • fn: 函数名
  • arguments: 函数参数，参数间以逗号 , 分隔，而函数名和参数之间以“空格”分隔

 

1 shell

$(shell <command> <arguments>)
  • 名称：shell 命令函数 —— shell
  • 功能：调用 shell 命令 command
  • 返回：函数返回 shell 命令 command 的执行结果

示例

# shell 指令，src 文件夹下找到 .cpp 文件
cpp_srcs := $(shell find src -name "*.cpp") 
# shell 指令, 获取计算机架构
HOST_ARCH := $(shell uname -m)

 

2 subst

$(subst <from>,<to>,<text>)
  • 名称：字符串替换函数——subst
  • 功能：把字串 <text> 中的 <from> 字符串替换成 <to>
  • 返回：函数返回被替换过后的字符串

示例：


cpp_srcs := $(shell find src -name "*.cpp")
cpp_objs := $(subst src/,objs/,$(cpp_objs))

 

3 patsubst

$(patsubst <pattern>,<replacement>,<text>)
  • 名称：模式字符串替换函数 —— patsubst
  • 功能：通配符 %，表示任意长度的字串，从 text 中取出 patttern， 替换成 replacement
  • 返回：函数返回被替换过后的字符串

示例

cpp_srcs := $(shell find src -name "*.cpp") #shell指令，src文件夹下找到.cpp文件
cpp_objs := $(patsubst %.cpp,%.o,$(cpp_srcs)) #cpp_srcs变量下cpp文件替换成 .o文件

 

4 foreach

$(foreach <var>,<list>,<text>)
  • 名称：循环函数——foreach。
  • 功能：把字串<list>中的元素逐一取出来，执行<text>包含的表达式
  • 返回：<text>所返回的每个字符串所组成的整个字符串（以空格分隔）

示例：

library_paths := /datav/shared/100_du/03.08/lean/protobuf-3.11.4/lib \
                 /usr/local/cuda-10.1/lib64 \

library_paths := $(foreach item,$(library_paths),-L$(item))

同等效果

I_flag := $(include_paths:%=-I%)

 

5 dir

$(dir <names...>)
  • 名称：取目录函数——dir。
  • 功能：从文件名序列中取出目录部分。目录部分是指最后一个反斜杠（“/”）之前
    的部分。如果没有反斜杠，那么返回“./”。
  • 返回：返回文件名序列的目录部分。
  • 示例：
$(dir src/foo.c hacks)    # 返回值是“src/ ./”。

 

6 notdir

$(notdir <names...>)

示例

libs   := $(notdir $(shell find /usr/lib -name lib*))

 

7 filter

$(filter <names...>)

libs    := $(notdir $(shell find /usr/lib -name lib*))
a_libs  := $(filter %.a,$(libs))
so_libs := $(filter %.so,$(libs))

 

8 basename

$(basename <names...>)

libs    := $(notdir $(shell find /usr/lib -name lib*))
a_libs  := $(subst lib,,$(basename $(filter %.a,$(libs))))
so_libs := $(subst lib,,$(basename $(filter %.so,$(libs))))

 

Conditional Rules

注意：

  • Condition 语句里面全部不能用 Tab 缩进, 你看到的 Makefile 如果好像有 “Tab”, 那全部是空格
  • 使用 Tab 会报错：*** commands commence before first target

1 ifeq / else / endif

# build flags
ifeq ($(TARGET_OS),darwin)
    LDFLAGS += -rpath $(CUDA_PATH)/lib
    CCFLAGS += -arch $(HOST_ARCH)
else ifeq ($(HOST_ARCH)-$(TARGET_ARCH)-$(TARGET_OS),x86_64-armv7l-linux)
    LDFLAGS += --dynamic-linker=/lib/ld-linux-armhf.so.3
    CCFLAGS += -mfloat-abi=hard
else ifeq ($(TARGET_OS),android)
    LDFLAGS += -pie
    CCFLAGS += -fpie -fpic -fexceptions
endif

 

2 ifneq / else / endif

HOST_ARCH   := $(shell uname -m)
TARGET_ARCH ?= $(HOST_ARCH)
temp := $(filter $(TARGET_ARCH),x86_64 aarch64 sbsa ppc64le armv7l)

ifneq (,$(filter $(TARGET_ARCH),x86_64 aarch64 sbsa ppc64le armv7l))
    ifneq ($(TARGET_ARCH),$(HOST_ARCH))
        ifneq (,$(filter $(TARGET_ARCH),x86_64 aarch64 sbsa ppc64le))
            TARGET_SIZE := 64
        else ifneq (,$(filter $(TARGET_ARCH),armv7l))
            TARGET_SIZE := 32
        endif
    else
        TARGET_SIZE := $(shell getconf LONG_BIT)
    endif
else
    $(error ERROR - unsupported value $(TARGET_ARCH) for TARGET_ARCH!)
endif

 

3 ifdef / else / endif

ifdef TARGET_OVERRIDE # cuda toolkit targets override
    NVCCFLAGS += -target-dir $(TARGET_OVERRIDE)
endif

 

Compile

1 编译过程

1.1 预处理

示例

cpp_srcs := $(shell find src -name *.cpp)
pp_files := $(patsubst src/%.cpp,src/%.i,$(cpp_srcs))

src/%.i : src/%.cpp
	@g++ -E $^ -o $@

preprocess : $(pp_files)

clean :
	@rm -f src/*.i

debug :
	@echo $(pp_files)

.PHONY : debug preprocess clean

 

1.2 编译成汇编语言

示例

cpp_srcs := $(shell find src -name *.cpp)
as_files := $(patsubst src/%.cpp,src/%.s,$(cpp_srcs))

src/%.s : src/%.cpp
	@g++ -S $^ -o $@

assemble : $(as_files)

clean :
	@rm -f src/*.s

debug :
	@echo $(as_files)

.PHONY : debug assemble clean

 

1.3 编译成目标文件

示例

cpp_srcs := $(shell find src -name *.cpp)
cpp_objs := $(patsubst src/%.cpp,objs/%.o,$(cpp_srcs))

objs/%.o : src/%.cpp
	@mkdir -p $(dir $@)
	@g++ -c $^ -o $@

objects : $(cpp_objs)

clean :
	@rm -rf objs src/*.o

debug :
	@echo $(as_files)

.PHONY : debug objects clean

 

1.4 链接可执行文件

cpp_srcs := $(shell find src -name *.cpp)
cpp_objs := $(patsubst src/%.cpp,objs/%.o,$(cpp_srcs))


objs/%.o : src/%.cpp
	@mkdir -p $(dir $@)
	@g++ -c $^ -o $@

workspace/exec : $(cpp_objs)
	@mkdir workspace/exec
	@g++ $^ -o $@

run : workspace
	@./$<

clean :
	@rm -rf objs workspace/exec

debug :
	@echo $(as_files)

.PHONY : debug run clean

 

2 编译选项

编译选项

  • -m64: 指定编译为 64 位应用程序
  • -std=: 指定编译标准，例如：-std=c++11、-std=c++14
  • -g: 包含调试信息
  • -w: 不显示警告
  • -O: 优化等级，通常使用：-O3
  • -I: 加在头文件路径前
  • fPIC: (Position-Independent Code), 产生的没有绝对地址，全部使用相对地址，代码可以被加载到内存的任意位置，且可以正确的执行。这正是共享库所要求的，共享库被加载时，在内存的位置不是固定的

链接选项

  • -l: 加在库名前面
  • -L: 加在库路径前面
  • -Wl,<选项>: 将逗号分隔的 <选项> 传递给链接器
  • -rpath=: “运行” 的时候，去找的目录。运行的时候，要找 .so 文件，会从这个选项里指定的地方去找

 

3 Implicit Rules

  • CC: Program for compiling C programs; default cc
  • CXX: Program for compiling C++ programs; default g++
  • CFLAGS: Extra flags to give to the C compiler
  • CXXFLAGS: Extra flags to give to the C++ compiler
  • CPPFLAGS: Extra flags to give to the C preprocessor
  • LDFLAGS: Extra flags to give to compilers when they are supposed to invoke the linker

 

4 编译带头文件的程序

add.hpp

#ifndef ADD_HPP
#define ADD_HPP
int add(int a, int b);

#endif // ADD_HPP

add.cpp

int add(int a, int b)
{
    return a+b;
}

minus.hpp

#ifndef MINUS_HPP
#define MINUS_HPP
int minus(int a, int b);

#endif // MINUS_HPP

minus.cpp

int minus(int a, int b)
{
    return a-b;
}

main.cpp

#include <stdio.h>
#include "add.hpp"
#include "minus.hpp"

int main()
{
    int a=10; int b=5;
    int res = add(a, b);
    printf("a + b = %d\n", res);
    res = minus(a, b);
    printf("a - b = %d\n", res);

    return 0;
}

Makefile

cpp_srcs := $(shell find src -name *.cpp)
cpp_objs := $(patsubst src/%.cpp,objs/%.o,$(cpp_srcs))

# 你的头文件所在文件夹路径（建议绝对路径）
include_paths := 
I_flag        := $(include_paths:%=-I%)


objs/%.o : src/%.cpp
	@mkdir -p $(dir $@)
	@g++ -c $^ -o $@ $(I_flag)

workspace/exec : $(cpp_objs)
	@mkdir -p $(dir $@)
	@g++ $^ -o $@ 

run : workspace/exec
	@./$<

debug :
	@echo $(I_flag)

clean :
	@rm -rf objs

.PHONY : debug run

 

Makefile 静态库编译

1 程序

add.hpp

#ifndef ADD_HPP
#define ADD_HPP
int add(int a, int b);

#endif // ADD_HPP

add.cpp

int add(int a, int b)
{
    return a+b;
}

minus.hpp

#ifndef MINUS_HPP
#define MINUS_HPP
int minus(int a, int b);

#endif // MINUS_HPP

minus.cpp

int minus(int a, int b)
{
    return a-b;
}

main.cpp

#include <stdio.h>
#include "add.hpp"
#include "minus.hpp"

int main()
{
    int a=10; int b=5;
    int res = add(a, b);
    printf("a + b = %d\n", res);
    res = minus(a, b);
    printf("a - b = %d\n", res);

    return 0;
}

 

2 编译过程

  • 源文件[.c/cpp] -> Object文件[.o]
    g++ -c [.c/cpp][.c/cpp]... -o [.o][.o]... -I[.h/hpp] -g
  • Object文件[.o] -> 静态库文件[lib库名.a]
    ar -r [lib库名.a] [.o][.o]...
  • main 文件[.c/cpp] -> Object 文件[.o]
    g++ -c [main.c/cpp] -o [.o] -I[.h/hpp]
  • 链接 main 的 Object 文件与静态库文件 [lib库名.a]
    g++ [main.o] -o [可执行文件] -l[库名] -L[库路径]

 

动态库（共享库）

1 编库

编译 .c 文件
源文件[.c/cpp] -> Object文件[.o]

g++ -c [.c/cpp][.c/cpp]... -o [.o][.o]... -I[.h/hpp] -g -fpic

Object文件[.o] -> 动态库文件[lib库名.so]

g++ -shared [.o][.o]... -o [lib库名.so]

main文件[.c/cpp] -> Object文件[.o]

g++ -c [main.c/cpp] -o [.o] -I[.h/hpp] -g

 

2 链接

链接 main 的 Object 文件与动态库文件[lib库名.so]

g++ [main.o] -o [可执行文件] -l[库名] -L[库路径] -Wl,-rpath=[库路径]

常见 Error

*** missing separator. Stop.

  • 原因: Makefile 语法出错
  • 解决方法: 根据报错的行数，检查 tab 缩进，空格问题

*** commands commence before first target. Stop

  • 原因: if等语句里面用了 tab 缩进
  • 解决方法: 缩进的地方全部改为空格

文章转载至：https://www.bilibili.com/video/BV1EM41177s1?p=15&spm_id_from=pageDriver&vd_source=3ed107622c5e8572cd5d2d075ae86d16

侵删