深入浅出CMake编程从基础语法到高级技巧的完整代码示例与业界最佳实践指南助您轻松掌握项目构建

威震华夏关云长

1. 引言

CMake是一个开源、跨平台的构建自动化工具，它使用平台无关的配置文件来生成标准的构建文件（如Unix的Makefile或Windows Visual Studio的项目文件）。CMake被广泛用于C++项目，但也支持其他语言。通过掌握CMake，开发者可以轻松管理复杂项目的构建过程，处理依赖关系，并实现跨平台开发。

本文将从CMake的基础语法开始，逐步深入到高级技巧和最佳实践，帮助读者全面掌握CMake编程。每个概念都会配有详细的代码示例，以便读者理解和应用。

2. CMake基础

2.1 CMake简介和安装

CMake（Cross-platform Make）是一个构建系统生成器，它不直接构建软件，而是生成构建文件（如Makefile或Visual Studio项目），然后使用这些构建文件来编译和链接代码。

在大多数Linux系统上，可以通过包管理器安装：

2. # Ubuntu/Debian
3. sudo apt-get install cmake
5. # Fedora
6. sudo dnf install cmake
8. # Arch Linux
9. sudo pacman -S cmake

复制代码

在macOS上，可以使用Homebrew：

2. brew install cmake

复制代码

在Windows上，可以从CMake官方网站下载安装程序。

安装完成后，可以通过以下命令验证安装：

2. cmake --version

复制代码

2.2 基本语法和命令

CMake脚本使用CMake语言编写，文件通常命名为CMakeLists.txt。CMake语言简单直观，主要由命令（函数）调用组成。

让我们从一个简单的例子开始：

2. # 设置CMake最低版本要求
3. cmake_minimum_required(VERSION 3.10)
5. # 项目名称
6. project(MyFirstProject)
8. # 添加一个可执行文件
9. add_executable(my_app main.cpp)

复制代码

这个简单的CMakeLists.txt文件做了三件事：

1. 指定需要的CMake最低版本
2. 定义项目名称
3. 添加一个可执行文件目标，从main.cpp源文件构建

以下是一些常用的CMake基本命令：

2. # 设置变量
3. set(VARIABLE_NAME value)
5. # 获取变量值
6. message(STATUS "Variable value: ${VARIABLE_NAME}")
8. # 添加子目录
9. add_subdirectory(source_dir)
11. # 查找源文件
12. file(GLOB SOURCES "src/*.cpp")
14. # 条件语句
15. if(condition)
16.     # 执行命令
17. elseif(condition2)
18.     # 执行命令
19. else()
20.     # 执行命令
21. endif()
23. # 循环
24. foreach(var IN ITEMS item1 item2 item3)
25.     message(STATUS "Item: ${var}")
26. endforeach()

复制代码

2.3 变量和作用域

在CMake中，变量使用set()命令设置，通过${VAR_NAME}语法引用。

2. # 设置变量
3. set(MY_VARIABLE "Hello World")
5. # 引用变量
6. message(STATUS "${MY_VARIABLE}")
8. # 列表变量
9. set(MY_LIST item1 item2 item3)
10. message(STATUS "List items: ${MY_LIST}")

复制代码

CMake有几种不同的变量作用域：

1. 函数作用域：在函数内部设置的变量，默认情况下只在函数内部可见
2. 目录作用域：在CMakeLists.txt文件中设置的变量，对该文件及其子目录可见
3. 缓存变量：持久化变量，存储在CMakeCache.txt中，跨CMake运行保持不变

2. # 设置普通变量
3. set(LOCAL_VAR "local value")
5. # 设置缓存变量
6. set(CACHE_VAR "cache value" CACHE STRING "A cache variable")
8. # 设置父作用域变量（在函数中使用）
9. set(PARENT_VAR "parent value" PARENT_SCOPE)

复制代码

2.4 条件语句和循环

CMake支持标准的条件语句，使用if()、elseif()、else()和endif()：

2. set(MY_VARIABLE "some_value")
4. if(MY_VARIABLE)
5.     message(STATUS "MY_VARIABLE is set to: ${MY_VARIABLE}")
6. endif()
8. # 检查变量是否等于特定值
9. if(MY_VARIABLE STREQUAL "some_value")
10.     message(STATUS "MY_VARIABLE equals 'some_value'")
11. elseif(MY_VARIABLE STREQUAL "other_value")
12.     message(STATUS "MY_VARIABLE equals 'other_value'")
13. else()
14.     message(STATUS "MY_VARIABLE has a different value")
15. endif()
17. # 数值比较
18. set(NUMBER 10)
19. if(NUMBER GREATER 5)
20.     message(STATUS "${NUMBER} is greater than 5")
21. endif()
23. # 检查是否定义了变量
24. if(DEFINED MY_VARIABLE)
25.     message(STATUS "MY_VARIABLE is defined")
26. endif()

复制代码

CMake提供了几种循环结构：

