CMake 保姆级教程（上）

整理自视频【CMake 保姆级教程【C/C++】】 https://www.bilibili.com/video/BV14s4y1g7Zj/?p=5&share_source=copy_web&vd_source=6eb8f46d194c5ef9f89d3331f623a9c3

1、cmake简介

源文件（.cpp / .c）要经过工具链

1.1 工具链

1、预处理：把头文件展开，宏替换，把注释去掉
得到的还是源文件

2、编译器进行编译（gcc / g++），编译完得到汇编文件

3、将汇编文件通过汇编器进行处理，就得到二进制文件（.obj (win) / .o (linux)）

4、链接器对二进制文件进行链接，打包之后生成可执行文件（也是二进制的）

5、可以把CMake看成一款自动生成 Makefile的工具，其编译流程如下图：
在这里插入图片描述

1.2 生成可执行文件

文件少可以通过命令生成可执行文件；项目多：
1）makefile，创建一个脚本文件，脚本文件名字就是makefile，在makefile里面执行一系列的指令，告诉编译器怎么编译源文件
脚本文件写好后，执行一系列的批处理命令，批处理命令就叫做make，makefile里面的若干个指令执行了 make之后就可以把 makefile里面的指令全部执行完毕，可执行程序就被构建出来了

2）cmake，不依赖于平台，根据不同的平台生成对应的 makefile脚本文件，脚本文件名字 cmakelists.txt，在这个文件里面执行一系列的指令，有了这些指令之后再执行命令 cmake，生成 makefile文件，执行了 make之后就可以把 makefile里面的指令全部执行完毕，可执行程序就被构建出来了

除了生成可执行文件还可以生成库文件，库文件有两种：动态库和静态库。库文件引入第三方项目使用（对第三方保密，使用更直观（变成库第三方直接调用））

主要聚焦 cmakelists.txt 命令怎么写，大型项目自动化管理

2、编写简单的 cmakelists.txt

2.1 安装cmake

查看是否安装cmake

cmake --version

安装cmake

sudo apt install cmake

或者

官网下载安装.tar.gz cmake v3.17
安装版本：cmake-3.17.0-rc2-Linux-x86_64（新版本无法这样安装）
解压并进入目录下bin文件（tar -zxvf），加个软链

tar -zxvf cmake-3.17.0-rc2-Linux-x86_64.tar.gz
cd cmake-3.17.0-rc2-Linux-x86_64/bin
sudo ln -s /home/名字/cmake-3.17.0-rc2-Linux-x86_64/bin/cmake /usr/bin/cmake

检验一下

./cmake -version

软连接成功
不用虚拟机也可以安装wsl解决

2.2 源文件和头文件

头文件声明，源文件具体实现，加减乘除，在main中对加减乘除函数实现了调用
add.c

#include <stdio.h>
#include "head.h"

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

sub.c

#include <stdio.h>
#include "head.h"

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

mult.c

#include <stdio.h>
#include "head.h"

int multiply(int a, int b)
{
    return a*b;
}

div.c

#include <stdio.h>
#include "head.h"

double divide(int a, int b)
{
    return (double)a/b;
}

head.h

#ifndef _HEAD_H
#define _HEAD_H
// 加法
int add(int a, int b);
// 减法
int subtract(int a, int b);
// 乘法
int multiply(int a, int b);
// 除法
double divide(int a, int b);
#endif

main.c

#include <stdio.h>
#include "head.h"

int main()
{
    int a = 20;
    int b = 12;
    printf("a = %d, b = %d\n", a, b);
    printf("a + b = %d\n", add(a, b));
    printf("a - b = %d\n", subtract(a, b));
    printf("a * b = %d\n", multiply(a, b));
    printf("a / b = %f\n", divide(a, b));
    return 0;
}

源文件比较少，可以直接使用命令进行编译
转到代码所在目录下

g++ *.cpp -o app

