CMake 基本用法与简单介绍#

1、基本介绍#

CMake 是一个项目构建工具，并且是跨平台的。关于项目构建我们所熟知的还有Makefile（通过 make 命令进行项目的构建），大多是IDE软件都集成了make，比如：VS 的 nmake、linux 下的 GNU make、Qt 的 qmake等，如果自己动手写 makefile，会发现，makefile 通常依赖于当前的编译平台，而且编写 makefile 的工作量比较大，解决依赖关系时也容易出错。

而 CMake 恰好能解决上述问题，其允许开发者指定整个工程的编译流程，在根据编译平台，自动生成本地化的Makefile和工程文件，最后用户只需make编译即可，所以可以把CMake看成一款自动生成 Makefile的工具，其编译流程如下图：

Image 1: image-20230309130644912

蓝色虚线表示使用makefile构建项目的过程
红色实线表示使用cmake构建项目的过程

介绍完CMake的作用之后，再来总结一下它的优点：

跨平台
能够管理大型项目
简化编译构建过程和编译过程
可扩展：可以为 cmake 编写特定功能的模块，扩充 cmake 功能

2. CMake的使用#

CMake支持大写、小写、混合大小写的命令。如果在编写CMakeLists.txt文件时使用的工具有对应的命令提示，那么大小写随缘即可，不要太过在意。

2.1 注释#

2.1.1 注释行#

CMake 使用 # 进行行注释，可以放在任何位置。

1
cmake_minimum_required(VERSION 3.0.0)

2.1.2 注释块#

CMake 使用 #[[ ]] 形式进行块注释。

1
cmake_minimum_required(VERSION 3.0.0)

2.1 只有源文件#

2.1.1 共处一室#

准备工作，为了方便测试，在我本地电脑准备了这么几个测试文件

add.c

1
#include <stdio.h>
2
#include "head.h"
3

4
int add(int a, int b)
5
{
6
    return a+b;
7
}

sub.c

1
#include <stdio.h>
2
#include "head.h"
3

4

5
int subtract(int a, int b)
6
{
7
    return a-b;
8
}

mult.c

1
#include <stdio.h>
2
#include "head.h"
3

4
int multiply(int a, int b)
5
{
6
    return a*b;
7
}

div.c

1
#include <stdio.h>
2
#include "head.h"
3

4
double divide(int a, int b)
5
{
6
    return (double)a/b;
7
}

head.h

1
#ifndef _HEAD_H
2
#define _HEAD_H
3

4
int add(int a, int b);
5

6
int subtract(int a, int b);
7

8
int multiply(int a, int b);
9

10
double divide(int a, int b);
11
#endif

main.c

1
#include <stdio.h>
2
#include "head.h"
3

4
int main()
5
{
6
    int a = 20;
7
    int b = 12;
8
    printf("a = %d, b = %d\n", a, b);
9
    printf("a + b = %d\n", add(a, b));
10
    printf("a - b = %d\n", subtract(a, b));
11
    printf("a * b = %d\n", multiply(a, b));
12
    printf("a / b = %f\n", divide(a, b));
13
    return 0;
14
}

上述文件的目录结构如下：

1
$ tree
2
.
3
├── add.c
4
├── div.c
5
├── head.h
6
├── main.c
7
├── mult.c
8
└── sub.c

添加 CMakeLists.txt 文件

在上述源文件所在目录下添加一个新文件 CMakeLists.txt，文件内容如下：
```
1
cmake_minimum_required(VERSION 3.0)
2
project(CALC)
3
add_executable(app add.c div.c main.c mult.c sub.c)
```
接下来依次介绍一下在 CMakeLists.txt 文件中添加的三个命令:
- cmake_minimum_required：指定使用的 cmake 的最低版本
  - 可选，非必须，如果不加可能会有警告
- project：定义工程名称，并可指定工程的版本、工程描述、web主页地址、支持的语言（默认情况支持所有语言），如果不需要这些都是可以忽略的，只需要指定出工程名字即可。
```
1
project(<PROJECT-NAME> [<language-name>...])
2
project(<PROJECT-NAME>
3
       [VERSION <major>[.<minor>[.<patch>[.<tweak>]]]]
4
       [DESCRIPTION <project-description-string>]
5
       [HOMEPAGE_URL <url-string>]
6
       [LANGUAGES <language-name>...])
```
- add_executable：定义工程会生成一个可执行程序
```
1
add_executable(可执行程序名 源文件名称)
```
  - 这里的可执行程序名和project中的项目名没有任何关系
  - 源文件名可以是一个也可以是多个，如有多个可用空格或;间隔
    1 add_executable(app add.c div.c main.c mult.c sub.c) 2 3 add_executable(app add.c;div.c;main.c;mult.c;sub.c)

执行CMake 命令

万事俱备只欠东风，将 CMakeLists.txt 文件编辑好之后，就可以执行 cmake命令了。

1
# cmake 命令原型
2
$ cmake CMakeLists.txt文件所在路径

1
$ tree
2
.
3
├── add.c
4
├── CMakeLists.txt
5
├── div.c
6
├── head.h
7
├── main.c
8
├── mult.c
9
└── sub.c
10

11
0 directories, 7 files
12
robin@OS:~/Linux/3Day/calc$ cmake .

当执行cmake命令之后，CMakeLists.txt 中的命令就会被执行，所以一定要注意给cmake 命令指定路径的时候一定不能出错。

执行命令之后，看一下源文件所在目录中是否多了一些文件：

1
$ tree -L 1
2
.
3
├── add.c
4
├── CMakeCache.txt         # new add file
5
├── CMakeFiles             # new add dir
6
├── cmake_install.cmake    # new add file
7
├── CMakeLists.txt
8
├── div.c
9
├── head.h
10
├── main.c
11
├── Makefile               # new add file
12
├── mult.c
13
└── sub.c