2. # foreach循环
3. foreach(var IN ITEMS item1 item2 item3)
4.     message(STATUS "Item: ${var}")
5. endforeach()
7. # 数字范围循环
8. foreach(i RANGE 0 5)
9.     message(STATUS "Number: ${i}")
10. endforeach()
12. # 步进循环
13. foreach(i RANGE 0 10 2)
14.     message(STATUS "Even number: ${i}")
15. endforeach()
17. # while循环
18. set(i 0)
19. while(i LESS 5)
20.     message(STATUS "i is: ${i}")
21.     math(EXPR i "${i} + 1")
22. endwhile()

复制代码

3. 项目配置

3.1 项目设置

project()命令是CMake项目的基础，它设置项目名称，并可选地指定版本、语言等：

2. # 基本项目设置
3. project(MyProject)
5. # 带版本信息的项目设置
6. project(MyProject
7.     VERSION 1.0.2
8.     DESCRIPTION "My awesome project"
9.     LANGUAGES CXX C
10. )
12. # 访问项目信息
13. message(STATUS "Project name: ${PROJECT_NAME}")
14. message(STATUS "Project version: ${PROJECT_VERSION}")
15. message(STATUS "Project version major: ${PROJECT_VERSION_MAJOR}")
16. message(STATUS "Project version minor: ${PROJECT_VERSION_MINOR}")
17. message(STATUS "Project version patch: ${PROJECT_VERSION_PATCH}")

复制代码

3.2 查找依赖包

CMake的find_package()命令是查找和使用外部依赖的关键：

2. # 查找Boost库
3. find_package(Boost 1.66 REQUIRED COMPONENTS filesystem system)
5. # 如果找到，使用Boost
6. if(Boost_FOUND)
7.     message(STATUS "Boost found")
8.     message(STATUS "Boost include directories: ${Boost_INCLUDE_DIRS}")
9.     message(STATUS "Boost libraries: ${Boost_LIBRARIES}")
10.    
11.     # 将Boost的include目录添加到目标
12.     include_directories(${Boost_INCLUDE_DIRS})
13. endif()
15. # 查找其他常见库
16. find_package(OpenGL REQUIRED)
17. find_package(PkgConfig REQUIRED)
18. pkg_check_modules(SDL2 REQUIRED sdl2)

复制代码

在现代CMake（3.0+）中，推荐使用目标属性和target_link_libraries()来处理依赖：

2. # 创建一个可执行文件
3. add_executable(my_app main.cpp)
5. # 链接库
6. target_link_libraries(my_app
7.     PRIVATE
8.         Boost::filesystem
9.         Boost::system
10.         OpenGL::GL
11.         ${SDL2_LIBRARIES}
12. )
14. # 包含目录
15. target_include_directories(my_app
16.     PRIVATE
17.         ${SDL2_INCLUDE_DIRS}
18. )

复制代码

3.3 编译选项和配置

CMake允许设置各种编译选项和配置：

2. # 设置C++标准
3. set(CMAKE_CXX_STANDARD 17)
4. set(CMAKE_CXX_STANDARD_REQUIRED ON)
5. set(CMAKE_CXX_EXTENSIONS OFF)
7. # 编译器标志
8. add_compile_options(-Wall -Wextra -Wpedantic)
10. # 调试和发布模式的不同设置
11. set(CMAKE_CXX_FLAGS_DEBUG "-g -O0")
12. set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG")
14. # 使用生成器表达式设置特定配置的编译标志
15. target_compile_options(my_app
16.     PRIVATE
17.         $<$<CONFIG:Debug>:-g -O0>
18.         $<$<CONFIG:Release>:-O3 -DNDEBUG>
19. )
21. # 定义宏
22. target_compile_definitions(my_app
23.     PRIVATE
24.         MY_PROJECT_VERSION="${PROJECT_VERSION}"
25.         $<$<CONFIG:Debug>:DEBUG_MODE>
26. )

复制代码

4. 构建系统

4.1 可执行文件和库的创建

2. # 从单个源文件创建可执行文件
3. add_executable(my_app main.cpp)
5. # 从多个源文件创建可执行文件
6. add_executable(my_app
7.     main.cpp
8.     utils.cpp
9.     utils.h
10. )
12. # 使用变量存储源文件
13. set(SOURCES
14.     main.cpp
15.     utils.cpp
16.     utils.h
17. )
18. add_executable(my_app ${SOURCES})
20. # 使用file命令自动查找源文件
21. file(GLOB SOURCES "src/*.cpp")
22. add_executable(my_app ${SOURCES})

复制代码

2. # 创建静态库
3. add_library(my_static_lib STATIC
4.     lib_source1.cpp
5.     lib_source2.cpp
6. )
8. # 创建共享库
9. add_library(my_shared_lib SHARED
10.     lib_source1.cpp
11.     lib_source2.cpp
12. )
14. # 创建对象库（不生成归档文件，只编译为对象文件）
15. add_library(my_object_lib OBJECT
16.     lib_source1.cpp
17.     lib_source2.cpp
18. )
20. # 创建接口库（只包含接口，不编译源文件）
21. add_library(my_interface_lib INTERFACE)
22. target_include_directories(my_interface_lib
23.     INTERFACE
24.         ${CMAKE_CURRENT_SOURCE_DIR}/include
25. )