./app 运行
运行结果

2.3 初步使用 CMake

1、注释：
Make 使用 # 进行行注释
CMake 使用 #[[ ]] 形式进行块注释

#[[ 这是一个 CMakeLists.txt 文件。
这是一个 CMakeLists.txt 文件
这是一个 CMakeLists.txt 文件]]
cmake_minimum_required(VERSION 3.0.0)

2、创建文件 CMakeLists.txt 区分大小写

3、在创建的文件里面写命令：

cmake_minimum_required：指定使用的 cmake 的最低版本（可选，非必须，如果不加可能会有警告）

# PROJECT 指令的语法是：
project(<PROJECT-NAME> [<language-name>...])
project(<PROJECT-NAME>
       [VERSION <major>[.<minor>[.<patch>[.<tweak>]]]]
       [DESCRIPTION <project-description-string>]
       [HOMEPAGE_URL <url-string>]
       [LANGUAGES <language-name>...])

与上面的字段一一对应：定义工程名称，并可指定工程的版本、工程描述（字符串）、web主页地址、支持的语言（默认情况支持所有语言），如果不需要这些都是可以忽略的，只需要指定出工程名字即可

add_executable：定义工程会生成一个可执行程序

add_executable(可执行程序名 源文件名称)

# 样式1
add_executable(app add.cpp div.cpp main.cpp mult.cpp sub.cpp)
# 样式2
add_executable(app add.cpp; div.cpp; main.cpp; mult.cpp; sub.cpp)

这里的可执行程序名和 project中的项目名没有任何关系
源文件名可以是一个也可以是多个，如有多个可用空格或; 间隔

本次的文件：

cmake_minimum_required(VERSION 3.15) # 指定版本
project(test)                        # 指定工程名字
add_executable(app add.cpp div.cpp main.cpp mult.cpp sub.cpp) # 指定可执行程序名字以及源文件

在当前目录里面执行cmake命令，cmake后面跟上 CMakeLists.txt 所在的路径 cmake .然后会看到一系列的日志输出
生成的文件

生成了一些新的文件以及目录， app 工程文件可以执行
执行工程文件
多了一些暂时不关心的文件，可能会减慢搜索速度，可以把这些文件放到对应的编译目录
删除文件，进入创建的编译目录，再执行cmake命令（路径是CMakeLists.txt对应的路径） cmake ..

操作2
只要 MakeFile 文件生成就大功告成了
还需要执行 make命令，在build文件夹里面生成了 app工程文件
查看日志

2.4 set

1、定义变量
通过set设置变量值的时候都是字符串类型，变量名同一个文件中不能有重复
对变量进行取值：${ 变量名 }

# SET 指令的语法是：
# [] 中的参数为可选项, 如不需要可以不写
SET(VAR [VALUE] [CACHE TYPE DOCSTRING [FORCE]])
# VAR：变量名  VALUE：变量值

# 方式1: 各个源文件之间使用空格间隔
# set(SRC_LIST add.c  div.c   main.c  mult.c  sub.c)

# 方式2: 各个源文件之间使用分号 ; 间隔
set(SRC_LIST add.c;div.c;main.c;mult.c;sub.c)
add_executable(app  ${SRC_LIST})

2、指定使用的C++标准
1）在编译的时候在编译命令中制定出要使用哪个标准

$ g++ *.cpp -std=c++11 -o app

2）C++标准对应有一宏叫做CMAKE_CXX_STANDARD。在CMake中想要指定C++标准有两种方式：
CMakeLists.txt 中通过 set 命令指定

#增加-std=c++11
set(CMAKE_CXX_STANDARD 11)

在执行 cmake 命令的时候指定出这个宏的值

#增加-std=c++11，-D就是制定一个宏
cmake CMakeLists.txt文件路径 -DCMAKE_CXX_STANDARD=11

