深入浅出CMake构建文件编写打造高效可维护的跨平台项目构建系统

威震华夏关云长

引言

CMake是一个开源、跨平台的构建自动化工具，它使用平台无关的配置文件来控制软件编译过程，并生成标准的构建文件（如Unix的Makefile或Windows Visual Studio的项目文件）。CMake的设计初衷是解决跨平台构建的问题，使开发者能够用一套构建逻辑管理不同平台上的项目构建。

在现代软件开发中，项目规模日益庞大，依赖关系复杂，跨平台需求普遍，一个高效、可维护的构建系统变得至关重要。CMake凭借其强大的功能和灵活的设计，成为了许多大型项目的首选构建工具，如OpenCV、VTK、KDE等。

本文将深入浅出地介绍CMake构建文件的编写方法，帮助读者打造高效可维护的跨平台项目构建系统。

CMake基础

CMake的基本语法

CMake脚本使用CMake语言编写，这种语言相对简单，主要由命令、变量和注释组成。命令不区分大小写，但参数是区分大小写的。以下是一个基本的CMake脚本示例：

2. # 这是一个CMake注释
3. cmake_minimum_required(VERSION 3.10)  # 要求CMake最低版本
4. project(MyProject)                    # 定义项目名称
6. # 添加一个可执行文件
7. add_executable(my_app main.cpp)

复制代码

变量

CMake中的变量使用set()命令设置，使用${VAR}语法引用：

2. # 设置变量
3. set(MY_VARIABLE "Hello, CMake!")
5. # 引用变量
6. message(STATUS "${MY_VARIABLE}")  # 输出: -- Hello, CMake!

复制代码

CMake也有一些预定义的变量，如PROJECT_SOURCE_DIR（项目根目录）、CMAKE_CURRENT_SOURCE_DIR（当前CMakeLists.txt所在目录）等。

控制流

CMake提供了基本的控制流结构，如条件判断和循环：

2. # 条件判断
3. if(WIN32)
4.     message(STATUS "Windows platform")
5. elseif(UNIX AND NOT APPLE)
6.     message(STATUS "Linux platform")
7. else()
8.     message(STATUS "Other platform")
9. endif()
11. # 循环
12. set(MY_LIST item1 item2 item3)
13. foreach(item ${MY_LIST})
14.     message(STATUS "${item}")
15. endforeach()

复制代码

项目结构

一个典型的CMake项目结构如下：

2. my_project/
3. ├── CMakeLists.txt          # 主CMake配置文件
4. ├── src/                    # 源代码目录
5. │   ├── CMakeLists.txt      # src子目录的CMake配置
6. │   ├── module1/
7. │   │   ├── CMakeLists.txt
8. │   │   ├── module1.cpp
9. │   │   └── module1.h
10. │   └── module2/
11. │       ├── CMakeLists.txt
12. │       ├── module2.cpp
13. │       └── module2.h
14. ├── include/                # 公共头文件目录
15. │   └── my_project/
16. │       └── common.h
17. ├── tests/                  # 测试目录
18. │   ├── CMakeLists.txt
19. │   └── test_module1.cpp
20. ├── third_party/            # 第三方库
21. │   └── some_library/
22. └── cmake/                  # 自定义CMake模块
23.     └── FindSomeLib.cmake

复制代码

这种结构将源代码、头文件、测试和第三方库分离开来，使项目更加清晰和易于维护。

主CMakeLists.txt

主CMakeLists.txt文件通常位于项目根目录，它负责设置项目全局配置和构建目标：

2. # 要求CMake最低版本
3. cmake_minimum_required(VERSION 3.10)
5. # 定义项目名称和版本
6. project(MyProject VERSION 1.0.0 LANGUAGES CXX)
8. # 设置C++标准
9. set(CMAKE_CXX_STANDARD 17)
10. set(CMAKE_CXX_STANDARD_REQUIRED ON)
12. # 添加编译选项
13. if(MSVC)
14.     add_compile_options(/W4)
15. else()
16.     add_compile_options(-Wall -Wextra -Wpedantic)
17. endif()
19. # 添加子目录
20. add_subdirectory(src)
21. add_subdirectory(tests)

复制代码

子目录CMakeLists.txt

每个子目录可以有自己的CMakeLists.txt文件，用于定义该目录下的构建目标：