复制代码

4.2 目标属性

现代CMake强调使用目标属性而不是全局变量：

2. # 创建库
3. add_library(my_lib lib.cpp)
5. # 设置库的包含目录
6. target_include_directories(my_lib
7.     PUBLIC
8.         ${CMAKE_CURRENT_SOURCE_DIR}/include
9.     PRIVATE
10.         ${CMAKE_CURRENT_SOURCE_DIR}/src
11. )
13. # 设置库的编译定义
14. target_compile_definitions(my_lib
15.     PRIVATE
16.         LIB_INTERNAL_DEFINE
17.     PUBLIC
18.         LIB_PUBLIC_DEFINE
19. )
21. # 设置库的编译选项
22. target_compile_options(my_lib
23.     PRIVATE
24.         -Wall
25.     PUBLIC
26.         -fno-exceptions
27. )
29. # 链接其他库
30. target_link_libraries(my_lib
31.     PUBLIC
32.         Boost::filesystem
33.     PRIVATE
34.         some_internal_lib
35. )
37. # 创建可执行文件并链接库
38. add_executable(my_app main.cpp)
39. target_link_libraries(my_app
40.     PRIVATE
41.         my_lib
42. )

复制代码

4.3 安装规则

CMake提供了安装规则，允许用户通过make install（或类似命令）安装项目：

2. # 安装目标
3. install(TARGETS my_lib my_app
4.     # 库的安装位置
5.     LIBRARY DESTINATION lib
6.     ARCHIVE DESTINATION lib
7.     RUNTIME DESTINATION bin
8.     # 公共头文件
9.     PUBLIC_HEADER DESTINATION include
10. )
12. # 安装文件
13. install(FILES
14.     ${CMAKE_CURRENT_SOURCE_DIR}/README.md
15.     DESTINATION doc/my_project
16. )
18. # 安装目录
19. install(DIRECTORY
20.     ${CMAKE_CURRENT_SOURCE_DIR}/include/
21.     DESTINATION include
22. )
24. # 安装脚本
25. install(SCRIPT
26.     cmake/post_install.cmake
27. )
29. # 导出配置
30. install(EXPORT MyProjectTargets
31.     FILE MyProjectTargets.cmake
32.     DESTINATION lib/cmake/MyProject
33. )

复制代码

5. 高级技巧

5.1 自定义函数和宏

CMake允许定义自定义函数和宏来封装常用逻辑：

2. # 定义一个简单的函数
3. function(print_message msg)
4.     message(STATUS "Custom message: ${msg}")
5. endfunction()
7. # 调用函数
8. print_message("Hello from function")
10. # 带返回值的函数
11. function(get_project_version result_var)
12.     set(${result_var} ${PROJECT_VERSION} PARENT_SCOPE)
13. endfunction()
15. # 调用函数并获取结果
16. get_project_version(PROJ_VER)
17. message(STATUS "Project version: ${PROJ_VER}")
19. # 带参数的函数
20. function(create_simple_executable name sources)
21.     add_executable(${name} ${sources})
22.     target_include_directories(${name}
23.         PRIVATE
24.             ${CMAKE_CURRENT_SOURCE_DIR}/include
25.     )
26.     target_compile_features(${name}
27.         PRIVATE
28.             cxx_std_17
29.     )
30. endfunction()
32. # 使用函数创建可执行文件
33. create_simple_executable(my_app main.cpp utils.cpp)

复制代码

2. # 定义一个宏
3. macro(print_macro_message msg)
4.     message(STATUS "Macro message: ${msg}")
5.     # 注意：宏中的变量会直接替换，而不是创建新作用域
6.     set(msg "Modified in macro")
7.     message(STATUS "Modified message: ${msg}")
8. endmacro()
10. # 调用宏
11. set(original_msg "Original message")
12. print_macro_message(${original_msg})
13. message(STATUS "After macro call: ${original_msg}")  # 输出: "Modified in macro"

复制代码

5.2 生成器和表达式

CMake提供了强大的生成器表达式，允许在生成时根据不同条件选择值：

2. # 基本生成器表达式
3. add_executable(my_app main.cpp)
5. # 根据配置类型设置不同的定义
6. target_compile_definitions(my_app
7.     PRIVATE
8.         $<$<CONFIG:Debug>:DEBUG_MODE>
9.         $<$<CONFIG:Release>:NDEBUG>
10. )
12. # 根据平台设置不同的编译选项
13. target_compile_options(my_app
14.     PRIVATE
15.         $<$<PLATFORM_ID:Linux>:-fPIC>
16.         $<$<PLATFORM_ID:Windows>:/WX>
17. )
19. # 根据编译器设置不同的标志
20. target_compile_options(my_app
21.     PRIVATE
22.         $<$<CXX_COMPILER_ID:GNU>:-Wall -Wextra>
23.         $<$<CXX_COMPILER_ID:Clang>:-Wall -Wextra>
24.         $<$<CXX_COMPILER_ID:MSVC>:/W4>
25. )
27. # 条件链接
28. target_link_libraries(my_app
29.     PRIVATE
30.         $<$<BOOL:${USE_OPENMP}>:OpenMP::OpenMP_CXX>
31. )