3、指定输出的路径
在CMake中指定可执行程序输出的路径，也对应一个宏，叫做EXECUTABLE_OUTPUT_PATH，它的值还是通过set命令进行设置

set(HOME /home/robin/Linux/Sort)
set(EXECUTABLE_OUTPUT_PATH ${HOME}/bin)

指定输出路径时要使用绝对路径，因为如果此处指定可执行程序生成路径的时候使用的是相对路径 ./xxx/xxx，那么这个路径中的 ./ 对应的就是 makefile 文件所在的那个目录

除了给可执行程序指定路径，还可以给动态库指定路径

如果这个路径中的子目录不存在，会自动生成，无需自己手动创建

4、例子
CMakeLists.txt

cmake_minimum_required(VERSION 3.15) # 指定版本
project(test)                        # 指定工程名字
set(SRC add.cpp div.cpp main.cpp mult.cpp sub.cpp)
set(EXECUTABLE_OUTPUT_PATH /home/ashergu/vscode_workpace/cmake_v1/out)
set(CMAKE_CXX_STANDARD 11)
add_executable(app ${SRC}) # 指定可执行程序名字以及源文件

运行结果
在这里插入图片描述

cmake命令是在build目录中执行的，但是CMakeLists.txt文件是build目录的上一级目录中，所以cmake 命令后指定的路径为…，即当前目录的上一级目录
当命令执行完毕之后，在build目录中会生成一个makefile文件
这样就可以在build目录中执行make命令编译项目，生成的相关文件自然也就被存储到build目录中了。这样通过cmake和make生成的所有文件就全部和项目源文件隔离开了

使用cmake命令时要保证上级目录里面不能有之前执行cmake命令生成的文件，不然就不会生成新的文件了
给对应的宏设置值，宏不一样，对应的功能也就不一样

3、搜索文件

1、如果一个项目里边的源文件很多，在编写CMakeLists.txt文件的时候不可能将项目目录的各个文件一一罗列出来，在CMake中为提供了搜索相应目录文件的命令，可以使用aux_source_directory命令或者file命令

2、这个变量是不需要提前定义的，使用时只要把名字指定到参数位置就行了，命令执行完之后，这个名字对应的变量也就初始化完成了

3.1 方式一：aux_source_directory

1、可以查找某个路径下的所有源文件（包括.c / .cpp）

aux_source_directory(< dir > < variable >)

dir：要搜索的目录（可以指定字符串（不需要加" "）或者可以通过宏来进行指定）
宏有两个（宏存储的值相同）：
1）PROJECT_SOURCE_DIR：对应cmake命令后面跟随的路径（就是CMakeLists.txt文件所在的路径），有两个文件路径，可以写两个PROJECT_SOURCE_DIR，然后通过set进行合并 set(a, a, b) 把a，b全部放进a中
2）CMAKE_CURRENT_SOURCE_DIR：宏表示当前访问的 CMakeLists.txt 文件所在的路径

variable：将从dir目录下搜索到的源文件列表存储到该变量中

CMakeLists.txt

cmake_minimum_required(VERSION 3.0)
project(CALC)
include_directories(${PROJECT_SOURCE_DIR}/include)
# 搜索 src 目录下的源文件
aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/src SRC_LIST)
add_executable(app  ${SRC_LIST})

cmake生成了MakeFile文件，只要make就行了
CMakeLists.txt

cmake_minimum_required(VERSION 3.15) # 指定版本
project(test)                        # 指定工程名字
# set(SRC add.cpp div.cpp main.cpp mult.cpp sub.cpp)
aux_source_directory(${PROJECT_SOURCE_DIR} SRC)
set(EXECUTABLE_OUTPUT_PATH /home/ashergu/vscode_workpace/cmake_v1/out)
set(CMAKE_CXX_STANDARD 11)
add_executable(app ${SRC}) # 指定可执行程序名字以及源文件

运行结果
在这里插入图片描述

3.2 方式二：file

