【C++】Cmake使用教程（看这一篇就够了）

最新推荐文章于 2025-03-28 13:59:00 发布

#君#

最新推荐文章于 2025-03-28 13:59:00 发布

阅读量1.5k

点赞数 10

文章标签： c++ 开发语言

原文链接：https://blog.csdn.net/weixin_43717839/article/details/128032486

版权

文章目录

引言

这篇文章主要介绍的是 CMake 相关的语法，如果刚开始接触 CMake，并对此有所兴趣的话，建议看看这篇文章：为什么需要 CMake？

CMake 是开源、跨平台的构建工具，可以让我们通过编写简单的配置文件去生成本地的 Makefile，这个配置文件是独立于运行平台和编译器的，这样就不用亲自去编写 Makefile 了，而且配置文件可以直接拿到其它平台上使用，无需修改，非常方便。

本文主要讲述在 Linux 下如何使用 CMake 来编译我们的程序。

一环境搭建

我使用的是 ubuntu18.04，安装 cmake 使用如下命令：

sudo apt install cmake

安装完成后，在终端下输入:

cmake -version

查看 cmake 版本

这样 cmake 就安装好了。

二简单入门

首先让我们从最简单的代码入手，先来体验下 cmake 是如何操作的。

2.1 项目结构

2.2 示例源码

打开终端，输入：

touch main.c CMakeLists.txt

编写 main.c，如下：

main.c

#include <stdio.h>

int main(void)
{
	printf("Hello World\n");
	return 0;
}

然后在 main.c 同级目录下编写 CMakeLists.txt，内容如下：

CMakeLists.txt

cmake_minimum_required (VERSION 2.8)

project (demo)

add_executable(main main.c)

2.3 运行查看

在终端下切到 main.c 所在的目录下，然后输入以下命令运行 cmake：

cmake .

输出结果如下：

ps: 此时，建议留意一下这个文件夹下多生成的文件都有哪些。

可以看到成功生成了 Makefile，还有一些 cmake 运行时自动生成的文件。
然后在终端下输入 make：

可以看到执行 cmake 生成的 Makefile 可以显示进度，并带颜色。再看下目录下的文件：

可以看到我们需要的可执行文件 main 也成功生成了！
然后运行 main：

运行成功！

PS：如果想重新生成 main，输入 make clean 就可以删除 main 这个文件。然后重新 make 就行。
需要注意的是：我希望你着重看一下这时候这个文件夹下都有哪些文件。

三编译多个源文件

3.1 在同一个目录下有多个源文件

3.1.1 简单版本

接下来进入稍微复杂的例子：在同一个目录下有多个源文件。

3.1.1.1 项目结构

3.1.1.2 示例代码

首先删除之前的文件：

rm -rf CMakeFiles CMakeCache.txt cmake_install.cmake Makefile main

在之前的目录下添加 2 个文件，testFunc.c 和 testFunc.h:

touch testFunc.c testFunc.h

添加完后整体文件结构如下：

testFunc.c

/*
** testFunc.c
*/

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

void func(int data)
{
	printf("data is %d\n", data);
}

testFunc.h

/*
** testFunc.h
*/

#ifndef _TEST_FUNC_H_
#define _TEST_FUNC_H_

void func(int data);

#endif

修改 main.c，调用 testFunc.h 里声明的函数 func()：

main.c

#include <stdio.h>

#include "testFunc.h"

int main(void)
{
	func(100);
	return 0;
}

修改 CMakeLists.txt，在 add_executable 的参数里把 testFunc.c 加进来:

CMakeLists.txt

cmake_minimum_required (VERSION 2.8)

project (demo)

add_executable(main main.c testFunc.c)

3.1.1.3 运行查看

cmake .
make

然后运行查看：

运行成功！

可以类推，如果在同一目录下有多个源文件，那么只要在 add_executable 里把所有源文件都添加进去就可以了。

但是如果有一百个源文件，再这样做就有点坑了，无法体现 cmake 的优越性。
因此 cmake 提供了一个命令可以把指定目录下所有的源文件存储在一个变量中，这个命令就是

aux_source_directory(dir var)