2. # src/CMakeLists.txt
4. # 添加子目录
5. add_subdirectory(module1)
6. add_subdirectory(module2)
8. # 创建库
9. add_library(my_project_lib STATIC
10.     module1/module1.cpp
11.     module2/module2.cpp
12. )
14. # 设置包含目录
15. target_include_directories(my_project_lib
16.     PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../include
17. )
19. # 链接库
20. target_link_libraries(my_project_lib
21.     PUBLIC some_other_library
22. )

复制代码

常用CMake命令详解

project()

project()命令用于定义项目名称，并可选地指定版本、描述、语言等：

2. project(MyProject VERSION 1.0.0 DESCRIPTION "My awesome project" LANGUAGES CXX)

复制代码

执行此命令后，CMake会自动定义一些变量，如PROJECT_NAME、PROJECT_VERSION等。

add_executable()

add_executable()命令用于添加一个可执行文件目标：

2. # 简单形式
3. add_executable(my_app main.cpp)
5. # 指定源文件列表
6. set(SOURCES
7.     main.cpp
8.     utils.cpp
9.     config.cpp
10. )
11. add_executable(my_app ${SOURCES})
13. # 指定别名（CMake 3.13+）
14. add_executable(my_app ALIAS my_app_real)

复制代码

add_library()

add_library()命令用于添加一个库目标，可以是静态库、共享库或模块库：

2. # 静态库
3. add_library(my_lib STATIC utils.cpp)
5. # 共享库
6. add_library(my_lib SHARED utils.cpp)
8. # 模块库
9. add_library(my_lib MODULE utils.cpp)
11. # 接口库（仅包含接口，不生成编译文件）
12. add_library(my_lib INTERFACE)

复制代码

target_include_directories()

target_include_directories()命令用于为目标设置包含目录：

2. # 为my_lib目标设置包含目录
3. target_include_directories(my_lib
4.     PUBLIC
5.         ${CMAKE_CURRENT_SOURCE_DIR}/include
6.     PRIVATE
7.         ${CMAKE_CURRENT_SOURCE_DIR}/src
8.     INTERFACE
9.         ${CMAKE_CURRENT_SOURCE_DIR}/api
10. )

复制代码

这里的PUBLIC、PRIVATE和INTERFACE指定了包含目录的传递性：

• PUBLIC：当前目标使用，并且会传递给链接此目标的目标
• PRIVATE：仅当前目标使用，不传递
• INTERFACE：不用于当前目标，只传递给链接此目标的目标

target_link_libraries()

target_link_libraries()命令用于为目标链接库：

2. # 链接库
3. target_link_libraries(my_app
4.     PRIVATE
5.         some_static_lib
6.     PUBLIC
7.         some_shared_lib
8.     INTERFACE
9.         some_interface_lib
10. )

复制代码

与target_include_directories()类似，PRIVATE、PUBLIC和INTERFACE指定了链接库的传递性。

find_package()

find_package()命令用于查找和加载外部项目：

2. # 查找Boost库
3. find_package(Boost 1.66 REQUIRED COMPONENTS filesystem system)
5. # 如果找到，则使用
6. if(Boost_FOUND)
7.     target_include_directories(my_app
8.         PRIVATE ${Boost_INCLUDE_DIRS}
9.     )
10.     target_link_libraries(my_app
11.         PRIVATE ${Boost_LIBRARIES}
12.     )
13. endif()

复制代码

include_directories()与link_directories()

虽然target_include_directories()和target_link_libraries()是更现代、更推荐的做法，但在某些情况下，使用全局的include_directories()和link_directories()可能更方便：

2. # 全局包含目录
3. include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
5. # 全局链接目录
6. link_directories(${CMAKE_CURRENT_SOURCE_DIR}/lib)

复制代码

add_subdirectory()

add_subdirectory()命令用于添加并构建子目录：

2. # 添加子目录
3. add_subdirectory(src)
4. add_subdirectory(tests EXCLUDE_FROM_ALL)  # EXCLUDE_FROM_ALL表示默认不构建

复制代码

option()

option()命令用于定义一个布尔选项，用户可以在配置时设置：

2. # 定义选项
3. option(ENABLE_TESTS "Enable building tests" ON)
5. # 根据选项执行不同操作
6. if(ENABLE_TESTS)
7.     add_subdirectory(tests)
8. endif()

复制代码

条件编译和跨平台处理

CMake提供了多种方式来处理不同平台和编译器的差异，实现条件编译。

平台检测

CMake提供了一些预定义的变量来检测当前平台：