我们可以看到在对应的目录下生成了一个makefile文件，此时再执行make命令，就可以对项目进行构建得到所需的可执行程序了。

1
$ make
2
Scanning dependencies of target app
3
[ 16%] Building C object CMakeFiles/app.dir/add.c.o
4
[ 33%] Building C object CMakeFiles/app.dir/div.c.o
5
[ 50%] Building C object CMakeFiles/app.dir/main.c.o
6
[ 66%] Building C object CMakeFiles/app.dir/mult.c.o
7
[ 83%] Building C object CMakeFiles/app.dir/sub.c.o
8
[100%] Linking C executable app
9
[100%] Built target app
10

11
# 查看可执行程序是否已经生成
12
$ tree -L 1
13
.
14
├── add.c
15
├── app          # 生成的可执行程序
16
├── CMakeCache.txt
17
├── CMakeFiles
18
├── cmake_install.cmake
19
├── CMakeLists.txt
20
├── div.c
21
├── head.h
22
├── main.c
23
├── Makefile
24
├── mult.c
25
└── sub.c

最终可执行程序app就被编译出来了（这个名字是在CMakeLists.txt中指定的）。

2.1.2 VIP 包房#

通过上面的例子可以看出，如果在CMakeLists.txt文件所在目录执行了cmake命令之后就会生成一些目录和文件（包括 makefile 文件），如果再基于makefile文件执行make命令，程序在编译过程中还会生成一些中间文件和一个可执行文件，这样会导致整个项目目录看起来很混乱，不太容易管理和维护，此时我们就可以把生成的这些与项目源码无关的文件统一放到一个对应的目录里边，比如将这个目录命名为build:

1
$ mkdir build
2
$ cd build
3
$ cmake ..
4
-- The C compiler identification is GNU 5.4.0
5
-- The CXX compiler identification is GNU 5.4.0
6
-- Check for working C compiler: /usr/bin/cc
7
-- Check for working C compiler: /usr/bin/cc -- works
8
-- Detecting C compiler ABI info
9
-- Detecting C compiler ABI info - done
10
-- Detecting C compile features
11
-- Detecting C compile features - done
12
-- Check for working CXX compiler: /usr/bin/c++
13
-- Check for working CXX compiler: /usr/bin/c++ -- works
14
-- Detecting CXX compiler ABI info
15
-- Detecting CXX compiler ABI info - done
16
-- Detecting CXX compile features
17
-- Detecting CXX compile features - done
18
-- Configuring done
19
-- Generating done
20
-- Build files have been written to: /home/robin/Linux/build

现在cmake命令是在build目录中执行的，但是CMakeLists.txt文件是build目录的上一级目录中，所以cmake 命令后指定的路径为..，即当前目录的上一级目录。

当命令执行完毕之后，在build目录中会生成一个makefile文件

1
$ tree build -L 1
2
build
3
├── CMakeCache.txt
4
├── CMakeFiles
5
├── cmake_install.cmake
6
└── Makefile
7

8
1 directory, 3 files

这样就可以在build目录中执行make命令编译项目，生成的相关文件自然也就被存储到build目录中了。这样通过cmake和make生成的所有文件就全部和项目源文件隔离开了，各回各家，各找各妈。

2.2 私人订制#

2.2.1 定义变量#

在上面的例子中一共提供了5个源文件，假设这五个源文件需要反复被使用，每次都直接将它们的名字写出来确实是很麻烦，此时我们就需要定义一个变量，将文件名对应的字符串存储起来，在cmake里定义变量需要使用set。

1
SET(VAR [VALUE] [CACHE TYPE DOCSTRING [FORCE]])

VAR：变量名
VALUE：变量值

1
set(SRC_LIST add.c;div.c;main.c;mult.c;sub.c)
2
add_executable(app  ${SRC_LIST})

2.2.2 指定使用的C++标准#

在编写C++程序的时候，可能会用到C++11、C++14、C++17、C++20等新特性，那么就需要在编译的时候在编译命令中制定出要使用哪个标准：

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

上面的例子中通过参数-std=c++11指定出要使用c++11标准编译程序，C++标准对应有一宏叫做DCMAKE_CXX_STANDARD。在CMake中想要指定C++标准有两种方式：

在 CMakeLists.txt 中通过 set 命令指定

1
set(CMAKE_CXX_STANDARD 11)
2

3
set(CMAKE_CXX_STANDARD 14)
4

5
set(CMAKE_CXX_STANDARD 17)

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

1
#增加-std=c++11
2
cmake CMakeLists.txt文件路径 -DCMAKE_CXX_STANDARD=11
3
#增加-std=c++14
4
cmake CMakeLists.txt文件路径 -DCMAKE_CXX_STANDARD=14
5
#增加-std=c++17
6
cmake CMakeLists.txt文件路径 -DCMAKE_CXX_STANDARD=17

在上面例子中 CMake 后的路径需要根据实际情况酌情修改。

2.2.3 指定输出的路径#

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

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

第一行：定义一个变量用于存储一个绝对路径
第二行：将拼接好的路径值设置给EXECUTABLE_OUTPUT_PATH宏
- 如果这个路径中的子目录不存在，会自动生成，无需自己手动创建

由于可执行程序是基于 cmake 命令生成的 makefile 文件然后再执行 make 命令得到的，所以如果此处指定可执行程序生成路径的时候使用的是相对路径 ./xxx/xxx，那么这个路径中的 ./ 对应的就是 makefile 文件所在的那个目录。

2.3 搜索文件#