第一个参数 dir 是指定目录，第二个参数 var 是用于存放源文件列表的变量。

接下来写个进阶版的 demo 使用一下这个变量。

3.1.2 进阶版本

3.1.2.1 项目结构

3.1.2.2 示例源码

删除无关文件

rm -rf CMakeFiles CMakeCache.txt cmake_install.cmake  main Makefile

创建文件：

touch testFunc1.c testFunc1.h

testFunc1.c

/*
** testFunc1.c
*/

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

void func1(int data)
{
	printf("data is %d\n", data);
}

testFunc1.h

/*
** testFunc1.h
*/

#ifndef _TEST_FUNC1_H_
#define _TEST_FUNC1_H_

void func1(int data);

#endif

再修改 main.c，调用 testFunc1.h 里声明的函数 func1()：

main.c

#include <stdio.h>

#include "testFunc.h"
#include "testFunc1.h"

int main(void)
{
	func(100);
	func1(200);

	return 0;
}

修改 CMakeLists.txt：

CMakeLists.txt

cmake_minimum_required (VERSION 2.8)

project (demo)

aux_source_directory(. SRC_LIST)

add_executable(main ${SRC_LIST})

使用 aux_source_directory 把当前目录下的源文件存列表存放到变量 SRC_LIST 里;

然后在 add_executable 里调用 SRC_LIST（注意调用变量时的写法）。

3.1.2.3 运行查看

再次执行 cmake 和 make，并运行 main:

可以看到运行成功了。

aux_source_directory() 也存在弊端，它会把指定目录下的所有源文件都加进来，可能会加入一些我们不需要的文件，此时我们可以使用 set 命令去新建变量来存放需要的源文件，如下：

cmake_minimum_required (VERSION 2.8)

project (demo)

set( SRC_LIST
	 ./main.c
	 ./testFunc1.c
	 ./testFunc.c)

add_executable(main ${SRC_LIST})

3.2 在不同目录下有多个源文件

一般来说，当程序文件比较多时，我们会进行分类管理，把代码根据功能放在不同的目录下，这样方便查找。那么这种情况下如何编写 CMakeLists.txt 呢？

3.2.1 项目结构

我们把之前的源文件整理一下（新建 2 个目录 test_func 和 test_func1）：

rm -rf CMakeFiles CMakeCache.txt cmake_install.cmake  main Makefile

整理好后整体文件结构如下：

把之前的 testFunc.c 和 testFunc.h 放到 test_func 目录下，testFunc1.c 和 testFunc1.h 则放到 test_func1 目录下。

3.2.2 示例源码

其中，CMakeLists.txt 和 main.c 在同一目录下，内容修改成如下所示：

cmake_minimum_required (VERSION 2.8)

project (demo)

include_directories (test_func test_func1)

aux_source_directory (test_func SRC_LIST)
aux_source_directory (test_func1 SRC_LIST1)

add_executable (main main.c ${SRC_LIST} ${SRC_LIST1})

这里出现了一个新的命令：include_directories。

该命令是用来向工程添加多个指定头文件的搜索路径，路径之间用空格分隔。

因为 main.c 里 include 了 testFunc.h 和 testFunc1.h，如果没有这个命令来指定头文件所在位置，就会无法编译。当然，也可以在 main.c 里使用 include 来指定路径，如下

#include "test_func/testFunc.h"
#include "test_func1/testFunc1.h"

只是这种写法不好看。
另外，我们使用了 2 次 aux_source_directory，因为源文件分布在 2 个目录下，所以添加 2 次。

3.2.2 运行查看

四项目级的组织结构

正规一点来说，一般会把源文件放到 src 目录下，把头文件放入到 include 文件下，生成的对象文件放入到 build 目录下，最终输出的可执行程序文件会放到 bin 目录下，这样整个结构更加清晰。

4.1 项目结构

让我们把前面的文件再次重新组织下：

4.2 示例源码

修改 CMakeLists.txt：

CMakeLists.txt

cmake_minimum_required (VERSION 2.8)

project (demo)

add_subdirectory (src)

add_subdirectory：这个语句的作用是增加编译子目录。其基本语法格式是：