复制代码

5.3 测试和打包

CMake支持与CTest集成进行测试：

2. # 启用测试
3. enable_testing()
5. # 添加测试
6. add_executable(my_test test_main.cpp test_utils.cpp)
7. target_link_libraries(my_test PRIVATE my_lib)
9. # 注册测试
10. add_test(NAME MyTest COMMAND my_test)
12. # 带参数的测试
13. add_test(NAME MyTestWithArgs COMMAND my_test --verbose)
15. # 设置测试属性
16. set_tests_properties(MyTest PROPERTIES
17.     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
18.     TIMEOUT 30
19. )
21. # 添加多个测试
22. function(add_unit_test name sources)
23.     add_executable(${name} ${sources})
24.     target_link_libraries(${name} PRIVATE my_lib)
25.     add_test(NAME ${name} COMMAND ${name})
26. endfunction()
28. add_unit_test(utils_test test_utils.cpp)
29. add_unit_test(math_test test_math.cpp)

复制代码

CMake支持与CPack集成进行打包：

2. # 设置CPack变量
3. set(CPACK_PACKAGE_NAME "MyProject")
4. set(CPACK_PACKAGE_VERSION ${PROJECT_VERSION})
5. set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "My awesome project")
6. set(CPACK_PACKAGE_VENDOR "MyCompany")
8. # 设置包类型
9. set(CPACK_GENERATOR "TGZ;ZIP")
11. # 设置包文件名
12. set(CPACK_PACKAGE_FILE_NAME "myproject-${PROJECT_VERSION}")
14. # 设置包依赖
15. set(CPACK_DEBIAN_PACKAGE_DEPENDS "libboost-all-dev (>= 1.66)")
17. # 包含许可证文件
18. install(FILES LICENSE.txt DESTINATION .)
20. # 包含CPack
21. include(CPack)

复制代码

5.4 跨平台考虑

CMake的一个主要优势是跨平台支持。以下是一些处理跨平台差异的技巧：

2. # 检测操作系统
3. if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
4.     message(STATUS "Building for Linux")
5.     add_definitions(-DLINUX)
6. elseif(CMAKE_SYSTEM_NAME STREQUAL "Windows")
7.     message(STATUS "Building for Windows")
8.     add_definitions(-DWINDOWS)
9. elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
10.     message(STATUS "Building for macOS")
11.     add_definitions(-DMACOS)
12. endif()
14. # 检测处理器架构
15. if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64")
16.     message(STATUS "64-bit architecture")
17.     add_definitions(-DARCH_64BIT)
18. else()
19.     message(STATUS "32-bit architecture")
20.     add_definitions(-DARCH_32BIT)
21. endif()
23. # 跨平台路径处理
24. file(TO_CMAKE_PATH "/path/to/file" FILE_PATH)
25. file(TO_NATIVE_PATH "${FILE_PATH}" NATIVE_PATH)
26. message(STATUS "Native path: ${NATIVE_PATH}")
28. # 跨平台库文件扩展
29. if(WIN32)
30.     set(LIB_EXT ".lib")
31. elseif(APPLE)
32.     set(LIB_EXT ".dylib")
33. else()
34.     set(LIB_EXT ".so")
35. endif()
37. # 使用生成器表达式处理平台特定代码
38. target_sources(my_app
39.     PRIVATE
40.         common.cpp
41.         $<$<PLATFORM_ID:Linux>:linux_specific.cpp>
42.         $<$<PLATFORM_ID:Windows>:windows_specific.cpp>
43.         $<$<PLATFORM_ID:Darwin>:macos_specific.cpp>
44. )

复制代码

6. 最佳实践

6.1 项目结构组织

良好的项目结构使CMake项目更易于维护和理解。以下是一个推荐的项目结构：

2. myproject/
3. ├── CMakeLists.txt          # 主CMakeLists.txt文件
4. ├── README.md
5. ├── LICENSE.txt
6. ├── cmake/                  # CMake模块和脚本
7. │   ├── FindSomeLib.cmake   # 自定义查找模块
8. │   └── MyProjectUtils.cmake # 自定义CMake函数
9. ├── include/                # 公共头文件
10. │   └── myproject/
11. │       ├── utils.h
12. │       └── api.h
13. ├── src/                    # 源文件
14. │   ├── utils.cpp
15. │   └── main.cpp
16. ├── tests/                  # 测试
17. │   ├── CMakeLists.txt
18. │   ├── test_utils.cpp
19. │   └── test_api.cpp
20. ├── examples/               # 示例
21. │   ├── CMakeLists.txt
22. │   └── simple_example.cpp
23. ├── docs/                   # 文档
24. │   └── user_guide.md
25. └── third_party/            # 第三方库
26.     └── some_lib/

复制代码

对应的顶级CMakeLists.txt文件：