如果一个项目里边的源文件很多，在编写CMakeLists.txt文件的时候不可能将项目目录的各个文件一一罗列出来，这样太麻烦也不现实。所以，在CMake中为我们提供了搜索文件的命令，可以使用aux_source_directory命令或者file命令。

2.3.1 方式1#

在 CMake 中使用aux_source_directory 命令可以查找某个路径下的所有源文件，命令格式为：

1
aux_source_directory(< dir > < variable >)

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

1
cmake_minimum_required(VERSION 3.0)
2
project(CALC)
3
include_directories(${PROJECT_SOURCE_DIR}/include)
4

5
aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/src SRC_LIST)
6
add_executable(app  ${SRC_LIST})

2.3.2 方式2#

如果一个项目里边的源文件很多，在编写CMakeLists.txt文件的时候不可能将项目目录的各个文件一一罗列出来，这样太麻烦了。所以，在CMake中为我们提供了搜索文件的命令，他就是file（当然，除了搜索以外通过 file 还可以做其他事情）。

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

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

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

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

CMAKE_CURRENT_SOURCE_DIR 宏表示当前访问的 CMakeLists.txt 文件所在的路径。
关于要搜索的文件路径和类型可加双引号，也可不加:
```
1
file(GLOB MAIN_HEAD "${CMAKE_CURRENT_SOURCE_DIR}/src/*.h")
```

2.4 包含头文件#

在编译项目源文件的时候，很多时候都需要将源文件对应的头文件路径指定出来，这样才能保证在编译过程中编译器能够找到这些头文件，并顺利通过编译。在CMake中设置要包含的目录也很简单，通过一个命令就可以搞定了，他就是include_directories:

1
include_directories(headpath)

举例说明，有源文件若干，其目录结构如下：

1
$ tree
2
.
3
├── build
4
├── CMakeLists.txt
5
├── include
6
│   └── head.h
7
└── src
8
    ├── add.cpp
9
    ├── div.cpp
10
    ├── main.cpp
11
    ├── mult.cpp
12
    └── sub.cpp
13

14
3 directories, 7 files

CMakeLists.txt文件内容如下:

1
cmake_minimum_required(VERSION 3.0)
2
project(CALC)
3
set(CMAKE_CXX_STANDARD 11)
4
set(HOME /home/robin/Linux/calc)
5
set(EXECUTABLE_OUTPUT_PATH ${HOME}/bin/)
6
include_directories(${PROJECT_SOURCE_DIR}/include)
7
file(GLOB SRC_LIST ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
8
add_executable(app  ${SRC_LIST})

其中，第六行指定就是头文件的路径，PROJECT_SOURCE_DIR宏对应的值就是我们在使用cmake命令时，后面紧跟的目录，一般是工程的根目录。

2.5 制作动态库或静态库#

有些时候我们编写的源代码并不需要将他们编译生成可执行程序，而是生成一些静态库或动态库提供给第三方使用，下面来讲解在cmake中生成这两类库文件的方法。

2.5.1 制作静态库#

在cmake中，如果要制作静态库，需要使用的命令如下：

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

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

在Windows中虽然库名和Linux格式不同，但也只需指定出名字即可。

下面有一个目录，需要将src目录中的源文件编译成静态库，然后再使用：

1
.
2
├── build
3
├── CMakeLists.txt
4
├── include           # 头文件目录
5
│   └── head.h
6
├── main.cpp          # 用于测试的源文件
7
└── src               # 源文件目录
8
    ├── add.cpp
9
    ├── div.cpp
10
    ├── mult.cpp
11
    └── sub.cpp

根据上面的目录结构，可以这样编写CMakeLists.txt文件:

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

这样最终就会生成对应的静态库文件libcalc.a。

2.5.2 制作动态库#

在cmake中，如果要制作动态库，需要使用的命令如下：

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

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

在Windows中虽然库名和Linux格式不同，但也只需指定出名字即可。

根据上面的目录结构，可以这样编写CMakeLists.txt文件:

1
cmake_minimum_required(VERSION 3.0)
2
project(CALC)
3
include_directories(${PROJECT_SOURCE_DIR}/include)
4
file(GLOB SRC_LIST "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp")
5
add_library(calc SHARED ${SRC_LIST})

这样最终就会生成对应的动态库文件libcalc.so。

2.5.3 指定输出的路径#

方式1 - 适用于动态库#

对于生成的库文件来说和可执行程序一样都可以指定输出路径。由于在Linux下生成的动态库默认是有执行权限的，所以可以按照生成可执行程序的方式去指定它生成的目录：

1
cmake_minimum_required(VERSION 3.0)
2
project(CALC)
3
include_directories(${PROJECT_SOURCE_DIR}/include)
4
file(GLOB SRC_LIST "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp")
5

6
set(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/lib)
7
add_library(calc SHARED ${SRC_LIST})

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

方式2 - 都适用#

由于在Linux下生成的静态库默认不具有可执行权限，所以在指定静态库生成的路径的时候就不能使用EXECUTABLE_OUTPUT_PATH宏了，而应该使用LIBRARY_OUTPUT_PATH，这个宏对应静态库文件和动态库文件都适用。

1
cmake_minimum_required(VERSION 3.0)
2
project(CALC)
3
include_directories(${PROJECT_SOURCE_DIR}/include)
4
file(GLOB SRC_LIST "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp")
5

6
set(LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/lib)
7

8

9

10
add_library(calc STATIC ${SRC_LIST})

2.6 包含库文件#

在编写程序的过程中，可能会用到一些系统提供的动态库或者自己制作出的动态库或者静态库文件，cmake中也为我们提供了相关的加载动态库的命令。

2.6.1 链接静态库#

1
src
2
├── add.cpp
3
├── div.cpp
4
├── main.cpp
5
├── mult.cpp
6
└── sub.cpp

现在我们把上面src目录中的add.cpp、div.cpp、mult.cpp、sub.cpp编译成一个静态库文件libcalc.a。通过命令制作并使用静态链接库

测试目录结构如下：

1
$ tree
2
.
3
├── build
4
├── CMakeLists.txt
5
├── include
6
│   └── head.h
7
├── lib
8
│   └── libcalc.a     # 制作出的静态库的名字
9
└── src
10
    └── main.cpp
11

12
4 directories, 4 files

在cmake中，链接静态库的命令如下：

1
link_libraries(<static lib> [<static lib>...])

参数1：指定出要链接的静态库的名字
- 可以是全名 libxxx.a
- 也可以是掐头（lib）去尾（.a）之后的名字 xxx
参数2-N：要链接的其它静态库的名字

如果该静态库不是系统提供的（自己制作或者使用第三方提供的静态库）可能出现静态库找不到的情况，此时可以将静态库的路径也指定出来：

1
link_directories(<lib path>)

这样，修改之后的CMakeLists.txt文件内容如下:

1
cmake_minimum_required(VERSION 3.0)
2
project(CALC)
3

4
file(GLOB SRC_LIST ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
5

6
include_directories(${PROJECT_SOURCE_DIR}/include)
7

8
link_directories(${PROJECT_SOURCE_DIR}/lib)
9

10
link_libraries(calc)
11
add_executable(app ${SRC_LIST})

添加了第8行的代码，就可以根据参数指定的路径找到这个静态库了。

2.6.2 链接动态库#

在程序编写过程中，除了在项目中引入静态库，好多时候也会使用一些标准的或者第三方提供的一些动态库，关于动态库的制作、使用以及在内存中的加载方式和静态库都是不同的，在此不再过多赘述，如有疑惑请参考Linux 静态库和动态库

在cmake中链接动态库的命令如下:

1
target_link_libraries(
2
    <target>
3
    <PRIVATE|PUBLIC|INTERFACE> <item>...
4
    [<PRIVATE|PUBLIC|INTERFACE> <item>...]...)

target：指定要加载动态库的文件的名字
- 该文件可能是一个源文件
- 该文件可能是一个动态库文件
- 该文件可能是一个可执行文件
PRIVATE|PUBLIC|INTERFACE：动态库的访问权限，默认为PUBLIC
- 如果各个动态库之间没有依赖关系，无需做任何设置，三者没有没有区别，一般无需指定，使用默认的 PUBLIC 即可。
- 动态库的链接具有传递性，如果动态库 A 链接了动态库B、C，动态库D链接了动态库A，此时动态库D相当于也链接了动态库B、C，并可以使用动态库B、C中定义的方法。
```
1
target_link_libraries(A B C)
2
target_link_libraries(D A)
```
  - PUBLIC：在public后面的库会被Link到前面的target中，并且里面的符号也会被导出，提供给第三方使用。
  - PRIVATE：在private后面的库仅被link到前面的target中，并且终结掉，第三方不能感知你调了啥库
  - INTERFACE：在interface后面引入的库不会被链接到前面的target中，只会导出符号。

链接系统动态库#

动态库的链接和静态库是完全不同的：

静态库会在生成可执行程序的链接阶段被打包到可执行程序中，所以可执行程序启动，静态库就被加载到内存中了。
动态库在生成可执行程序的链接阶段不会被打包到可执行程序中，当可执行程序被启动并且调用了动态库中的函数的时候，动态库才会被加载到内存

因此，在cmake中指定要链接的动态库的时候，应该将命令写到生成了可执行文件之后：

1
cmake_minimum_required(VERSION 3.0)
2
project(TEST)
3
file(GLOB SRC_LIST ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
4

5
add_executable(app ${SRC_LIST})
6

7
target_link_libraries(app pthread)

在target_link_libraries(app pthread)中：

app: 对应的是最终生成的可执行程序的名字
pthread：这是可执行程序要加载的动态库，这个库是系统提供的线程库，全名为libpthread.so，在指定的时候一般会掐头（lib）去尾（.so）。

链接第三方动态库#

现在，自己生成了一个动态库，对应的目录结构如下：

1
$ tree
2
.
3
├── build
4
├── CMakeLists.txt
5
├── include
6
│   └── head.h            # 动态库对应的头文件
7
├── lib
8
│   └── libcalc.so        # 自己制作的动态库文件
9
└── main.cpp              # 测试用的源文件
10

11
3 directories, 4 files

假设在测试文件main.cpp中既使用了自己制作的动态库libcalc.so又使用了系统提供的线程库，此时CMakeLists.txt文件可以这样写：

1
cmake_minimum_required(VERSION 3.0)
2
project(TEST)
3
file(GLOB SRC_LIST ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
4
include_directories(${PROJECT_SOURCE_DIR}/include)
5
add_executable(app ${SRC_LIST})
6
target_link_libraries(app pthread calc)

在第六行中，pthread、calc都是可执行程序app要链接的动态库的名字。当可执行程序app生成之后并执行该文件，会提示有如下错误信息：

1
$ ./app
2
./app: error while loading shared libraries: libcalc.so: cannot open shared object file: No such file or directory

这是因为可执行程序启动之后，去加载calc这个动态库，但是不知道这个动态库被放到了什么位置解决动态库无法加载的问题，所以就加载失败了，在 CMake 中可以在生成可执行程序之前，通过命令指定出要链接的动态库的位置，指定静态库位置使用的也是这个命令：

1
link_directories(path)

所以修改之后的CMakeLists.txt文件应该是这样的：

1
cmake_minimum_required(VERSION 3.0)
2
project(TEST)
3
file(GLOB SRC_LIST ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
4

5
include_directories(${PROJECT_SOURCE_DIR}/include)
6

7
link_directories(${PROJECT_SOURCE_DIR}/lib)
8

9
add_executable(app ${SRC_LIST})
10

11
target_link_libraries(app pthread calc)

通过link_directories指定了动态库的路径之后，在执行生成的可执行程序的时候，就不会出现找不到动态库的问题了。

温馨提示：使用 target_link_libraries 命令就可以链接动态库，也可以链接静态库文件。

2.7 日志#

在CMake中可以用用户显示一条消息，该命令的名字为message：

1
message([STATUS|WARNING|AUTHOR_WARNING|FATAL_ERROR|SEND_ERROR] "message to display" ...)

(无) ：重要消息
STATUS ：非重要消息
WARNING：CMake 警告, 会继续执行
AUTHOR_WARNING：CMake 警告 (dev), 会继续执行
SEND_ERROR：CMake 错误, 继续执行，但是会跳过生成的步骤
FATAL_ERROR：CMake 错误, 终止所有处理过程

CMake的命令行工具会在stdout上显示STATUS消息，在stderr上显示其他所有消息。CMake的GUI会在它的log区域显示所有消息。

CMake警告和错误消息的文本显示使用的是一种简单的标记语言。文本没有缩进，超过长度的行会回卷，段落之间以新行做为分隔符。

1
message(STATUS "source path: ${PROJECT_SOURCE_DIR}")
2

3
message(WARNING "source path: ${PROJECT_SOURCE_DIR}")
4

5
message(FATAL_ERROR "source path: ${PROJECT_SOURCE_DIR}")

2.8 变量操作#

2.8.1 追加#

有时候项目中的源文件并不一定都在同一个目录中，但是这些源文件最终却需要一起进行编译来生成最终的可执行文件或者库文件。如果我们通过file命令对各个目录下的源文件进行搜索，最后还需要做一个字符串拼接的操作，关于字符串拼接可以使用set命令也可以使用list命令。

使用set拼接#

如果使用set进行字符串拼接，对应的命令格式如下：

1
set(变量名1 ${变量名1} ${变量名2} ...)

关于上面的命令其实就是将从第二个参数开始往后所有的字符串进行拼接，最后将结果存储到第一个参数中，如果第一个参数中原来有数据会对原数据就行覆盖。

1
cmake_minimum_required(VERSION 3.0)
2
project(TEST)
3
set(TEMP "hello,world")
4
file(GLOB SRC_1 ${PROJECT_SOURCE_DIR}/src1/*.cpp)
5
file(GLOB SRC_2 ${PROJECT_SOURCE_DIR}/src2/*.cpp)
6

7
set(SRC_1 ${SRC_1} ${SRC_2} ${TEMP})
8
message(STATUS "message: ${SRC_1}")

使用list拼接#

如果使用list进行字符串拼接，对应的命令格式如下：

1
list(APPEND <list> [<element> ...])

list命令的功能比set要强大，字符串拼接只是它的其中一个功能，所以需要在它第一个参数的位置指定出我们要做的操作，APPEND表示进行数据追加，后边的参数和set就一样了。

1
cmake_minimum_required(VERSION 3.0)
2
project(TEST)
3
set(TEMP "hello,world")
4
file(GLOB SRC_1 ${PROJECT_SOURCE_DIR}/src1/*.cpp)
5
file(GLOB SRC_2 ${PROJECT_SOURCE_DIR}/src2/*.cpp)
6

7
list(APPEND SRC_1 ${SRC_1} ${SRC_2} ${TEMP})
8
message(STATUS "message: ${SRC_1}")

在CMake中，使用set命令可以创建一个list。一个在list内部是一个由分号;分割的一组字符串。例如，set(var a b c d e)命令将会创建一个list:a;b;c;d;e，但是最终打印变量值的时候得到的是abcde。

1
set(tmp1 a;b;c;d;e)
2
set(tmp2 a b c d e)
3
message(${tmp1})
4
message(${tmp2})

输出的结果:

1
abcde
2
abcde

2.9 宏定义#

在进行程序测试的时候，我们可以在代码中添加一些宏定义，通过这些宏来控制这些代码是否生效，如下所示：

1
#include <stdio.h>
2
#define NUMBER  3
3

4
int main()
5
{
6
    int a = 10;
7
#ifdef DEBUG
8
    printf("我是一个程序猿, 我不会爬树...\n");
9
#endif
10
    for(int i=0; i<NUMBER; ++i)
11
    {
12
        printf("hello, GCC!!!\n");
13
    }
14
    return 0;
15
}

在程序的第七行对DEBUG宏进行了判断，如果该宏被定义了，那么第八行就会进行日志输出，如果没有定义这个宏，第八行就相当于被注释掉了，因此最终无法看到日志输入出（上述代码中并没有定义这个宏）。

为了让测试更灵活，我们可以不在代码中定义这个宏，而是在测试的时候去把它定义出来，其中一种方式就是在gcc/g++命令中去指定，如下：

1
$ gcc test.c -DDEBUG -o app

在gcc/g++命令中通过参数 -D指定出要定义的宏的名字，这样就相当于在代码中定义了一个宏，其名字为DEBUG。

在CMake中我们也可以做类似的事情，对应的命令叫做add_definitions:

1
add_definitions(-D宏名称)

针对于上面的源文件编写一个CMakeLists.txt，内容如下：

1
cmake_minimum_required(VERSION 3.0)
2
project(TEST)
3

4
add_definitions(-DDEBUG)
5
add_executable(app ./test.c)

通过这种方式，上述代码中的第八行日志就能够被输出出来了。

3. 预定义宏#

下面的列表中为大家整理了一些CMake中常用的宏：

宏	功能
PROJECT_SOURCE_DIR	使用cmake命令后紧跟的目录，一般是工程的根目录
PROJECT_BINARY_DIR	执行cmake命令的目录
CMAKE_CURRENT_SOURCE_DIR	当前处理的CMakeLists.txt所在的路径
CMAKE_CURRENT_BINARY_DIR	target 编译目录
EXECUTABLE_OUTPUT_PATH	重新定义目标二进制可执行文件的存放位置
LIBRARY_OUTPUT_PATH	重新定义目标链接库文件的存放位置
PROJECT_NAME	返回通过PROJECT指令定义的项目名称
CMAKE_BINARY_DIR	项目实际构建路径，假设在`build`目录进行的构建，那么得到的就是这个目录的路径

CMake 保姆级教程（下）#

如果项目很大，或者项目中有很多的源码目录，在通过CMake管理项目的时候如果只使用一个CMakeLists.txt，那么这个文件相对会比较复杂，有一种化繁为简的方式就是给每个源码目录都添加一个CMakeLists.txt文件（头文件目录不需要），这样每个文件都不会太复杂，而且更灵活，更容易维护。

先来看一下下面的这个的目录结构：

1
$ tree
2
.
3
├── build
4
├── calc
5
│   ├── add.cpp
6
│   ├── CMakeLists.txt
7
│   ├── div.cpp
8
│   ├── mult.cpp
9
│   └── sub.cpp
10
├── CMakeLists.txt
11
├── include
12
│   ├── calc.h
13
│   └── sort.h
14
├── sort
15
│   ├── CMakeLists.txt
16
│   ├── insert.cpp
17
│   └── select.cpp
18
├── test1
19
│   ├── calc.cpp
20
│   └── CMakeLists.txt
21
└── test2
22
    ├── CMakeLists.txt
23
    └── sort.cpp
24

25
6 directories, 15 files

include 目录：头文件目录
calc 目录：目录中的四个源文件对应的加、减、乘、除算法
- 对应的头文件是include中的calc.h
sort 目录 ：目录中的两个源文件对应的是插入排序和选择排序算法
- 对应的头文件是include中的sort.h
test1 目录：测试目录，对加、减、乘、除算法进行测试
test2 目录：测试目录，对排序算法进行测试

可以看到各个源文件目录所需要的CMakeLists.txt文件现在已经添加完毕了。接下来庖丁解牛，我们依次分析一下各个文件中需要添加的内容。

1.1 准备工作#

1.1.1 节点关系#

众所周知，Linux的目录是树状结构，所以嵌套的 CMake 也是一个树状结构，最顶层的 CMakeLists.txt 是根节点，其次都是子节点。因此，我们需要了解一些关于 CMakeLists.txt 文件变量作用域的一些信息：

根节点CMakeLists.txt中的变量全局有效
父节点CMakeLists.txt中的变量可以在子节点中使用
子节点CMakeLists.txt中的变量只能在当前节点中使用

1.1.2 添加子目录#

接下来我们还需要知道在 CMake 中父子节点之间的关系是如何建立的，这里需要用到一个 CMake 命令：

1
add_subdirectory(source_dir [binary_dir] [EXCLUDE_FROM_ALL])

source_dir：指定了CMakeLists.txt源文件和代码文件的位置，其实就是指定子目录
binary_dir：指定了输出文件的路径，一般不需要指定，忽略即可。
EXCLUDE_FROM_ALL：在子路径下的目标默认不会被包含到父路径的ALL目标里，并且也会被排除在IDE工程文件之外。用户必须显式构建在子路径下的目标。

通过这种方式CMakeLists.txt文件之间的父子关系就被构建出来了。

1.2 解决问题#

在上面的目录中我们要做如下事情：

通过 test1 目录中的测试文件进行计算器相关的测试
通过 test2 目录中的测试文件进行排序相关的测试

现在相当于是要进行模块化测试，对于calc和sort目录中的源文件来说，可以将它们先编译成库文件（可以是静态库也可以是动态库）然后在提供给测试文件使用即可。库文件的本质其实还是代码，只不过是从文本格式变成了二进制格式。

1.2.1 根目录#

根目录中的 CMakeLists.txt文件内容如下：

1
cmake_minimum_required(VERSION 3.0)
2
project(test)
3

4

5
set(LIB_PATH ${CMAKE_CURRENT_SOURCE_DIR}/lib)
6

7
set(EXEC_PATH ${CMAKE_CURRENT_SOURCE_DIR}/bin)
8

9
set(HEAD_PATH ${CMAKE_CURRENT_SOURCE_DIR}/include)
10

11
set(CALC_LIB calc)
12
set(SORT_LIB sort)
13

14
set(APP_NAME_1 test1)
15
set(APP_NAME_2 test2)
16

17
add_subdirectory(calc)
18
add_subdirectory(sort)
19
add_subdirectory(test1)
20
add_subdirectory(test2)

在根节点对应的文件中主要做了两件事情：定义全局变量和添加子目录。

定义的全局变量主要是给子节点使用，目的是为了提高子节点中的CMakeLists.txt文件的可读性和可维护性，避免冗余并降低出差的概率。
一共添加了四个子目录，每个子目录中都有一个CMakeLists.txt文件，这样它们的父子关系就被确定下来了。

2. 流程控制#

在 CMake 的 CMakeLists.txt 中也可以进行流程控制，也就是说可以像写 shell 脚本那样进行条件判断和循环。

2.1 条件判断#

关于条件判断其语法格式如下：

1
if(<condition>)
2
  <commands>
3
elseif(<condition>)
4
  <commands>
5
else()
6
  <commands>
7
endif()

在进行条件判断的时候，如果有多个条件，那么可以写多个elseif，最后一个条件可以使用else，但是开始和结束是必须要成对出现的，分别为：if和endif。

2.1.1 基本表达式#

1
if(<expression>)

如果是基本表达式，expression 有以下三种情况：常量、变量、字符串。

如果是1, ON, YES, TRUE, Y, 非零值，非空字符串时，条件判断返回True
如果是 0, OFF, NO, FALSE, N, IGNORE, NOTFOUND，空字符串时，条件判断返回False

2.1.2 逻辑判断#

NOT
```
1
if(NOT <condition>)
```
其实这就是一个取反操作，如果条件condition为True将返回False，如果条件condition为False将返回True。
AND
```
1
if(<cond1> AND <cond2>)
```
如果cond1和cond2同时为True，返回True否则返回False。
OR
```
1
if(<cond1> OR <cond2>)
```
如果cond1和cond2两个条件中至少有一个为True，返回True，如果两个条件都为False则返回False。

2.2 循环#

在 CMake 中循环有两种方式，分别是：foreach和while。

2.2.1 foreach#

使用 foreach 进行循环，语法格式如下：

1
foreach(<loop_var> <items>)
2
    <commands>
3
endforeach()

通过foreach我们就可以对items中的数据进行遍历，然后通过loop_var将遍历到的当前的值取出，在取值的时候有以下几种用法：

方法1#

1
foreach(<loop_var> RANGE <stop>)

RANGE：关键字，表示要遍历范围
stop：这是一个正整数，表示范围的结束值，在遍历的时候从 0 开始，最大值为 stop。
loop_var：存储每次循环取出的值

举例说明：

1
cmake_minimum_required(VERSION 3.2)
2
project(test)
3

4
foreach(item RANGE 10)
5
    message(STATUS "当前遍历的值为: ${item}" )
6
endforeach()

输出的日志信息是这样的：

1
$ cmake ..
2
-- 当前遍历的值为: 0
3
-- 当前遍历的值为: 1
4
-- 当前遍历的值为: 2
5
-- 当前遍历的值为: 3
6
-- 当前遍历的值为: 4
7
-- 当前遍历的值为: 5
8
-- 当前遍历的值为: 6
9
-- 当前遍历的值为: 7
10
-- 当前遍历的值为: 8
11
-- 当前遍历的值为: 9
12
-- 当前遍历的值为: 10
13
-- Configuring done
14
-- Generating done
15
-- Build files have been written to: /home/robin/abc/a/build

再次强调：在对一个整数区间进行遍历的时候，得到的范围是这样的【0，stop】，右侧是闭区间包含 stop 这个值。

方法2#

1
foreach(<loop_var> RANGE <start> <stop> [<step>])

这是上面方法1的加强版，我们在遍历一个整数区间的时候，除了可以指定起始范围，还可以指定步长。

RANGE：关键字，表示要遍历范围
start：这是一个正整数，表示范围的起始值，也就是说最小值为 start
stop：这是一个正整数，表示范围的结束值，也就是说最大值为 stop
step：控制每次遍历的时候以怎样的步长增长，默认为1，可以不设置
loop_var：存储每次循环取出的值

举例说明：

1
cmake_minimum_required(VERSION 3.2)
2
project(test)
3

4
foreach(item RANGE 10 30 2)
5
    message(STATUS "当前遍历的值为: ${item}" )
6
endforeach()

输出的结果如下:

1
$ cmake ..
2
-- 当前遍历的值为: 10
3
-- 当前遍历的值为: 12
4
-- 当前遍历的值为: 14
5
-- 当前遍历的值为: 16
6
-- 当前遍历的值为: 18
7
-- 当前遍历的值为: 20
8
-- 当前遍历的值为: 22
9
-- 当前遍历的值为: 24
10
-- 当前遍历的值为: 26
11
-- 当前遍历的值为: 28
12
-- 当前遍历的值为: 30
13
-- Configuring done
14
-- Generating done
15
-- Build files have been written to: /home/robin/abc/a/build

再次强调：在使用上面的方式对一个整数区间进行遍历的时候，得到的范围是这样的【start，stop】，左右两侧都是闭区间，包含 start 和 stop 这两个值，步长 step 默认为1，可以不设置。

方法3#

1
foreach(<loop_var> IN [LISTS [<lists>]] [ITEMS [<items>]])

这是foreach的另一个变体，通过这种方式我们可以对更加复杂的数据进行遍历，前两种方式只适用于对某个正整数范围内的遍历。

IN：关键字，表示在 xxx 里边
LISTS：关键字，对应的是列表list，通过set、list可以获得
ITEMS：关键字，对应的也是列表
loop_var：存储每次循环取出的值

1
cmake_minimum_required(VERSION 3.2)
2
project(test)
3

4
set(WORD a b c d)
5
set(NAME ace sabo luffy)
6

7
foreach(item IN LISTS WORD NAME)
8
    message(STATUS "当前遍历的值为: ${item}" )
9
endforeach()

在上面的例子中，创建了两个 list 列表，在遍历的时候对它们两个都进行了遍历（可以根据实际需求选择同时遍历多个或者只遍历一个）。输出的日志信息如下：

1
$ cd build/
2
$ cmake ..
3
-- 当前遍历的值为: a
4
-- 当前遍历的值为: b
5
-- 当前遍历的值为: c
6
-- 当前遍历的值为: d
7
-- 当前遍历的值为: ace
8
-- 当前遍历的值为: sabo
9
-- 当前遍历的值为: luffy
10
-- Configuring done
11
-- Generating done
12
-- Build files have been written to: /home/robin/abc/a/build

一共输出了7个字符串，说明遍历是没有问题的。接下来看另外一种方式：

1
cmake_minimum_required(VERSION 3.2)
2
project(test)
3

4
set(WORD a b c "d e f")
5
set(NAME ace sabo luffy)
6
foreach(item IN ITEMS ${WORD} ${NAME})
7
    message(STATUS "当前遍历的值为: ${item}" )
8
endforeach()

在上面的例子中，遍历过程中将关键字LISTS改成了ITEMS，后边跟的还是一个或者多个列表，只不过此时需要通过${}将列表中的值取出。其输出的信息和上一个例子是一样的：

1
$ cd build/
2
$ cmake ..
3
-- 当前遍历的值为: a
4
-- 当前遍历的值为: b
5
-- 当前遍历的值为: c
6
-- 当前遍历的值为: d e f
7
-- 当前遍历的值为: ace
8
-- 当前遍历的值为: sabo
9
-- 当前遍历的值为: luffy
10
-- Configuring done
11
-- Generating done
12
-- Build files have been written to: /home/robin/abc/a/build

小细节：在通过 set 组织列表的时候，如果某个字符串中有空格，可以通过双引号将其包裹起来，具体的操作方法可以参考上面的例子。

方法4#

注意事项：这种循环方式要求CMake的版本大于等于 3.17。

1
foreach(<loop_var>... IN ZIP_LISTS <lists>)

通过这种方式，遍历的还是一个或多个列表，可以理解为是方式3的加强版。因为通过上面的方式遍历多个列表，但是又想把指定列表中的元素取出来使用是做不到的，在这个加强版中就可以轻松实现。

loop_var：存储每次循环取出的值，可以根据要遍历的列表的数量指定多个变量，用于存储对应的列表当前取出的那个值。
- 如果指定了多个变量名，它们的数量应该和列表的数量相等
- 如果只给出了一个 loop_var，那么它将一系列的 loop_var_N 变量来存储对应列表中的当前项，也就是说 loop_var_0 对应第一个列表，loop_var_1 对应第二个列表，以此类推......
- 如果遍历的多个列表中一个列表较短，当它遍历完成之后将不会再参与后续的遍历（因为其它列表还没有遍历完）。
IN：关键字，表示在 xxx 里边
ZIP_LISTS：关键字，对应的是列表list，通过set 、list可以获得

1
cmake_minimum_required(VERSION 3.17)
2
project(test)
3

4
list(APPEND WORD hello world "hello world")
5
list(APPEND NAME ace sabo luffy zoro sanji)
6

7
foreach(item1 item2 IN ZIP_LISTS WORD NAME)
8
    message(STATUS "当前遍历的值为: item1 = ${item1}, item2=${item2}" )
9
endforeach()
10

11
message("=============================")
12

13
foreach(item  IN ZIP_LISTS WORD NAME)
14
    message(STATUS "当前遍历的值为: item1 = ${item_0}, item2=${item_1}" )
15
endforeach()

在这个例子中关于列表数据的添加是通过list来实现的。在遍历列表的时候一共使用了两种方式，一种提供了多个变量来存储当前列表中的值，另一种只有一个变量，但是实际取值的时候需要通过变量名_0、变量名_1、变量名_N 的方式来操作，注意事项：第一个列表对应的编号是0，第一个列表对应的编号是0，第一个列表对应的编号是0。

上面的例子输出的结果如下：

1
$ cd build/
2
$ cmake ..
3
-- 当前遍历的值为: item1 = hello, item2=ace
4
-- 当前遍历的值为: item1 = world, item2=sabo
5
-- 当前遍历的值为: item1 = hello world, item2=luffy
6
-- 当前遍历的值为: item1 = , item2=zoro
7
-- 当前遍历的值为: item1 = , item2=sanji
8
=============================
9
-- 当前遍历的值为: item1 = hello, item2=ace
10
-- 当前遍历的值为: item1 = world, item2=sabo
11
-- 当前遍历的值为: item1 = hello world, item2=luffy
12
-- 当前遍历的值为: item1 = , item2=zoro
13
-- 当前遍历的值为: item1 = , item2=sanji
14
-- Configuring done (0.0s)
15
-- Generating done (0.0s)
16
-- Build files have been written to: /home/robin/abc/a/build

Reference#

【1】 https://subingwen.cn/cmake/CMake-advanced/

CMake 基本用法与简单介绍#

1、 基本介绍#

2. CMake的使用#

2.1 注释#

2.1.1 注释行#

2.1.2 注释块#

2.1 只有源文件#

2.1.1 共处一室#

2.1.2 VIP 包房#

2.2 私人订制#

2.2.1 定义变量#

2.2.2 指定使用的C++标准#

2.2.3 指定输出的路径#

2.3 搜索文件#

2.3.1 方式1#

2.3.2 方式2#

2.4 包含头文件#

2.5 制作动态库或静态库#

2.5.1 制作静态库#

2.5.2 制作动态库#

2.5.3 指定输出的路径#

方式1 - 适用于动态库#

方式2 - 都适用#

2.6 包含库文件#

2.6.1 链接静态库#

2.6.2 链接动态库#

链接系统动态库#

链接第三方动态库#

2.7 日志#

2.8 变量操作#

2.8.1 追加#

使用set拼接#

使用list拼接#

2.9 宏定义#

3. 预定义宏#

CMake 保姆级教程（下）#

1.1 准备工作#

1.1.1 节点关系#

1.1.2 添加子目录#

1.2 解决问题#

1.2.1 根目录#

2. 流程控制#

2.1 条件判断#

2.1.1 基本表达式#

2.1.2 逻辑判断#

2.2 循环#

2.2.1 foreach#

方法1#

方法2#

方法3#

方法4#

Reference#

1、基本介绍#