add_subdirectory(source_dir [binary_dir] [EXCLUDE_FROM_ALL])

一共有三个参数，后两个是可选参数.

指定一个包含 CMakeLists.txt 和代码文件所在的目录，该目录可以是绝对路径，也可以是相对路径，对于后者相对路径的起点是 CMAKE_CURRENT_SOURCE_DIR。此外，如果子目录再次包含的 CMakeLists.txt，则将继续处理里层的 CMakeLists.txt，而不是继续处理当前源代码。

binary_dir 二进制代码目录

这个目录是可选的，如果指定，cmake 命令执行后的输出文件将会存放在此处，若没有指定，默认情况等于source_dir没有进行相对路径计算前的路径，也就是CMAKE_BINARY_DIR。

EXCLUDE_FROM_ALL 标记

这个标志是可选的，如果传递了该参数表示新增加的子目录将会排除在 ALL 目录之外（可能是 make 系统中的 make all？），表示这个目录将从 IDE 的工程中排除。用户必须显式在子文件这个编译目标（手动 cmake 之类的）。指定了这个文件夹，表示这个文件夹是独立于源工程的，这些函数是有用但是不是必要的，比如说我们一系列的例子。

add_subdirectory 这个命令用于添加源文件子目录，同时还可以指定中间二进制和目标二进制的生成路径。EXCLUDE_FROM_ALL 将会将这个目录从编译中排除，如工程的例子需要等待其他编译完成后再进行单独的编译。通常子目录应该包含自己的 project() 命令，这样以来整个编译命令将会产生各自的目标文件。如果把 CMakeLists.txt 与 VS IDE 比较，总的 CMakeLists.txt 就相当于解决方案，子 CMakeLists.txt 就相当于在解决方案下的工程文件。还有一个需要注意的是，如果编译父 CMakeLists 时依赖了子 CMakeLists.txt 中的源文件，那么该标志将会被覆盖（也就是也会处理），以满足编译任务。

这里指定 src 目录下存放了源文件，当执行 cmake 时，就会进入 src 目录下去找 src 目录下的 CMakeLists.txt，所以在 src 目录下也建立一个 CMakeLists.txt，内容如下:

src/CMakeLists.txt

aux_source_directory (. SRC_LIST)

include_directories (../include)

add_executable (main ${SRC_LIST})

set (EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)

这里的 set 其实是和前面的一样，只是 EXECUTABLE_OUTPUT_PATH 是个系统自带的预定义变量，其意义如下：

EXECUTABLE_OUTPUT_PATH ：目标二进制可执行文件的存放位置
PROJECT_SOURCE_DIR：工程的根目录

所以，这里 set 的意思是把存放 elf 文件的位置设置为工程根目录下的 bin 目录。（cmake 有很多预定义变量，详细的可以网上搜索一下）

添加好以上这 2 个 CMakeLists.txt 后，整体文件结构如下：

4.3 运行查看

下面来运行 cmake，不过这次先让我们切到 build 目录下:

cd build
cmake ..
make

这样 Makefile 会在 build 目录下生成，二进制程序会在 bin 目录下生成，然后运行可执行程序：

cd ../bin
./main

这里解释一下为什么在 build 目录下运行 cmake？
还记得在第一个例子里我让你着重看一下 cmake 和 make 之后会生成什么文件吗？这个过程中会生成很多文件，但是可惜的是跟我们的运行并没有什么关系，因此，如果能把编译隔离在某个文件夹，这样 cmake 的时候所有的中间文件都将在这个目录下生成，删除的时候也很好删除，非常方便。如果不这样做，cmake 运行时生成的附带文件就会跟源码文件混在一起，这样会对程序的目录结构造成污染。
另外一种写法：
前面的工程使用了 2 个 CMakeLists.txt，最外层的 CMakeLists.txt 用于掌控全局，使用 add_subdirectory 来控制其它目录下的 CMakeLists.txt 的运行。

上面的例子也可以只使用一个 CMakeLists.txt，把最外层的 CMakeLists.txt 内容改成如下

CMakeLists.txt

cmake_minimum_required (VERSION 2.8)

project (demo)

set (EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)

aux_source_directory (src SRC_LIST)