2. cmake_minimum_required(VERSION 3.15)
4. project(MyProject
5.     VERSION 1.0.0
6.     DESCRIPTION "My awesome project"
7.     LANGUAGES CXX
8. )
10. # 设置C++标准
11. set(CMAKE_CXX_STANDARD 17)
12. set(CMAKE_CXX_STANDARD_REQUIRED ON)
13. set(CMAKE_CXX_EXTENSIONS OFF)
15. # 添加cmake模块路径
16. list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
18. # 选项
19. option(BUILD_TESTS "Build tests" ON)
20. option(BUILD_EXAMPLES "Build examples" ON)
22. # 查找依赖
23. find_package(Boost 1.66 REQUIRED COMPONENTS filesystem system)
25. # 添加子目录
26. add_subdirectory(src)
27. add_subdirectory(include)
29. if(BUILD_TESTS)
30.     add_subdirectory(tests)
31. endif()
33. if(BUILD_EXAMPLES)
34.     add_subdirectory(examples)
35. endif()
37. # 打包支持
38. include(CPack)

复制代码

6.2 模块化设计

将CMake代码模块化可以提高可重用性和可维护性：

2. # cmake/MyProjectUtils.cmake
4. # 设置编译器警告选项
5. function(set_project_warnings target_name)
6.     set(MSVC_WARNINGS
7.         /W4
8.         /permissive-
9.     )
11.     set(CLANG_WARNINGS
12.         -Wall
13.         -Wextra
14.         -Wpedantic
15.     )
17.     set(GCC_WARNINGS
18.         ${CLANG_WARNINGS}
19.         -Wmisleading-indentation
20.     )
22.     if(MSVC)
23.         set(WARNINGS ${MSVC_WARNINGS})
24.     elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
25.         set(WARNINGS ${CLANG_WARNINGS})
26.     elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
27.         set(WARNINGS ${GCC_WARNINGS})
28.     else()
29.         message(AUTHOR_WARNING "No compiler warnings set for '${CMAKE_CXX_COMPILER_ID}'")
30.     endif()
32.     target_compile_options(${target_name} PRIVATE ${WARNINGS})
33. endfunction()
35. # 设置C++标准
36. function(set_project_cxx_standard target_name std_version)
37.     set_target_properties(${target_name} PROPERTIES
38.         CXX_STANDARD ${std_version}
39.         CXX_STANDARD_REQUIRED ON
40.         CXX_EXTENSIONS OFF
41.     )
42. endfunction()

复制代码

使用自定义模块：

2. # 在主CMakeLists.txt中
3. include(MyProjectUtils)
5. add_library(my_lib src/my_lib.cpp)
7. set_project_warnings(my_lib)
8. set_project_cxx_standard(my_lib 17)

复制代码

6.3 版本控制

良好的版本控制策略对于CMake项目很重要：

2. # 从Git标签获取版本信息
3. find_package(Git QUIET)
4. if(GIT_FOUND AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/.git")
5.     execute_process(
6.         COMMAND ${GIT_EXECUTABLE} describe --tags --abbrev=0
7.         WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
8.         OUTPUT_VARIABLE GIT_TAG
9.         OUTPUT_STRIP_TRAILING_WHITESPACE
10.         ERROR_QUIET
11.     )
12.    
13.     execute_process(
14.         COMMAND ${GIT_EXECUTABLE} rev-parse --short HEAD
15.         WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
16.         OUTPUT_VARIABLE GIT_COMMIT_HASH
17.         OUTPUT_STRIP_TRAILING_WHITESPACE
18.         ERROR_QUIET
19.     )
20.    
21.     if(GIT_TAG)
22.         set(PROJECT_VERSION ${GIT_TAG})
23.     endif()
24.    
25.     if(GIT_COMMIT_HASH)
26.         set(PROJECT_COMMIT ${GIT_COMMIT_HASH})
27.     endif()
28. endif()
30. # 配置版本头文件
31. configure_file(
32.     ${CMAKE_CURRENT_SOURCE_DIR}/include/version.h.in
33.     ${CMAKE_CURRENT_BINARY_DIR}/include/version.h
34.     @ONLY
35. )
37. # 确保生成的头文件被包含
38. include_directories(${CMAKE_CURRENT_BINARY_DIR}/include)

复制代码

对应的version.h.in模板文件：

2. #pragma once
4. #define PROJECT_VERSION "@PROJECT_VERSION@"
5. #define PROJECT_COMMIT "@PROJECT_COMMIT@"
6. #define PROJECT_VERSION_MAJOR "@PROJECT_VERSION_MAJOR@"
7. #define PROJECT_VERSION_MINOR "@PROJECT_VERSION_MINOR@"
8. #define PROJECT_VERSION_PATCH "@PROJECT_VERSION_PATCH@"

复制代码

6.4 性能优化

CMake项目本身的性能优化也很重要，特别是对于大型项目：

2. # 减少冗余配置
3. # 使用CMAKE_CACHE_ARGS而不是多次调用ExternalProject_Add
4. set(CMAKE_ARGS
5.     -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
6.     -DCMAKE_CXX_STANDARD:STRING=${CMAKE_CXX_STANDARD}
7. )
9. # 使用目标属性而不是全局变量
10. # 避免使用include_directories()和link_directories()
11. target_include_directories(my_target
12.     PRIVATE
13.         ${CMAKE_CURRENT_SOURCE_DIR}/include
14. )
16. # 使用编译器预编译头
17. if(MSVC OR CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
18.     target_precompile_headers(my_lib
19.         PRIVATE
20.             ${CMAKE_CURRENT_SOURCE_DIR}/include/pch.h
21.     )
22. endif()
24. # 使用UNITY_BUILD（如果支持）加速编译
25. if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.16)
26.     set_target_properties(my_lib PROPERTIES
27.         UNITY_BUILD ON
28.         UNITY_BUILD_MODE BATCH
29.     )
30. endif()
32. # 使用CMAKE_DISABLE_SOURCE_CHANGES防止源目录被修改
33. set(CMAKE_DISABLE_SOURCE_CHANGES ON)
35. # 使用CMAKE_DISABLE_IN_SOURCE_BUILD防止源内构建
36. if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR})
37.     message(FATAL_ERROR "In-source builds are not allowed. Please create a separate build directory.")
38. endif()