2. # Windows平台
3. if(WIN32)
4.     # Windows特定代码
5.     add_definitions(-DWINDOWS_PLATFORM)
6. endif()
8. # Unix-like系统
9. if(UNIX)
10.     # Unix特定代码
11.     add_definitions(-DUNIX_PLATFORM)
12. endif()
14. # Linux系统
15. if(UNIX AND NOT APPLE)
16.     # Linux特定代码
17.     add_definitions(-DLINUX_PLATFORM)
18. endif()
20. # macOS系统
21. if(APPLE)
22.     # macOS特定代码
23.     add_definitions(-DMACOS_PLATFORM)
24. endif()

复制代码

编译器检测

CMake也提供了检测编译器的方法：

2. # MSVC编译器
3. if(MSVC)
4.     add_compile_options(/W4 /permissive-)
5. endif()
7. # GCC编译器
8. if(CMAKE_COMPILER_IS_GNUCXX)
9.     add_compile_options(-Wall -Wextra -Wpedantic)
10. endif()
12. # Clang编译器
13. if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
14.     add_compile_options(-Wall -Wextra -Wpedantic)
15. endif()

复制代码

生成器表达式

生成器表达式是CMake中一种强大的条件表达式，可以在构建时根据条件生成不同的值：

2. # 根据配置类型设置不同的定义
3. target_compile_definitions(my_lib
4.     PRIVATE
5.         $<$<CONFIG:Debug>:DEBUG_BUILD>
6.         $<$<CONFIG:Release>:NDEBUG>
7. )
9. # 根据平台设置不同的链接库
10. target_link_libraries(my_app
11.     PRIVATE
12.         $<$<PLATFORM_ID:Windows>:ws2_32>
13.         $<$<PLATFORM_ID:Linux>:dl>
14. )

复制代码

配置类型处理

CMake支持多种配置类型，如Debug、Release、RelWithDebInfo和MinSizeRel：

2. # 根据配置类型设置不同的编译选项
3. if(CMAKE_BUILD_TYPE STREQUAL "Debug")
4.     add_compile_options(-g -O0)
5. elseif(CMAKE_BUILD_TYPE STREQUAL "Release")
6.     add_compile_options(-O3 -DNDEBUG)
7. elseif(CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
8.     add_compile_options(-g -O2 -DNDEBUG)
9. elseif(CMAKE_BUILD_TYPE STREQUAL "MinSizeRel")
10.     add_compile_options(-Os -DNDEBUG)
11. endif()

复制代码

依赖管理：查找和链接库

在复杂项目中，依赖管理是一个关键问题。CMake提供了多种方式来查找和链接外部库。

find_package()详解

find_package()是CMake中查找外部库的主要方式。它有两种模式：Module模式和Config模式。

Module模式下，CMake会查找名为Find<PackageName>.cmake的文件。这些文件通常包含查找库的逻辑：

2. # 查找OpenCV库
3. find_package(OpenCV REQUIRED)
5. # 如果找到，使用它
6. if(OpenCV_FOUND)
7.     message(STATUS "OpenCV found: ${OpenCV_VERSION}")
8.     target_include_directories(my_app
9.         PRIVATE ${OpenCV_INCLUDE_DIRS}
10.     )
11.     target_link_libraries(my_app
12.         PRIVATE ${OpenCV_LIBS}
13.     )
14. endif()

复制代码

Config模式下，CMake会查找名为<PackageName>Config.cmake或<lower-case-package-name>-config.cmake的文件。这些文件通常由库的安装过程生成：

2. # 查找Eigen3库
3. find_package(Eigen3 REQUIRED NO_MODULE)
5. # 如果找到，使用它
6. if(Eigen3_FOUND)
7.     message(STATUS "Eigen3 found: ${Eigen3_VERSION}")
8.     target_link_libraries(my_app
9.         PRIVATE Eigen3::Eigen
10.     )
11. endif()

复制代码

自定义Find模块

如果CMake没有提供某个库的Find模块，你可以自己创建一个。例如，创建一个FindMyLib.cmake文件：

2. # 尝试查找头文件
3. find_path(MYLIB_INCLUDE_DIR
4.     NAMES mylib.h
5.     PATHS /usr/include /usr/local/include
6. )
8. # 尝试查找库文件
9. find_library(MYLIB_LIBRARY
10.     NAMES mylib
11.     PATHS /usr/lib /usr/local/lib
12. )
14. # 设置变量
15. include(FindPackageHandleStandardArgs)
16. find_package_handle_standard_args(MyLib
17.     DEFAULT_MSG
18.     MYLIB_INCLUDE_DIR
19.     MYLIB_LIBRARY
20. )
22. # 如果找到，创建导入目标
23. if(MYLIB_FOUND)
24.     add_library(MyLib::MyLib UNKNOWN IMPORTED)
25.     set_target_properties(MyLib::MyLib PROPERTIES
26.         INTERFACE_INCLUDE_DIRECTORIES "${MYLIB_INCLUDE_DIR}"
27.         IMPORTED_LOCATION "${MYLIB_LIBRARY}"
28.     )
29. endif()

复制代码

FetchContent

CMake 3.11引入了FetchContent模块，允许在配置时下载和构建依赖项：

2. include(FetchContent)
4. # 声明要获取的内容
5. FetchContent_Declare(
6.     googletest
7.     GIT_REPOSITORY https://github.com/google/googletest.git
8.     GIT_TAG main
9. )
11. # 获取内容
12. FetchContent_MakeAvailable(googletest)
14. # 使用获取的内容
15. target_link_libraries(my_test
16.     PRIVATE gtest_main
17. )

复制代码

ExternalProject

ExternalProject模块提供了更强大的外部项目管理功能，允许在构建时下载、配置、构建和安装外部项目：

2. include(ExternalProject)
4. # 定义外部项目
5. ExternalProject_Add(
6.     some_external_lib
7.     GIT_REPOSITORY https://github.com/example/some_external_lib.git
8.     GIT_TAG main
9.     CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}
10.     INSTALL_DIR ${CMAKE_INSTALL_PREFIX}
11. )
13. # 创建导入目标
14. add_library(some_external_lib STATIC IMPORTED)
15. set_target_properties(some_external_lib PROPERTIES
16.     IMPORTED_LOCATION ${CMAKE_INSTALL_PREFIX}/lib/libsome_external_lib.a
17.     INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_INSTALL_PREFIX}/include
18. )
20. # 添加依赖关系
21. add_dependencies(some_external_lib some_external_lib)