file(GLOB/GLOB_RECURSE 变量名 要搜索的文件路径和文件类型)

GLOB: 将指定目录下搜索到的满足条件的所有文件名生成一个列表，并将其存储到变量中。
GLOB_RECURSE：递归搜索指定目录，将搜索到的满足条件的文件名生成一个列表，并将其存储到变量中。

搜索当前目录的src目录下所有的源文件，并存储到变量中

file(GLOB MAIN_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
file(GLOB MAIN_HEAD ${CMAKE_CURRENT_SOURCE_DIR}/include/*.h)

关于要搜索的文件路径和类型可加双引号，也可不加:

file(GLOB MAIN_HEAD "${CMAKE_CURRENT_SOURCE_DIR}/src/*.h")

CMakeLists.txt

cmake_minimum_required(VERSION 3.15) # 指定版本
project(test)                        # 指定工程名字
# set(SRC add.cpp div.cpp main.cpp mult.cpp sub.cpp)
# aux_source_directory(${PROJECT_SOURCE_DIR} SRC)
file(GLOB SRC ${CMAKE_CURRENT_SOURCE_DIR})
set(EXECUTABLE_OUTPUT_PATH /home/ashergu/vscode_workpace/cmake_v1/out)
set(CMAKE_CXX_STANDARD 11)
add_executable(app ${SRC}) # 指定可执行程序名字以及源文件

运行结果
在这里插入图片描述

4、包含头文件

1、头文件和源文件不在一个目录内：把源文件放在src目录中，头文件放在include目录中
在这里插入图片描述
基于脚本文件（CMakeLists.txt）来编译src里面的源文件最终生成可执行程序
更改目录并构建

将源文件对应的头文件路径指定出来

#include "head.h" // 相当于在./head.h

include_directories(headpath) // 参数是头文件对应的目录，建议使用绝对路径

在这里插入图片描述

5、制作动态库或静态库

有些时候我们编写的源代码并不需要将他们编译生成可执行程序，而是生成一些库文件（包括静态库或动态库）提供给第三方使用

先复制一份
在这里插入图片描述
制作库就不需要main.cpp了，主要是用来测试的，把main.cpp移动出来

5.1 制作静态库

add_library(库名称 STATIC 源文件1 [源文件2] ...)

在Linux中，静态库名字分为三部分：lib+库名字+.a（windows中是.lib），此处只需要指定出库的名字就可以了，另外两部分在生成该文件的时候会自动填充

工程名字需要跟之前不同，cmake和make之后

CMakeLists.txt

cmake_minimum_required(VERSION 3.0)
project(CALC)
include_directories(${PROJECT_SOURCE_DIR}/include)
file(GLOB SRC_LIST "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp")
add_library(calc STATIC ${SRC_LIST})

最终就会生成对应的静态库文件libcalc.a，没有可执行权限
在这里插入图片描述

5.2 制作动态库

add_library(库名称 SHARED 源文件1 [源文件2] ...)

就后缀名称变了（linux中为.so，Windows中为.dll），动态库有另一个名字共享库，所以参数改为 SHARED（唯一改动）

cmake_minimum_required(VERSION 3.15) # 指定版本
project(test2)                        # 指定工程名字
# set(SRC add.cpp div.cpp main.cpp mult.cpp sub.cpp)
# aux_source_directory(${PROJECT_SOURCE_DIR} SRC)
file(GLOB SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
set(EXECUTABLE_OUTPUT_PATH /home/ashergu/vscode_workpace/cmake_v1/out)
set(CMAKE_CXX_STANDARD 11)
include_directories(${PROJECT_SOURCE_DIR}/include)
# add_executable(app ${SRC}) # 指定可执行程序名字以及源文件
add_library(calc SHARED ${SRC})

动态库有可执行权限，所以是绿色
在这里插入图片描述
发布给使用者时，除了库文件之外，还需要对应的头文件
不论静态库还是动态库都是源代码，只不过是二进制的（.cpp源代码是文本格式的）

5.3 指定输出的路径

1、适用于动态库：
由于在Linux下生成的动态库默认是有执行权限的，所以可以按照生成可执行程序的方式去指定它生成的目录

set(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/lib)

对于这种方式来说，其实就是通过set命令给EXECUTABLE_OUTPUT_PATH宏设置了一个路径，这个路径就是可执行文件生成的路径

2、都适用：使用LIBRARY_OUTPUT_PATH，这个宏对应静态库文件和动态库文件都适用

# 设置动态库/静态库生成路径
set(LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/lib)

6、Linux 静态库和动态库

整理自 https://subingwen.cn/linux/library/

1、不管是Linux还是Windows中的库文件其本质和工作模式都是相同的, 只不过在不同的平台上库对应的文件格式和文件后缀不同。程序中调用的库有两种静态库和动态库，不管是哪种库文件本质是还是源文件

2、使用库一般有两个目的，一个是为了使程序更加简洁不需要在项目中维护太多的源文件，另一方面是为了源代码保密

3、拿到了库文件（动态库、静态库）之后要想使用还必须有这些库中提供的API函数的声明，也就是头文件，把这些都添加到项目中

6.1 生成静态链接库

在Linux中静态库由程序 ar 生成，以lib作为前缀, 以.a作为后缀, 中间是库的名字自己指定

1、生成静态库，需要先对源文件进行汇编操作 (使用参数 -c) 得到二进制格式的目标文件 (.o 格式), 然后在通过 ar工具将目标文件打包就可以得到静态库文件了 (libxxx.a)

参数c：创建一个库，不管库是否存在，都将创建。
参数s：创建目标文件索引，这在创建较大的库时能加快时间。
参数r：在库中插入模块(替换)。默认新的成员添加在库的结尾处，如果模块名已经在库中存在，则替换同名的模块

在这里插入图片描述

2、具体步骤：
1、第一步: 将源文件add.c, div.c, mult.c, sub.c 进行汇编, 得到二进制目标文件 add.o, div.o, mult.o, sub.o

# 1. 生成.o
$ gcc add.c div.c mult.c sub.c -c
sub.c:2:18: fatal error: head.h: No such file or directory
compilation terminated.

# 提示头文件找不到, 添加参数 -I 重新头文件路径即可
$ gcc add.c div.c mult.c sub.c -c -I ./include/

# 查看目标文件是否已经生成
$ tree
.
├── add.c
├── add.o            # 目标文件
├── div.c
├── div.o            # 目标文件
├── include
│   └── head.h
├── main.c
├── mult.c
├── mult.o           # 目标文件
├── sub.c
└── sub.o            # 目标文件

2、第二步: 将生成的目标文件通过 ar工具打包生成静态库

# 2. 将生成的目标文件 .o 打包成静态库
$ ar rcs libcalc.a a.o b.o c.o    # a.o b.o c.o在同一个目录中可以写成 *.o

# 查看目录中的文件
$ tree
.
├── add.c
├── add.o
├── div.c
├── div.o
├── include
│   └── `head.h  ===> 和静态库一并发布
├── `libcalc.a   ===> 生成的静态库
├── main.c
├── mult.c
├── mult.o
├── sub.c
└── sub.o

3、第三步: 将生成的的静态库 libcalc.a和库对应的头文件head.h一并发布给使用者就可以了

# 3. 发布静态库
	1. head.h    => 函数声明
	2. libcalc.a => 函数定义(二进制格式)

6.2 静态库的使用

# 1. 首先拿到了发布的静态库
	`head.h` 和 `libcalc.a`
	
# 2. 将静态库, 头文件, 测试程序放到一个目录中准备进行测试
.
├── head.h          # 函数声明
├── libcalc.a       # 函数定义（二进制格式）
└── main.c          # 函数测试

编译测试程序, 得到可执行文件

在编译的时将静态库的路径和名字都指定出来
-L: 指定库所在的目录(相对或者绝对路径)
-l: 指定库的名字, 需要掐头(lib)去尾(.a) 剩下的才是需要的静态库的名字

# 4. 编译的时候指定库信息
	-L: 指定库所在的目录(相对或者绝对路径)
	-l: 指定库的名字, 掐头(lib)去尾(.a) ==> calc
# -L -l, 参数和参数值之间可以有空格, 也可以没有  -L./ -lcalc
$ gcc main.c -o app -L ./ -l calc

# 查看目录信息, 发现可执行程序已经生成了
$ tree
.
├── app   		# 生成的可执行程序
├── head.h
├── libcalc.a
└── main.c

编译的源文件中包含了头文件 head.h, 这个头文件中声明的函数对应的定义（也就是函数体实现）在静态库中，程序在编译的时候没有找到函数实现

6.3 生成动态链接库

动态链接库是程序运行时加载的库，当动态链接库正确部署之后，运行的多个程序可以使用同一个加载到内存中的动态库，因此在Linux中动态链接库也可称之为共享库

动态链接库是目标文件的集合，目标文件在动态链接库中的组织方式是按照特殊方式形成的。库中函数和变量的地址使用的是相对地址（静态库中使用的是绝对地址），其真实地址是在应用程序加载动态库时形成的

在Linux中动态库以lib作为前缀, 以.so作为后缀, 中间是库的名字自己指定即可, 即: libxxx.so

1、生成动态链接库是直接使用gcc命令并且需要添加-fPIC（-fpic）以及-shared 参数

-fPIC 或 -fpic 参数的作用是使得 gcc 生成的代码是与位置无关的，也就是使用相对位置。
-shared参数的作用是告诉编译器生成一个动态链接库
在这里插入图片描述
2、生成动态链接库的具体步骤如下:
1）将源文件进行汇编操作, 需要使用参数 -c, 还需要添加额外参数 -fpic / -fPIC

# 得到若干个 .o文件
$ gcc 源文件(*.c) -c -fpic

2）将得到的.o文件打包成动态库, 还是使用gcc, 使用参数 -shared 指定生成动态库(位置没有要求)

$ gcc -shared 与位置无关的目标文件(*.o) -o 动态库(libxxx.so)

3）发布动态库和头文件

# 发布
 	1. 提供头文件: xxx.h
 	2. 提供动态库: libxxx.so

第一步: 使用gcc将源文件进行汇编(参数-c), 生成与位置无关的目标文件, 需要使用参数 -fpic或者-fPIC
在这里插入图片描述

第二步: 使用gcc将得到的目标文件打包生成动态库, 需要使用参数 -shared
在这里插入图片描述

第三步: 发布生成的动态库和相关的头文件

head.h
libcalc.so

6.4 动态库的使用

1、拿到发布的动态库
head.h libcalc.so

2、基于头文件编写测试程序, 测试动态库中提供的接口是否可用
main.cpp

include <stdio.h>
#include "head.h"

int main()
{
    int a = 20;
    int b = 12;
    printf("a = %d, b = %d\n", a, b);
    printf("a + b = %d\n", add(a, b));
    printf("a - b = %d\n", subtract(a, b));
    printf("a * b = %d\n", multiply(a, b));
    printf("a / b = %f\n", divide(a, b));
    return 0;
}

.
├── head.h          ==> 函数声明
├── libcalc.so      ==> 函数定义
└── main.c          ==> 函数测试

和使用静态库一样, 在编译的时候需要指定库相关的信息: 库的路径 -L和库的名字 -l
在编译的时候指定动态库相关的信息: 库的路径 -L, 库的名字 -l

在这里插入图片描述
执行生成的可执行程序, 错误提示：可执行程序执行的时候找不到动态库