复制代码

7. 实际案例

7.1 简单项目示例

让我们创建一个简单的项目，包含一个库和一个可执行文件：

项目结构：

2. simple_project/
3. ├── CMakeLists.txt
4. ├── include/
5. │   └── greeter.h
6. └── src/
7.     ├── greeter.cpp
8.     └── main.cpp

复制代码

include/greeter.h:

2. #pragma once
3. #include <string>
5. class Greeter {
6. public:
7.     explicit Greeter(const std::string& name);
8.     void greet() const;
9. private:
10.     std::string name_;
11. };

复制代码

src/greeter.cpp:

2. #include "greeter.h"
3. #include <iostream>
5. Greeter::Greeter(const std::string& name) : name_(name) {}
7. void Greeter::greet() const {
8.     std::cout << "Hello, " << name_ << "!" << std::endl;
9. }

复制代码

src/main.cpp:

2. #include "greeter.h"
4. int main() {
5.     Greeter greeter("World");
6.     greeter.greet();
7.     return 0;
8. }

复制代码

CMakeLists.txt:

2. cmake_minimum_required(VERSION 3.10)
4. project(SimpleProject
5.     VERSION 1.0.0
6.     DESCRIPTION "A simple project example"
7.     LANGUAGES CXX
8. )
10. # 设置C++标准
11. set(CMAKE_CXX_STANDARD 14)
12. set(CMAKE_CXX_STANDARD_REQUIRED ON)
14. # 添加库
15. add_library(greeter_lib
16.     src/greeter.cpp
17. )
19. target_include_directories(greeter_lib
20.     PUBLIC
21.         ${CMAKE_CURRENT_SOURCE_DIR}/include
22. )
24. # 添加可执行文件
25. add_executable(greeter_app
26.     src/main.cpp
27. )
29. target_link_libraries(greeter_app
30.     PRIVATE
31.         greeter_lib
32. )
34. # 安装规则
35. install(TARGETS greeter_lib greeter_app
36.     LIBRARY DESTINATION lib
37.     RUNTIME DESTINATION bin
38. )
40. install(DIRECTORY include/
41.     DESTINATION include
42. )

复制代码

7.2 复杂项目示例

现在看一个更复杂的项目，包含多个库、测试和第三方依赖：

项目结构：

2. complex_project/
3. ├── CMakeLists.txt
4. ├── cmake/
5. │   └── ProjectUtils.cmake
6. ├── include/
7. │   └── project/
8. │       ├── core.h
9. │       └── utils.h
10. ├── src/
11. │   ├── core/
12. │   │   ├── CMakeLists.txt
13. │   │   └── core.cpp
14. │   ├── utils/
15. │   │   ├── CMakeLists.txt
16. │   │   └── utils.cpp
17. │   └── app/
18. │       ├── CMakeLists.txt
19. │       └── main.cpp
20. ├── tests/
21. │   ├── CMakeLists.txt
22. │   ├── test_core.cpp
23. │   └── test_utils.cpp
24. ├── external/
25. │   └── CMakeLists.txt
26. └── docs/
27.     └── CMakeLists.txt

复制代码

主CMakeLists.txt:

2. cmake_minimum_required(VERSION 3.15)
4. project(ComplexProject
5.     VERSION 1.0.0
6.     DESCRIPTION "A complex project example"
7.     LANGUAGES CXX
8. )
10. # 添加cmake模块路径
11. list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
13. # 包含项目工具
14. include(ProjectUtils)
16. # 设置C++标准
17. set(CMAKE_CXX_STANDARD 17)
18. set(CMAKE_CXX_STANDARD_REQUIRED ON)
19. set(CMAKE_CXX_EXTENSIONS OFF)
21. # 选项
22. option(BUILD_TESTS "Build tests" ON)
23. option(BUILD_DOCS "Build documentation" OFF)
25. # 添加第三方依赖
26. add_subdirectory(external)
28. # 添加子目录
29. add_subdirectory(include)
30. add_subdirectory(src)
31. add_subdirectory(tests)
33. if(BUILD_DOCS)
34.     add_subdirectory(docs)
35. endif()
37. # 配置和打包
38. include(CPack)