复制代码

conan支持

Conan是一个流行的C++包管理器，CMake可以与Conan集成来管理依赖：

2. # 在项目根目录创建conanfile.txt或conanfile.py
3. # 然后在CMakeLists.txt中添加：
5. # 如果conan安装了依赖
6. if(EXISTS "${CMAKE_BINARY_DIR}/conanbuildinfo.cmake")
7.     include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
8.     conan_basic_setup()
9. endif()
11. # 使用conan提供的库
12. target_link_libraries(my_app
13.     PRIVATE ${CONAN_LIBS}
14. )

复制代码

安装和打包

CMake提供了安装和打包功能，使项目可以轻松地分发和部署。

install()命令

install()命令用于指定安装规则：

2. # 安装目标
3. install(TARGETS my_lib my_app
4.     EXPORT my_targets
5.     LIBRARY DESTINATION lib
6.     ARCHIVE DESTINATION lib
7.     RUNTIME DESTINATION bin
8.     PUBLIC_HEADER DESTINATION include
9. )
11. # 安装文件
12. install(FILES
13.     ${CMAKE_CURRENT_SOURCE_DIR}/README.md
14.     DESTINATION doc
15. )
17. # 安装目录
18. install(DIRECTORY
19.     ${CMAKE_CURRENT_SOURCE_DIR}/include/
20.     DESTINATION include
21. )
23. # 安装脚本
24. install(PROGRAMS
25.     ${CMAKE_CURRENT_SOURCE_DIR}/scripts/myscript.sh
26.     DESTINATION bin
27. )

复制代码

导出配置

为了使其他项目可以轻松地使用你的库，可以导出配置：

2. # 导出目标
3. install(EXPORT my_targets
4.     FILE MyTargets.cmake
5.     NAMESPACE My::
6.     DESTINATION lib/cmake/My
7. )
9. # 创建配置文件
10. include(CMakePackageConfigHelpers)
11. write_basic_package_version_file(
12.     "${CMAKE_CURRENT_BINARY_DIR}/MyConfigVersion.cmake"
13.     VERSION ${PROJECT_VERSION}
14.     COMPATIBILITY AnyNewerVersion
15. )
17. # 安装配置文件
18. install(FILES
19.     "${CMAKE_CURRENT_BINARY_DIR}/MyConfigVersion.cmake"
20.     "${CMAKE_CURRENT_SOURCE_DIR}/cmake/MyConfig.cmake"
21.     DESTINATION lib/cmake/My
22. )