include_directories (include)

add_executable (main ${SRC_LIST})

同时，还要把 src 目录下的 CMakeLists.txt 删除。

然后正常编译运行就可以。

五动态库和静态库的编译控制

有时只需要编译出动态库和静态库，然后等着让其它程序去使用。让我们看下这种情况该如何使用 cmake。

关于什么是静态库和动态库以及如何使用它们，请参见我的另一篇博客【C++】静态库与动态库的生成与使用介绍

5.1 生成库文件

5.1.1 项目结构

首先按照如下重新组织文件，只留下 testFunc.h 和 TestFunc.c

我们会在 build 目录下运行 cmake，并把生成的库文件存放到 lib 目录下。

5.1.2 示例源码

CMakeLists.txt

cmake_minimum_required (VERSION 3.5)

project (demo)

set (SRC_LIST ${PROJECT_SOURCE_DIR}/testFunc/testFunc.c)

add_library (testFunc_shared SHARED ${SRC_LIST})
add_library (testFunc_static STATIC ${SRC_LIST})

set_target_properties (testFunc_shared PROPERTIES OUTPUT_NAME "testFunc")
set_target_properties (testFunc_static PROPERTIES OUTPUT_NAME "testFunc")

set (LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/lib)

这里又出现了新的命令和预定义变量:

add_library: 生成动态库或静态库 (第 1 个参数指定库的名字；第 2 个参数决定是动态还是静态，如果没有就默认静态；第 3 个参数指定生成库的源文件)
set_target_properties: 设置最终生成的库的名称，还有其它功能，如设置库的版本号等
LIBRARY_OUTPUT_PATH: 库文件的默认输出路径，这里设置为工程目录下的 lib 目录

PS：前面使用 set_target_properties 重新定义了库的输出名称，如果不使用 set_target_properties 也可以，那么库的名称就是 add_library 里定义的名称，只是连续 2 次使用 add_library 指定库名称时（第一个参数），这个名称不能相同，而 set_target_properties 可以把名称设置为相同，只是最终生成的库文件后缀不同（一个是. so，一个是. a），这样相对来说会好看点。

5.1.3 运行查看

cd build/
cmake ..
make
cd ../lib/
ls

5.2 链接库文件

既然我们已经生成了库，那么就进行链接测试下。

5.2.1 项目结构

重新建一个工程目录，然后把上节生成的库拷贝过来，然后在在工程目录下新建 src 目录和 bin 目录，在 src 目录下添加一个 main.c，整体结构如下：

5.2.2 示例源码

main.c

#include <stdio.h>

#include "testFunc.h"

int main(void)
{
    func(100);
    
    return 0;
}

CMakeLists.txt

cmake_minimum_required (VERSION 3.5)

project (demo)


set (EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)

set (SRC_LIST ${PROJECT_SOURCE_DIR}/src/main.c)

# find testFunc.h
include_directories (${PROJECT_SOURCE_DIR}/testFunc/inc)

find_library(TESTFUNC_LIB testFunc HINTS ${PROJECT_SOURCE_DIR}/testFunc/lib)

add_executable (main ${SRC_LIST})

target_link_libraries (main ${TESTFUNC_LIB})

这里出现 2 个新的命令，

find_library: 在指定目录下查找指定库，并把库的绝对路径存放到变量里，其第一个参数是变量名称，第二个参数是库名称，第三个参数是 HINTS，第 4 个参数是路径，其它用法可以参考 cmake 文档
target_link_libraries: 把目标文件与库文件进行链接

使用 find_library 的好处是在执行 cmake … 时就会去查找库是否存在，这样可以提前发现错误，不用等到链接时。

5.2.3 运行查看

cd 到 build 目录下，然后运行 cmake … && make，最后进入到 bin 目录下查看，发现 main 已经生成，运行之：

cd build/
cmake ..
make
cd ../bin/
./main