复制代码

cmake/ProjectUtils.cmake:

2. # 设置常用编译器警告
3. function(set_target_warnings target_name)
4.     set(MSVC_WARNINGS
5.         /W4
6.         /permissive-
7.     )
9.     set(CLANG_WARNINGS
10.         -Wall
11.         -Wextra
12.         -Wpedantic
13.     )
15.     set(GCC_WARNINGS
16.         ${CLANG_WARNINGS}
17.         -Wmisleading-indentation
18.     )
20.     if(MSVC)
21.         set(WARNINGS ${MSVC_WARNINGS})
22.     elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
23.         set(WARNINGS ${CLANG_WARNINGS})
24.     elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
25.         set(WARNINGS ${GCC_WARNINGS})
26.     else()
27.         message(AUTHOR_WARNING "No compiler warnings set for '${CMAKE_CXX_COMPILER_ID}'")
28.     endif()
30.     target_compile_options(${target_name} PRIVATE ${WARNINGS})
31. endfunction()
33. # 设置目标属性
34. function(set_project_target_properties target_name)
35.     set_target_properties(${target_name} PROPERTIES
36.         CXX_STANDARD 17
37.         CXX_STANDARD_REQUIRED ON
38.         CXX_EXTENSIONS OFF
39.     )
40.    
41.     set_target_warnings(${target_name})
42. endfunction()

复制代码

src/core/CMakeLists.txt:

2. add_library(core_lib
3.     core.cpp
4. )
6. target_include_directories(core_lib
7.     PUBLIC
8.         ${CMAKE_CURRENT_SOURCE_DIR}/../../include
9. )
11. set_project_target_properties(core_lib)
13. # 链接第三方库
14. target_link_libraries(core_lib
15.     PUBLIC
16.         fmt::fmt
17. )

复制代码

src/utils/CMakeLists.txt:

2. add_library(utils_lib
3.     utils.cpp
4. )
6. target_include_directories(utils_lib
7.     PUBLIC
8.         ${CMAKE_CURRENT_SOURCE_DIR}/../../include
9. )
11. set_project_target_properties(utils_lib)
13. # 链接核心库
14. target_link_libraries(utils_lib
15.     PUBLIC
16.         core_lib
17. )

复制代码

src/app/CMakeLists.txt:

2. add_executable(complex_app
3.     main.cpp
4. )
6. target_include_directories(complex_app
7.     PRIVATE
8.         ${CMAKE_CURRENT_SOURCE_DIR}/../../include
9. )
11. set_project_target_properties(complex_app)
13. # 链接所有库
14. target_link_libraries(complex_app
15.     PRIVATE
16.         core_lib
17.         utils_lib
18. )
20. # 安装规则
21. install(TARGETS complex_app
22.     RUNTIME DESTINATION bin
23. )

复制代码

tests/CMakeLists.txt:

2. enable_testing()
4. add_executable(test_suite
5.     test_core.cpp
6.     test_utils.cpp
7. )
9. target_include_directories(test_suite
10.     PRIVATE
11.         ${CMAKE_CURRENT_SOURCE_DIR}/../include
12. )
14. target_link_libraries(test_suite
15.     PRIVATE
16.         core_lib
17.         utils_lib
18.         Catch2::Catch2
19. )
21. add_test(NAME TestSuite COMMAND test_suite)

复制代码

external/CMakeLists.txt:

2. # 使用FetchContent下载第三方库
3. include(FetchContent)
5. # 添加fmt库
6. FetchContent_Declare(
7.     fmt
8.     GIT_REPOSITORY https://github.com/fmtlib/fmt.git
9.     GIT_TAG 8.1.1
10. )
12. FetchContent_MakeAvailable(fmt)
14. # 添加Catch2测试框架
15. FetchContent_Declare(
16.     Catch2
17.     GIT_REPOSITORY https://github.com/catchorg/Catch2.git
18.     GIT_TAG v3.0.1
19. )
21. FetchContent_MakeAvailable(Catch2)

复制代码

7.3 第三方库集成

CMake提供了多种方式来集成第三方库，以下是几种常见的方法：

2. # 查找已安装的库
3. find_package(Boost 1.66 REQUIRED COMPONENTS filesystem system)
4. find_package(OpenGL REQUIRED)
5. find_package(PkgConfig REQUIRED)
6. pkg_check_modules(SDL2 REQUIRED sdl2)
8. # 使用找到的库
9. add_executable(my_app main.cpp)
10. target_link_libraries(my_app
11.     PRIVATE
12.         Boost::filesystem
13.         Boost::system
14.         OpenGL::GL
15.         ${SDL2_LIBRARIES}
16. )
17. target_include_directories(my_app
18.     PRIVATE
19.         ${SDL2_INCLUDE_DIRS}
20. )