复制代码

CPack打包

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. if(WIN32)
10.     set(CPACK_GENERATOR "NSIS")
11. elseif(APPLE)
12.     set(CPACK_GENERATOR "DragNDrop")
13. else()
14.     set(CPACK_GENERATOR "DEB;RPM")
15. endif()
17. # 包含CPack
18. include(CPack)

复制代码

然后，在构建项目后，可以运行cpack命令来创建安装包。

高级技巧和最佳实践

使用现代CMake实践

现代CMake（通常指CMake 3.0+）推荐使用基于目标的命令，而不是全局命令：

2. # 传统方式（不推荐）
3. include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
4. link_directories(${CMAKE_CURRENT_SOURCE_DIR}/lib)
5. add_executable(my_app main.cpp)
6. target_link_libraries(my_app my_lib)
8. # 现代方式（推荐）
9. add_executable(my_app main.cpp)
10. target_include_directories(my_app
11.     PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include
12. )
13. target_link_libraries(my_app
14.     PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/lib/libmy_lib.a
15. )

复制代码

创建和使用函数

CMake支持创建函数来封装重复的逻辑：

2. # 定义函数
3. function(add_my_library name)
4.     set(sources ${ARGN})
5.    
6.     add_library(${name} STATIC ${sources})
7.     target_include_directories(${name}
8.         PUBLIC
9.             ${CMAKE_CURRENT_SOURCE_DIR}/include
10.     )
11.     target_compile_features(${name}
12.         PUBLIC
13.             cxx_std_17
14.     )
15. endfunction()
17. # 使用函数
18. add_my_library(my_lib
19.     src/my_lib.cpp
20.     src/utils.cpp
21. )

复制代码

创建和使用宏

与函数不同，宏不会创建新的作用域，但可以用于代码生成：

2. # 定义宏
3. macro(configure_target target)
4.     target_compile_features(${target}
5.         PUBLIC
6.             cxx_std_17
7.     )
8.    
9.     if(MSVC)
10.         target_compile_options(${target}
11.             PRIVATE
12.                 /W4
13.         )
14.     else()
15.         target_compile_options(${target}
16.             PRIVATE
17.                 -Wall -Wextra -Wpedantic
18.         )
19.     endif()
20. endmacro()
22. # 使用宏
23. add_executable(my_app main.cpp)
24. configure_target(my_app)

复制代码

使用CMake的测试功能

CMake集成了CTest测试工具，可以方便地添加和运行测试：

2. # 启用测试
3. enable_testing()
5. # 添加测试
6. add_executable(my_test test/my_test.cpp)
7. target_link_libraries(my_test
8.     PRIVATE my_lib
9.     gtest
10. )
12. # 添加测试用例
13. add_test(
14.     NAME my_test
15.     COMMAND my_test
16. )
18. # 设置测试属性
19. set_tests_properties(my_test
20.     PROPERTIES
21.         WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
22. )

复制代码

使用CMake的文档生成

CMake可以与Doxygen等文档生成工具集成：

2. # 查找Doxygen
3. find_package(Doxygen)
5. # 如果找到，创建文档目标
6. if(Doxygen_FOUND)
7.     set(DOXYGEN_INPUT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include)
8.     set(DOXYGEN_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR}/docs)
9.     set(DOXYGEN_INDEX_FILE ${DOXYGEN_OUTPUT_DIR}/html/index.html)
10.    
11.     # 配置Doxygen模板文件
12.     configure_file(
13.         ${CMAKE_CURRENT_SOURCE_DIR}/cmake/Doxyfile.in
14.         ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
15.         @ONLY
16.     )
17.    
18.     # 添加自定义目标来生成文档
19.     add_custom_target(docs
20.         COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
21.         WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
22.         COMMENT "Generating API documentation with Doxygen"
23.         VERBATIM
24.     )
25.    
26.     # 添加安装规则
27.     install(DIRECTORY ${DOXYGEN_OUTPUT_DIR}/html
28.         DESTINATION share/doc/my_project
29.     )
30. endif()

复制代码

使用CMake的格式化和静态分析

为了保持CMake脚本的一致性和质量，可以使用格式化和静态分析工具：