ps：在 lib 目录下有 testFunc 的静态库和动态库，find_library(TESTFUNC_LIB testFunc
… 默认是查找动态库，如果想直接指定使用动态库还是静态库，可以写成 find_library(TESTFUNC_LIB
libtestFunc.so … 或者 find_library(TESTFUNC_LIB libtestFunc.a …

ps：查看 elf 文件使用了哪些库，可以使用 readelf -d ./xx 来查看例：readelf -d ./main

六条件编译

有时编译程序时想添加一些编译选项，如 - Wall，-std=c++11 等，就可以使用 add_compile_options 来进行操作。
这里以一个简单程序来做演示。

6.1 简单程序

6.1.1 项目结构

6.1.2 示例代码

main.cpp

#include <iostream>

int main(void)
{
    auto data = 100;
    std::cout << "data: " << data << "\n";
    return 0;
}

CMakeLists.txt

cmake_minimum_required (VERSION 2.8)

project (demo)

set (EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)

add_compile_options(-std=c++11 -Wall) 

add_executable(main main.cpp)

6.1.3 运行查看

然后 cd 到 build 目录下，执行 cmake … && make 命令，就可以在 bin 目录下得到 main 的可执行文件

6.2 添加编译选项

有时希望在编译代码时只编译一些指定的源码，可以使用 cmake 的 option 命令，主要遇到的情况分为 2 种：

本来要生成多个 bin 或库文件，现在只想生成部分指定的 bin 或库文件
对于同一个 bin 文件，只想编译其中部分代码（使用宏来控制）

6.2.1 生成部分指定 bin 或库文件

6.2.1.1 项目结构

假设我们现在的工程会生成 2 个 bin 文件，main1 和 main2，项目结构如下：

6.2.1.2 示例源码

CMakeLists.txt

cmake_minimum_required(VERSION 3.5)

project(demo)

option(MYDEBUG "enable debug compilation" OFF)

set (EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)

add_subdirectory(src)

这里使用了 option 命令，其第一个参数是这个 option 的名字，第二个参数是字符串，用来描述这个 option 是来干嘛的，第三个是 option 的值，ON 或 OFF，也可以不写，不写就是默认 OFF。

然后编写 src 目录下的 CMakeLists.txt，如下：

src/CMakeLists.txt

cmake_minimum_required (VERSION 3.5)

add_executable(main1 main1.c)

if (MYDEBUG)
    add_executable(main2 main2.c)
else()
    message(STATUS "Currently is not in debug mode")    
endif()

注意，这里使用了 if-else 来根据 option 来决定是否编译 main2.c, 其中 main1.c 和 main2.c 的内容如下:

main1.c

// main1.c
#include <stdio.h>

int main(void)
{
    printf("hello, this main1\n");
    
    return 0;
}

main1.c

// main2.c
#include <stdio.h>

int main(void)
{
    printf("hello, this main2\n");
    
    return 0;
}

6.2.1.3 运行查看

然后 cd 到 build 目录下输入 cmake … && make 就可以只编译出 main1，如果想编译出 main2，就把 MYDEBUG 设置为 ON，再次输入 cmake … && make 重新编译。

每次想改变 MYDEBUG 时都需要去修改 CMakeLists.txt，有点麻烦，其实可以通过 cmake 的命令行去操作，例如我们想把 MYDEBUG 设置为 OFF，先 cd 到 build 目录，然后输入 cmake … -DMYDEBUG=ON，这样就可以编译出 main1 和 main2 （在 bin 目录下）

6.2.2 编译部分代码

假设我们有个 main.c，其内容如下：

main.c

#include <stdio.h>

int main(void)
{
#ifdef WWW1
    printf("hello world1\n");
#endif    

#ifdef WWW2     
    printf("hello world2\n");
#endif

    return 0;
}

可以通过定义宏来控制打印的信息，我们 CMakeLists.txt 内容如下:

cmake_minimum_required(VERSION 3.5)

project(demo)

set (EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/bin)

option(WWW1 "print one message" OFF)
option(WWW2 "print another message" OFF)

if (WWW1)
    add_definitions(-DWWW1)
endif()

if (WWW2)
    add_definitions(-DWWW2)
endif()

add_executable(main main.c)

这里把 option 的名字保持和 main.c 里的宏名称一致，这样更加直观，也可以选择不同的名字。通过与 add_definitions() 的配合，就可以控制单个 bin 文件的打印输出了。

整体工程结构如下：