复制代码

2. include(FetchContent)
4. # 声明要获取的项目
5. FetchContent_Declare(
6.     googletest
7.     GIT_REPOSITORY https://github.com/google/googletest.git
8.     GIT_TAG release-1.11.0
9. )
11. # 获取内容并使其可用
12. FetchContent_MakeAvailable(googletest)
14. # 现在可以使用GTest
15. add_executable(my_test test_main.cpp)
16. target_link_libraries(my_test
17.     PRIVATE
18.         gtest
19.         gtest_main
20. )

复制代码

2. include(ExternalProject)
4. # 设置外部项目
5. ExternalProject_Add(
6.     external_lib
7.     GIT_REPOSITORY https://github.com/example/external_lib.git
8.     GIT_TAG master
9.     SOURCE_DIR "${CMAKE_CURRENT_BINARY_DIR}/external_lib-src"
10.     BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}/external_lib-build"
11.     CMAKE_ARGS
12.         -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
13.         -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
14.     INSTALL_COMMAND ""
15. )
17. # 创建导入的目标
18. add_library(external_lib::external_lib STATIC IMPORTED)
19. set_target_properties(external_lib::external_lib PROPERTIES
20.     IMPORTED_LOCATION "${CMAKE_CURRENT_BINARY_DIR}/external_lib-build/libexternal_lib.a"
21.     INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_CURRENT_BINARY_DIR}/external_lib-src/include"
22. )
24. # 添加依赖关系
25. add_dependencies(external_lib::external_lib external_lib)
27. # 使用外部库
28. add_executable(my_app main.cpp)
29. target_link_libraries(my_app
30.     PRIVATE
31.         external_lib::external_lib
32. )

复制代码

2. # 需要先安装conan并创建conanfile.txt或conanfile.py
4. # 在CMakeLists.txt中
5. if(NOT EXISTS "${CMAKE_BINARY_DIR}/conan.cmake")
6.     message(STATUS "Downloading conan.cmake...")
7.     file(DOWNLOAD
8.         https://github.com/conan-io/cmake-conan/raw/v0.15/conan.cmake
9.         "${CMAKE_BINARY_DIR}/conan.cmake"
10.     )
11. endif()
13. include(${CMAKE_BINARY_DIR}/conan.cmake)
15. conan_cmake_run(REQUIRES
16.     fmt/8.1.1
17.     catch2/3.0.1
18.     BASIC_SETUP
19.     BUILD missing)
21. # 现在可以使用conan安装的库
22. add_executable(my_app main.cpp)
23. target_link_libraries(my_app
24.     PRIVATE
25.         CONAN_LIBS
26. )

复制代码

8. 总结与展望

CMake是一个强大而灵活的构建系统，它为C++项目提供了跨平台构建能力。通过本文，我们详细介绍了CMake的基础语法、项目配置、构建系统、高级技巧和最佳实践，并通过实际案例展示了如何应用这些知识。

掌握CMake的关键点包括：

1. 理解现代CMake的理念：使用目标属性而不是全局变量，使用target_*命令而不是全局命令。
2. 良好的项目结构：合理组织源文件、头文件、测试和文档，使项目易于维护。
3. 模块化设计：将常用的CMake代码封装为函数和宏，提高代码重用性。
4. 跨平台考虑：使用CMake提供的工具处理不同平台之间的差异。
5. 依赖管理：熟练使用find_package、FetchContent和ExternalProject_Add等工具管理项目依赖。

理解现代CMake的理念：使用目标属性而不是全局变量，使用target_*命令而不是全局命令。

良好的项目结构：合理组织源文件、头文件、测试和文档，使项目易于维护。

模块化设计：将常用的CMake代码封装为函数和宏，提高代码重用性。

跨平台考虑：使用CMake提供的工具处理不同平台之间的差异。

依赖管理：熟练使用find_package、FetchContent和ExternalProject_Add等工具管理项目依赖。

随着C++生态系统的发展，CMake也在不断演进。未来，我们可以期待CMake在以下方面的改进：

1. 更好的包管理支持：与C++包管理器（如conan、vcpkg）的更紧密集成。
2. 更快的构建速度：通过改进生成器和构建系统的性能，减少构建时间。
3. 更强大的语言特性：CMake语言可能会增加更多现代编程语言的特性，使其更易于使用。
4. 更好的IDE集成：与各种IDE的更紧密集成，提供更好的开发体验。

更好的包管理支持：与C++包管理器（如conan、vcpkg）的更紧密集成。

更快的构建速度：通过改进生成器和构建系统的性能，减少构建时间。

更强大的语言特性：CMake语言可能会增加更多现代编程语言的特性，使其更易于使用。

更好的IDE集成：与各种IDE的更紧密集成，提供更好的开发体验。

通过持续学习和实践，开发者可以充分利用CMake的强大功能，高效地管理复杂项目的构建过程。希望本文能帮助读者深入理解CMake，并在实际项目中应用这些知识。