2. # 添加格式化目标
3. find_program(CMAKE_FORMAT cmake-format)
4. if(CMAKE_FORMAT)
5.     file(GLOB_RECURSE CMAKE_FILES
6.         ${CMAKE_CURRENT_SOURCE_DIR}/*.cmake
7.         ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
8.     )
9.    
10.     add_custom_target(format-cmake
11.         COMMAND ${CMAKE_FORMAT} -i ${CMAKE_FILES}
12.         COMMENT "Formatting CMake files"
13.         VERBATIM
14.     )
15. endif()
17. # 添加静态分析目标
18. find_program(CMAKE_LINT cmake-lint)
19. if(CMAKE_LINT)
20.     add_custom_target(lint-cmake
21.         COMMAND ${CMAKE_LINT} ${CMAKE_FILES}
22.         COMMENT "Linting CMake files"
23.         VERBATIM
24.     )
25. endif()

复制代码

实际案例分析

让我们通过一个实际案例来综合运用前面介绍的知识。假设我们要构建一个名为”ImageProcessor”的跨平台图像处理库，包含以下功能：

1. 基本图像操作（旋转、缩放、裁剪）
2. 滤镜功能（灰度、模糊、锐化）
3. 支持多种图像格式（JPEG、PNG）
4. 提供命令行工具和GUI界面

项目结构

2. ImageProcessor/
3. ├── CMakeLists.txt              # 主CMake配置文件
4. ├── README.md
5. ├── LICENSE
6. ├── include/                    # 公共头文件
7. │   └── imageprocessor/
8. │       ├── core.h
9. │       ├── filters.h
10. │       ├── io.h
11. │       └── utils.h
12. ├── src/                        # 源代码
13. │   ├── CMakeLists.txt
14. │   ├── core/
15. │   │   ├── CMakeLists.txt
16. │   │   ├── image.cpp
17. │   │   └── operations.cpp
18. │   ├── filters/
19. │   │   ├── CMakeLists.txt
20. │   │   ├── grayscale.cpp
21. │   │   ├── blur.cpp
22. │   │   └── sharpen.cpp
23. │   ├── io/
24. │   │   ├── CMakeLists.txt
25. │   │   ├── jpeg.cpp
26. │   │   └── png.cpp
27. │   └── utils/
28. │       ├── CMakeLists.txt
29. │       └── common.cpp
30. ├── apps/                       # 应用程序
31. │   ├── CMakeLists.txt
32. │   ├── cli/
33. │   │   ├── CMakeLists.txt
34. │   │   └── main.cpp
35. │   └── gui/
36. │       ├── CMakeLists.txt
37. │       └── main.cpp
38. ├── tests/                      # 测试
39. │   ├── CMakeLists.txt
40. │   ├── test_core.cpp
41. │   ├── test_filters.cpp
42. │   └── test_io.cpp
43. ├── cmake/                      # CMake模块
44. │   └── FindSomeLib.cmake
45. ├── docs/                       # 文档
46. │   └── Doxyfile.in
47. └── third_party/                # 第三方库
48.     └── stb/
49.         └── stb_image.h

复制代码

主CMakeLists.txt

2. # 要求CMake最低版本
3. cmake_minimum_required(VERSION 3.15)
5. # 定义项目
6. project(ImageProcessor
7.     VERSION 1.0.0
8.     DESCRIPTION "A cross-platform image processing library"
9.     LANGUAGES CXX
10. )
12. # 设置C++标准
13. set(CMAKE_CXX_STANDARD 17)
14. set(CMAKE_CXX_STANDARD_REQUIRED ON)
16. # 设置输出目录
17. set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
18. set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
19. set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
21. # 添加编译选项
22. if(MSVC)
23.     add_compile_options(/W4)
24. else()
25.     add_compile_options(-Wall -Wextra -Wpedantic)
26. endif()
28. # 查找依赖
29. find_package(Threads REQUIRED)
30. find_package(PkgConfig REQUIRED)
31. pkg_check_modules(JPEG REQUIRED libjpeg)
32. pkg_check_modules(PNG REQUIRED libpng)
34. # 如果是GUI应用，查找Qt
35. option(BUILD_GUI "Build GUI application" ON)
36. if(BUILD_GUI)
37.     find_package(Qt5 COMPONENTS Widgets Core Gui REQUIRED)
38. endif()
40. # 添加子目录
41. add_subdirectory(src)
42. add_subdirectory(apps)
43. option(BUILD_TESTS "Build tests" ON)
44. if(BUILD_TESTS)
45.     enable_testing()
46.     add_subdirectory(tests)
47. endif()
49. # 配置打包
50. include(CPack)

复制代码

src/CMakeLists.txt

2. # 添加子目录
3. add_subdirectory(core)
4. add_subdirectory(filters)
5. add_subdirectory(io)
6. add_subdirectory(utils)
8. # 创建库
9. add_library(imageprocessor
10.     # 这里不需要列出源文件，因为子目录已经添加了
11. )
13. # 设置包含目录
14. target_include_directories(imageprocessor
15.     PUBLIC
16.         $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../include>
17.         $<INSTALL_INTERFACE:include>
18.     PRIVATE
19.         ${CMAKE_CURRENT_SOURCE_DIR}
20. )
22. # 链接库
23. target_link_libraries(imageprocessor
24.     PUBLIC
25.         Threads::Threads
26.     PRIVATE
27.         ${JPEG_LIBRARIES}
28.         ${PNG_LIBRARIES}
29. )
31. # 设置属性
32. set_target_properties(imageprocessor
33.     PROPERTIES
34.         VERSION ${PROJECT_VERSION}
35.         SOVERSION ${PROJECT_VERSION_MAJOR}
36.         PUBLIC_HEADER "${CMAKE_CURRENT_SOURCE_DIR}/../include/imageprocessor/*.h"
37. )
39. # 安装规则
40. install(TARGETS imageprocessor
41.     EXPORT ImageProcessorTargets
42.     LIBRARY DESTINATION lib
43.     ARCHIVE DESTINATION lib
44.     RUNTIME DESTINATION bin
45.     PUBLIC_HEADER DESTINATION include/imageprocessor
46. )
48. # 导出配置
49. install(EXPORT ImageProcessorTargets
50.     FILE ImageProcessorTargets.cmake
51.     NAMESPACE ImageProcessor::
52.     DESTINATION lib/cmake/ImageProcessor
53. )
55. # 创建配置文件
56. include(CMakePackageConfigHelpers)
57. write_basic_package_version_file(
58.     "${CMAKE_CURRENT_BINARY_DIR}/ImageProcessorConfigVersion.cmake"
59.     VERSION ${PROJECT_VERSION}
60.     COMPATIBILITY AnyNewerVersion
61. )
63. # 安装配置文件
64. install(FILES
65.     "${CMAKE_CURRENT_BINARY_DIR}/ImageProcessorConfigVersion.cmake"
66.     "${CMAKE_CURRENT_SOURCE_DIR}/../cmake/ImageProcessorConfig.cmake"
67.     DESTINATION lib/cmake/ImageProcessor
68. )

复制代码

src/core/CMakeLists.txt

2. # 源文件
3. set(CORE_SOURCES
4.     image.cpp
5.     operations.cpp
6. )
8. # 创建库
9. add_library(imageprocessor_core STATIC ${CORE_SOURCES})
11. # 设置包含目录
12. target_include_directories(imageprocessor_core
13.     PUBLIC
14.         ${CMAKE_CURRENT_SOURCE_DIR}/../../include
15.     PRIVATE
16.         ${CMAKE_CURRENT_SOURCE_DIR}
17. )
19. # 链接到主库
20. target_link_libraries(imageprocessor
21.     PRIVATE
22.         imageprocessor_core
23. )

复制代码

apps/cli/CMakeLists.txt

2. # 源文件
3. set(CLI_SOURCES
4.     main.cpp
5. )
7. # 创建可执行文件
8. add_executable(imageprocessor_cli ${CLI_SOURCES})
10. # 链接库
11. target_link_libraries(imageprocessor_cli
12.     PRIVATE
13.         ImageProcessor::imageprocessor
14. )
16. # 安装
17. install(TARGETS imageprocessor_cli
18.     RUNTIME DESTINATION bin
19. )

复制代码

apps/gui/CMakeLists.txt

2. # 如果没有找到Qt或者没有启用GUI，则跳过
3. if(NOT BUILD_GUI OR NOT Qt5_FOUND)
4.     return()
5. endif()
7. # 源文件
8. set(GUI_SOURCES
9.     main.cpp
10.     mainwindow.cpp
11.     mainwindow.h
12. )
14. # Qt自动化
15. qt5_wrap_cpp(GUI_MOC ${GUI_HEADERS})
16. qt5_wrap_ui(UI_HEADERS ${GUI_FORMS})
17. qt5_add_resources(QRC_SOURCES ${RESOURCES})
19. # 创建可执行文件
20. add_executable(imageprocessor_gui
21.     ${GUI_SOURCES}
22.     ${GUI_MOC}
23.     ${UI_HEADERS}
24.     ${QRC_SOURCES}
25. )
27. # 链接库
28. target_link_libraries(imageprocessor_gui
29.     PRIVATE
30.         ImageProcessor::imageprocessor
31.         Qt5::Widgets
32.         Qt5::Core
33.         Qt5::Gui
34. )
36. # 安装
37. install(TARGETS imageprocessor_gui
38.     RUNTIME DESTINATION bin
39. )

复制代码

tests/CMakeLists.txt

2. # 查找GTest
3. find_package(GTest REQUIRED)
5. # 测试源文件
6. set(TEST_SOURCES
7.     test_core.cpp
8.     test_filters.cpp
9.     test_io.cpp
10. )
12. # 创建测试可执行文件
13. add_executable(imageprocessor_tests ${TEST_SOURCES})
15. # 链接库
16. target_link_libraries(imageprocessor_tests
17.     PRIVATE
18.         ImageProcessor::imageprocessor
19.         GTest::gtest
20.         GTest::gtest_main
21. )
23. # 添加测试
24. add_test(
25.     NAME imageprocessor_tests
26.     COMMAND imageprocessor_tests
27. )

复制代码

cmake/ImageProcessorConfig.cmake

2. include(CMakeFindDependencyMacro)
4. # 查找依赖
5. find_dependency(Threads)
6. find_dependency(PkgConfig)
7. pkg_check_modules(JPEG libjpeg)
8. pkg_check_modules(PNG libpng)
10. # 包含目标
11. include("${CMAKE_CURRENT_LIST_DIR}/ImageProcessorTargets.cmake")

复制代码

docs/Doxyfile.in

2. # Doxygen配置文件
3. PROJECT_NAME           = "ImageProcessor"
4. PROJECT_NUMBER         = @PROJECT_VERSION@
5. OUTPUT_DIRECTORY       = @CMAKE_CURRENT_BINARY_DIR@/docs
6. INPUT                  = @CMAKE_CURRENT_SOURCE_DIR@/include @CMAKE_CURRENT_SOURCE_DIR@/src
7. RECURSIVE              = YES
8. GENERATE_HTML          = YES
9. GENERATE_LATEX         = NO

复制代码

构建和使用

构建这个项目的步骤如下：

2. # 创建构建目录
3. mkdir build && cd build
5. # 配置项目
6. cmake .. -DCMAKE_BUILD_TYPE=Release -DBUILD_TESTS=ON -DBUILD_GUI=ON
8. # 构建项目
9. cmake --build . --config Release
11. # 运行测试
12. ctest --output-on-failure
14. # 安装
15. cmake --install . --prefix /usr/local
17. # 创建包
18. cpack -G DEB  # 或 CPack -G NSIS, CPack -G DragNDrop 等

复制代码

在其他项目中使用这个库：

2. # 查找ImageProcessor
3. find_package(ImageProcessor REQUIRED)
5. # 使用它
6. target_link_libraries(my_app
7.     PRIVATE
8.         ImageProcessor::imageprocessor
9. )

复制代码

总结

CMake是一个功能强大、灵活的跨平台构建工具，通过合理使用CMake，我们可以构建高效、可维护的项目构建系统。本文介绍了CMake的基础知识、常用命令、条件编译、依赖管理、安装打包等内容，并通过一个实际案例展示了如何综合运用这些知识。

在实际项目中，以下是一些关键的最佳实践：

1. 使用现代CMake实践，优先使用基于目标的命令而不是全局命令。
2. 合理组织项目结构，将源代码、头文件、测试和应用程序分离开来。
3. 使用条件编译和生成器表达式处理跨平台差异。
4. 使用find_package()或FetchContent管理依赖，避免硬编码路径。
5. 导出目标配置，使其他项目可以轻松使用你的库。
6. 使用测试框架（如CTest）确保代码质量。
7. 使用CPack创建安装包，简化分发过程。

通过遵循这些实践，你可以构建出高效、可维护的跨平台项目构建系统，使你的项目更加专业和易于管理。

CMake的学习曲线可能较陡，但一旦掌握，它将成为你开发工具箱中不可或缺的工具。希望本文能够帮助你更好地理解和使用CMake，构建出优秀的软件项目。