CMakeList配置编译参数完全指南从入门到精通掌握CMake构建系统核心技巧提升项目编译效率

1. 引言

CMake是一个开源、跨平台的构建自动化工具，它使用平台无关的配置文件（CMakeLists.txt）来生成标准的构建文件（如Unix的Makefile或Windows Visual Studio的项目文件）。CMake的设计目标是简化跨平台构建过程，使开发者能够专注于代码开发而不是构建系统的复杂性。

在现代软件开发中，构建系统扮演着至关重要的角色。一个高效、灵活的构建系统可以显著提高开发效率，减少构建时间，并确保代码在不同平台上的一致性。CMake作为目前最流行的构建系统之一，被广泛应用于各种规模的项目中，从小型个人项目到大型企业级应用，如KDE、VTK、Boost等知名项目都使用CMake作为其构建系统。

本指南将带您从CMake的基础知识开始，逐步深入到高级编译参数配置技巧，帮助您全面掌握CMake构建系统的核心技能，提升项目编译效率。无论您是CMake的初学者还是希望提升技能的有经验的开发者，本指南都将为您提供有价值的参考。

2. CMake基础

2.1 CMake的基本概念

在开始使用CMake之前，我们需要了解一些基本概念：

CMakeLists.txt：CMake的配置文件，包含构建项目的指令和设置。
生成器(Generator)：CMake使用生成器来创建特定平台的构建文件。例如，Unix Makefiles生成器用于生成Makefile，Visual Studio生成器用于生成Visual Studio项目文件。
构建目录(Build Directory)：存放构建输出的目录，通常与源代码目录分离，这种做法称为”out-of-source build”。
缓存变量(Cache Variables)：CMake使用缓存变量存储用户可配置的选项，这些变量存储在CMakeCache.txt文件中。
变量(Variables)：CMake中的变量用于存储值，可以在CMakeLists.txt文件中定义和使用。

2.2 CMake的基本语法

CMake脚本语言相对简单，主要由命令组成，命令不区分大小写，但通常使用大写形式。以下是一些基本的CMake命令：

# 注释以#开头 # 设置最小CMake版本要求 cmake_minimum_required(VERSION 3.10) # 定义项目名称和版本 project(MyProject VERSION 1.0) # 设置变量 set(MY_VARIABLE "value") # 使用变量 message(STATUS "Variable value: ${MY_VARIABLE}") # 条件语句 if(MY_VARIABLE MATCHES "value") message(STATUS "Variable matches value") endif() # 添加子目录 add_subdirectory(src) # 添加可执行文件 add_executable(my_app main.cpp) # 添加库 add_library(my_lib STATIC lib.cpp) # 链接库 target_link_libraries(my_app my_lib)

2.3 CMake的执行流程

CMake的执行流程通常包括以下步骤：

配置阶段：CMake解析CMakeLists.txt文件，处理变量和命令，生成构建系统。
生成阶段：CMake根据选择的生成器创建特定的构建文件（如Makefile或Visual Studio项目文件）。
构建阶段：使用生成的构建文件编译和链接代码。

典型的CMake使用流程如下：

# 创建构建目录 mkdir build cd build # 配置项目 cmake .. # 构建项目 cmake --build . # 安装项目（可选） cmake --install .

3. CMakeLists.txt文件结构

一个典型的CMakeLists.txt文件通常包含以下部分：

3.1 基本项目设置

# 指定CMake最低版本要求 cmake_minimum_required(VERSION 3.10) # 定义项目名称和版本 project(MyProject VERSION 1.0.0 DESCRIPTION "My awesome project" LANGUAGES CXX C ) # 设置C++标准 set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS OFF)

3.2 选项和配置

# 定义用户选项 option(ENABLE_TESTS "Build tests" ON) option(ENABLE_EXAMPLES "Build examples" ON) option(BUILD_SHARED_LIBS "Build shared libraries" OFF) # 设置构建类型 if(NOT CMAKE_BUILD_TYPE) set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Build type" FORCE) endif() # 设置输出目录 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin) set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib) set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)

3.3 查找依赖

# 查找包 find_package(Boost 1.70 REQUIRED COMPONENTS filesystem system) find_package(Threads REQUIRED) # 查找头文件和库 find_path(SDL2_INCLUDE_DIR SDL.h PATH_SUFFIXES include/SDL2) find_library(SDL2_LIBRARY SDL2)

3.4 添加子目录

# 添加子目录 add_subdirectory(src) add_subdirectory(include) # 条件添加子目录 if(ENABLE_TESTS) add_subdirectory(tests) endif() if(ENABLE_EXAMPLES) add_subdirectory(examples) endif()

3.5 安装规则

# 安装目标 install(TARGETS my_lib ARCHIVE DESTINATION lib LIBRARY DESTINATION lib RUNTIME DESTINATION bin ) # 安装头文件 install(FILES include/my_lib.h DESTINATION include) # 安装配置文件 install(FILES cmake/MyLibConfig.cmake DESTINATION lib/cmake/MyLib)

4. 基本编译参数配置

4.1 编译器设置

CMake允许您配置各种编译器参数，以控制代码的编译过程。

4.1.1 设置编译标准

# 设置C++标准 set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS OFF) # 设置C标准 set(CMAKE_C_STANDARD 11) set(CMAKE_C_STANDARD_REQUIRED ON) set(CMAKE_C_EXTENSIONS OFF)

这些变量告诉CMake使用特定的C++或C标准。CMAKE_CXX_STANDARD_REQUIRED设置为ON表示如果编译器不支持指定的标准，CMake将报错而不是降级使用较低的标准。CMAKE_CXX_EXTENSIONS设置为OFF表示禁用编译器特定的扩展。

4.1.2 设置编译器标志

# 设置C++编译器标志 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wpedantic") # 设置C编译器标志 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Wpedantic") # 根据构建类型设置不同的标志 set(CMAKE_CXX_FLAGS_DEBUG "-g -O0") set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG") set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g -DNDEBUG") set(CMAKE_CXX_FLAGS_MINSIZEREL "-Os -DNDEBUG")

CMAKE_CXX_FLAGS和CMAKE_C_FLAGS变量包含应用于所有C++和C编译的标志。您可以根据构建类型设置特定的标志，这些标志将根据所选的构建类型自动应用。

4.1.3 针对特定编译器的设置

# 针对GCC/Clang的设置 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang") add_compile_options(-Wall -Wextra -Wpedantic) endif() # 针对MSVC的设置 if(MSVC) add_compile_options(/W4) # 禁用一些MSVC特定的警告 add_definitions(-D_CRT_SECURE_NO_WARNINGS) endif()

您可以使用CMAKE_CXX_COMPILER_ID变量检测编译器类型，并根据不同的编译器设置不同的编译选项。

4.2 构建类型配置

CMake支持几种标准的构建类型，每种类型都有不同的编译器标志和优化级别：

# 设置默认构建类型 if(NOT CMAKE_BUILD_TYPE) set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Build type" FORCE) endif() # 验证构建类型是否有效 set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "RelWithDebInfo" "MinSizeRel") # 根据构建类型设置不同的选项 if(CMAKE_BUILD_TYPE STREQUAL "Debug") add_definitions(-DDEBUG) message(STATUS "Building in Debug mode") elseif(CMAKE_BUILD_TYPE STREQUAL "Release") add_definitions(-DNDEBUG) message(STATUS "Building in Release mode") endif()

标准的构建类型包括：

Debug：包含调试信息，不进行优化（-g -O0）。
Release：不包含调试信息，进行高级优化（-O3 -DNDEBUG）。
RelWithDebInfo：包含调试信息，进行适度优化（-O2 -g -DNDEBUG）。
MinSizeRel：不包含调试信息，进行大小优化（-Os -DNDEBUG）。

4.3 目标特定编译参数

除了全局编译参数外，您还可以为特定的目标（可执行文件或库）设置编译参数：

# 添加可执行文件 add_executable(my_app main.cpp) # 为目标设置编译定义 target_compile_definitions(my_app PRIVATE MY_APP_DEFINE) # 为目标设置编译选项 target_compile_options(my_app PRIVATE -Wall -Wextra) # 为目标设置包含目录 target_include_directories(my_app PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include) # 添加库 add_library(my_lib STATIC lib.cpp) # 为库设置编译定义 target_compile_definitions(my_lib PUBLIC MY_LIB_DEFINE) # 为库设置包含目录 target_include_directories(my_lib PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include> $<INSTALL_INTERFACE:include> )

使用target_*命令而不是全局变量是现代CMake推荐的做法，因为它提供了更好的封装性和控制性。PRIVATE、PUBLIC和INTERFACE关键字指定了属性的传递范围：

PRIVATE：属性仅应用于当前目标，不传递给依赖目标。
PUBLIC：属性应用于当前目标和依赖目标。
INTERFACE：属性仅应用于依赖目标，不应用于当前目标。

5. 高级编译参数配置

5.1 使用生成器表达式

生成器表达式是CMake的一个强大功能，它允许在生成构建系统时评估表达式，而不是在配置CMake时。这使得您可以根据构建配置、平台、编译器等条件设置不同的参数。

# 根据构建类型设置不同的定义 target_compile_definitions(my_lib PRIVATE $<$<CONFIG:Debug>:DEBUG_MODE> $<$<CONFIG:Release>:NDEBUG> ) # 根据平台设置不同的标志 target_compile_options(my_lib PRIVATE $<$<PLATFORM_ID:Windows>:/WX> $<$<PLATFORM_ID:Linux>:-Werror> ) # 根据编译器设置不同的标志 target_compile_options(my_lib PRIVATE $<$<CXX_COMPILER_ID:GNU>:-Wall -Wextra> $<$<CXX_COMPILER_ID:MSVC>:/W4> ) # 条件包含目录 target_include_directories(my_lib PRIVATE $<$<BOOL:${ENABLE_FEATURE}>:${CMAKE_CURRENT_SOURCE_DIR}/feature> )

生成器表达式使用$<...>语法，可以嵌套使用，提供强大的条件逻辑。

5.2 编译特性

CMake提供了一种抽象的方式来处理编译器特性，而不是直接使用编译器特定的标志：

# 要求特定的编译特性 target_compile_features(my_lib PRIVATE cxx_std_17 cxx_auto_type cxx_range_for ) # 检查编译器是否支持特定特性 get_target_property(supported_features my_lib COMPILE_FEATURES) if("cxx_constexpr" IN_LIST supported_features) message(STATUS "Compiler supports constexpr") endif()

使用target_compile_features命令可以确保代码使用特定的C++特性，而无需知道特定编译器需要哪些标志来启用这些特性。

5.3 控制警告级别

不同的编译器有不同的警告标志，CMake提供了一些模块来帮助管理这些警告：

# 包含CMake的警告模块 include(CheckCXXCompilerFlag) # 检查并设置编译器标志 function(enable_cxx_warning flag) string(REPLACE "-" "_" flag_var ${flag}) check_cxx_compiler_flag(${flag} HAS_WARNING_${flag_var}) if(HAS_WARNING_${flag_var}) target_compile_options(my_lib PRIVATE ${flag}) endif() endfunction() # 启用常见警告 enable_cxx_warning(-Wall) enable_cxx_warning(-Wextra) enable_cxx_warning(-Wpedantic) # 对于MSVC，设置不同的警告级别 if(MSVC) target_compile_options(my_lib PRIVATE /W4) # 禁用一些特定的警告 target_compile_options(my_lib PRIVATE /wd4100) # 未使用的形参警告 endif()

这种方法可以确保只在编译器支持特定警告标志时才使用它们，提高构建系统的可移植性。

5.4 优化和调试选项

您可以根据构建类型和目标需求设置不同的优化和调试选项：

# 为Debug构建设置调试选项 if(CMAKE_BUILD_TYPE STREQUAL "Debug") # GCC/Clang调试选项 if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang") target_compile_options(my_lib PRIVATE -g3 # 最大调试信息 -Og # 优化调试体验 ) endif() # MSVC调试选项 if(MSVC) target_compile_options(my_lib PRIVATE /Zi # 生成完整的调试信息 /Od # 禁用优化 ) endif() endif() # 为Release构建设置优化选项 if(CMAKE_BUILD_TYPE STREQUAL "Release") # GCC/Clang优化选项 if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang") target_compile_options(my_lib PRIVATE -O3 # 最高级别的优化 -march=native # 针对当前CPU架构优化 -DNDEBUG # 禁用断言 ) endif() # MSVC优化选项 if(MSVC) target_compile_options(my_lib PRIVATE /O2 # 最高级别的优化 /DNDEBUG # 禁用断言 /GL # 全程序优化 ) target_link_options(my_lib PRIVATE /LTCG # 链接时代码生成 ) endif() endif()

通过为不同的构建类型设置不同的优化和调试选项，您可以在开发过程中获得更好的调试体验，而在发布时获得更好的性能。

6. 条件编译和平台特定配置

6.1 平台检测

CMake提供了多种方式来检测目标平台，以便根据平台设置不同的编译参数：

# 检测操作系统 if(CMAKE_SYSTEM_NAME STREQUAL "Linux") message(STATUS "Building for Linux") add_definitions(-DLINUX) elseif(CMAKE_SYSTEM_NAME STREQUAL "Windows") message(STATUS "Building for Windows") add_definitions(-DWIN32_LEAN_AND_MEAN) elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin") message(STATUS "Building for macOS") add_definitions(-DMACOS) endif() # 检测处理器架构 if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64") message(STATUS "Building for x86_64") add_definitions(-DX86_64) elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "arm|ARM") message(STATUS "Building for ARM") add_definitions(-DARM) endif() # 检测编译器 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") message(STATUS "Using GCC compiler") add_definitions(-DGCC) elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang") message(STATUS "Using Clang compiler") add_definitions(-DCLANG) elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC") message(STATUS "Using MSVC compiler") add_definitions(-DMSVC) endif()

6.2 条件编译

条件编译允许您根据不同的条件包含或排除代码，或者设置不同的编译参数：

# 基于选项的条件编译 option(USE_FEATURE_X "Enable feature X" OFF) if(USE_FEATURE_X) add_definitions(-DUSE_FEATURE_X) message(STATUS "Feature X is enabled") else() message(STATUS "Feature X is disabled") endif() # 基于依赖的条件编译 find_package(Boost QUIET) if(Boost_FOUND) add_definitions(-DHAVE_BOOST) message(STATUS "Boost is available") else() message(WARNING "Boost not found, some features will be disabled") endif() # 基于编译器版本的条件编译 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 7.0) add_definitions(-DGCC_GTE_7) message(STATUS "GCC version >= 7.0, enabling additional features") endif()

6.3 平台特定的源文件

有时，您可能需要为不同的平台包含不同的源文件：

# 设置平台特定的源文件 set(COMMON_SOURCES src/common.cpp src/utils.cpp ) if(CMAKE_SYSTEM_NAME STREQUAL "Windows") list(APPEND COMMON_SOURCES src/windows_specific.cpp) add_definitions(-DPLATFORM_WINDOWS) elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux") list(APPEND COMMON_SOURCES src/linux_specific.cpp) add_definitions(-DPLATFORM_LINUX) elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin") list(APPEND COMMON_SOURCES src/macos_specific.cpp) add_definitions(-DPLATFORM_MACOS) endif() # 创建库 add_library(my_lib ${COMMON_SOURCES})

6.4 配置文件

CMake允许您生成配置文件，这些文件可以在编译时包含，提供灵活的配置选项：

# 配置头文件模板 configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/config.h.in ${CMAKE_CURRENT_BINARY_DIR}/config.h ) # 确保生成的头文件可以被找到 target_include_directories(my_lib PRIVATE ${CMAKE_CURRENT_BINARY_DIR} )

config.h.in文件可能包含如下内容：

#ifndef CONFIG_H #define CONFIG_H // 项目版本 #define PROJECT_VERSION_MAJOR @PROJECT_VERSION_MAJOR@ #define PROJECT_VERSION_MINOR @PROJECT_VERSION_MINOR@ #define PROJECT_VERSION_PATCH @PROJECT_VERSION_PATCH@ // 功能标志 #cmakedefine USE_FEATURE_X #cmakedefine HAVE_BOOST // 平台特定定义 #cmakedefine PLATFORM_WINDOWS #cmakedefine PLATFORM_LINUX #cmakedefine PLATFORM_MACOS // 编译器特定定义 #cmakedefine GCC #cmakedefine CLANG #cmakedefine MSVC #cmakedefine GCC_GTE_7 #endif // CONFIG_H

当CMake处理configure_file命令时，它会将@variable@替换为变量的值，并将#cmakedefine转换为#define或注释，取决于变量是否定义。

7. 依赖管理和外部项目

7.1 查找依赖包

CMake提供了find_package命令来查找系统上安装的依赖包：

# 查找Boost库 find_package(Boost 1.70 REQUIRED COMPONENTS filesystem system) # 查找线程库 find_package(Threads REQUIRED) # 查找OpenGL find_package(OpenGL REQUIRED) # 检查包是否找到 if(Boost_FOUND) message(STATUS "Boost found: ${Boost_INCLUDE_DIRS}") message(STATUS "Boost libraries: ${Boost_LIBRARIES}") # 使用Boost include_directories(${Boost_INCLUDE_DIRS}) target_link_libraries(my_app ${Boost_LIBRARIES}) endif() # 使用现代CMake方式链接依赖 target_link_libraries(my_app PRIVATE Boost::filesystem Boost::system Threads::Threads OpenGL::GL )

find_package命令有两种模式：模块模式和配置模式。在模块模式下，CMake会查找名为Find<PackageName>.cmake的模块文件；在配置模式下，它会查找由包提供的<PackageName>Config.cmake文件。

7.2 添加外部项目

CMake的ExternalProject模块允许您在构建过程中下载、配置、构建和安装外部项目：

include(ExternalProject) # 添加外部项目 ExternalProject_Add( googletest URL https://github.com/google/googletest/archive/release-1.11.0.zip URL_HASH SHA256=152717e681c5c821cbb08a669ff593774f8ac0527b0131b8a3c92b0b2c62d2a PREFIX ${CMAKE_CURRENT_BINARY_DIR}/googletest INSTALL_DIR ${CMAKE_CURRENT_BINARY_DIR}/googletest_install CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=<INSTALL_DIR> -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DBUILD_GMOCK=ON -Dgtest_force_shared_crt=ON # 禁用不必要的步骤 UPDATE_COMMAND "" PATCH_COMMAND "" ) # 添加外部项目作为依赖 ExternalProject_Get_Property(googletest install_dir) set(GTEST_INCLUDE_DIR ${install_dir}/include) set(GTEST_LIBRARY_PATH ${install_dir}/lib) # 创建导入的目标 add_library(gtest IMPORTED STATIC) set_target_properties(gtest PROPERTIES IMPORTED_LOCATION ${GTEST_LIBRARY_PATH}/libgtest.a INTERFACE_INCLUDE_DIRECTORIES ${GTEST_INCLUDE_DIR} ) add_library(gtest_main IMPORTED STATIC) set_target_properties(gtest_main PROPERTIES IMPORTED_LOCATION ${GTEST_LIBRARY_PATH}/libgtest_main.a INTERFACE_INCLUDE_DIRECTORIES ${GTEST_INCLUDE_DIR} ) # 添加依赖关系 add_dependencies(gtest googletest) add_dependencies(gtest_main googletest) # 链接到主项目 target_link_libraries(my_test PRIVATE gtest gtest_main )

ExternalProject_Add命令提供了许多选项来控制外部项目的下载、配置、构建和安装过程。这种方法特别适合管理大型项目的依赖关系。

7.3 使用FetchContent

CMake 3.11及以上版本提供了FetchContent模块，它简化了下载和添加外部项目的过程：

include(FetchContent) # 声明要获取的内容 FetchContent_Declare( googletest URL https://github.com/google/googletest/archive/release-1.11.0.zip URL_HASH SHA256=152717e681c5c821cbb08a669ff593774f8ac0527b0131b8a3c92b0b2c62d2a ) # 获取内容 FetchContent_MakeAvailable(googletest) # 现在可以直接使用googletest目标 target_link_libraries(my_test PRIVATE gtest gtest_main )

FetchContent比ExternalProject更简洁，它会自动处理依赖关系，并将下载的项目直接添加到主构建中，而不是作为单独的构建步骤。

7.4 使用Conan或vcpkg等包管理器

您也可以将CMake与第三方包管理器（如Conan或vcpkg）集成，以更方便地管理依赖关系：

7.4.1 使用Conan

# 查找Conan find_program(CONAN_CMD conan) if(NOT CONAN_CMD) message(FATAL_ERROR "Conan not found. Please install Conan.") endif() # 设置Conan配置 set(CONAN_PROFILE default) set(CONAN_SETTINGS ${CMAKE_SYSTEM_NAME}) if(CMAKE_BUILD_TYPE) set(CONAN_SETTINGS ${CONAN_SETTINGS} build_type=${CMAKE_BUILD_TYPE}) endif() # 生成conanfile.txt file(WRITE ${CMAKE_BINARY_DIR}/conanfile.txt " [requires] boost/1.75.0 openssl/1.1.1k [generators] cmake cmake_find_package ") # 安装依赖 execute_process( COMMAND ${CONAN_CMD} install . --profile ${CONAN_PROFILE} --settings ${CONAN_SETTINGS} WORKING_DIRECTORY ${CMAKE_BINARY_DIR} ) # 包含Conan生成的文件 include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake) conan_basic_setup() # 或者使用现代CMake方式 find_package(Boost REQUIRED) find_package(OpenSSL REQUIRED) # 链接依赖 target_link_libraries(my_app PRIVATE Boost::boost OpenSSL::SSL OpenSSL::Crypto )

7.4.2 使用vcpkg

# 设置vcpkg工具链文件 set(CMAKE_TOOLCHAIN_FILE ${CMAKE_SOURCE_DIR}/vcpkg/scripts/buildsystems/vcpkg.cmake CACHE STRING "Vcpkg toolchain file" ) # 现在可以直接使用find_package查找vcpkg安装的包 find_package(Boost REQUIRED) find_package(OpenSSL REQUIRED) # 链接依赖 target_link_libraries(my_app PRIVATE Boost::boost OpenSSL::SSL OpenSSL::Crypto )

使用包管理器可以大大简化依赖管理，特别是在处理复杂的依赖关系时。

8. 优化编译效率的技巧

8.1 并行构建

并行构建可以显著减少构建时间，特别是对于大型项目：

# 设置并行编译 if(NOT DEFINED CMAKE_BUILD_PARALLEL_LEVEL) # 自动检测CPU核心数 include(ProcessorCount) ProcessorCount(N) if(NOT N EQUAL 0) set(CMAKE_BUILD_PARALLEL_LEVEL ${N}) else() set(CMAKE_BUILD_PARALLEL_LEVEL 4) endif() endif() message(STATUS "Parallel build level: ${CMAKE_BUILD_PARALLEL_LEVEL}") # 对于Makefile生成器，设置并行编译标志 if(CMAKE_GENERATOR STREQUAL "Unix Makefiles") set(CMAKE_MAKE_PROGRAM "${CMAKE_MAKE_PROGRAM} -j${CMAKE_BUILD_PARALLEL_LEVEL}") endif()

在构建时，您也可以使用以下命令来指定并行级别：

# 使用4个并行作业构建 cmake --build . --parallel 4 # 或者使用环境变量 CMAKE_BUILD_PARALLEL_LEVEL=4 cmake --build .

8.2 使用预编译头

预编译头可以显著减少编译时间，特别是对于包含大量头文件的项目：

# 启用预编译头 target_precompile_headers(my_lib PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include/pch.h ) # 或者使用生成器表达式 target_precompile_headers(my_lib PRIVATE $<$<COMPILE_LANGUAGE:CXX>:${CMAKE_CURRENT_SOURCE_DIR}/include/pch.h> $<$<COMPILE_LANGUAGE:C>:${CMAKE_CURRENT_SOURCE_DIR}/include/pch_c.h> )

预编译头文件应该包含那些很少更改但被许多源文件包含的头文件，如标准库头文件和第三方库头文件。

8.3 使用统一构建

统一构建（Unity Build）是一种将多个源文件合并到一个翻译单元中进行编译的技术，可以减少编译时间：

# 启用统一构建 set_target_properties(my_lib PROPERTIES UNITY_BUILD ON UNITY_BUILD_MODE BATCH # 排除一些不适合统一构建的文件 UNITY_BUILD_EXCLUDES src/special_file1.cpp src/special_file2.cpp )

统一构建可以减少编译器的工作量，但可能会增加内存使用，并可能导致一些命名冲突。因此，它通常用于大型项目中的核心模块，而不是整个项目。

8.4 使用ccache

ccache是一个编译器缓存工具，可以缓存编译结果并在相同的输入下重用它们：

# 查找ccache find_program(CCACHE_PROGRAM ccache) if(CCACHE_PROGRAM) # 设置编译器包装器 set(CMAKE_C_COMPILER_LAUNCHER ${CCACHE_PROGRAM}) set(CMAKE_CXX_COMPILER_LAUNCHER ${CCACHE_PROGRAM}) message(STATUS "Using ccache: ${CCACHE_PROGRAM}") else() message(WARNING "ccache not found. Install it to speed up rebuilds.") endif()

ccache特别适合开发过程中频繁重新编译的场景，可以显著减少增量构建的时间。

8.5 优化包含路径

优化包含路径可以减少编译器查找头文件的时间：

# 使用目标特定的包含目录而不是全局包含目录 target_include_directories(my_lib PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include ) # 避免使用include_directories()，它会影响所有目标 # include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include) # 不推荐 # 使用系统包含目录，减少编译器警告 target_include_directories(my_lib SYSTEM PRIVATE /usr/include/some_library )

使用目标特定的包含目录而不是全局包含目录可以提高构建系统的模块化，并减少不必要的包含路径。

8.6 使用目标属性优化

CMake提供了许多目标属性，可以用来优化构建过程：

# 设置可执行文件的链接选项 set_target_properties(my_app PROPERTIES # 启用链接时优化 INTERPROCEDURAL_OPTIMIZATION_RELEASE ON # 设置输出名称 OUTPUT_NAME my_app # 设置运行时目录 RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin ) # 设置库的属性 set_target_properties(my_lib PROPERTIES # 设置库版本 VERSION ${PROJECT_VERSION} SOVERSION ${PROJECT_VERSION_MAJOR} # 设置输出目录 LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib # 设置位置无关代码 POSITION_INDEPENDENT_CODE ON )

这些属性可以帮助您更好地控制构建过程，并优化生成的二进制文件。

9. 调试和故障排除

9.1 启用详细输出

在调试CMake问题时，启用详细输出可以帮助您了解发生了什么：

# 启用详细输出 cmake -DCMAKE_VERBOSE_MAKEFILE=ON .. # 或者使用--trace选项跟踪执行 cmake --trace .. # 或者使用--trace-expand选项跟踪执行并展开变量 cmake --trace-expand ..

在CMakeLists.txt文件中，您也可以使用以下命令来启用调试输出：

# 启用详细输出 set(CMAKE_VERBOSE_MAKEFILE ON) # 打印变量值 message(STATUS "CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}") message(STATUS "CMAKE_CXX_FLAGS: ${CMAKE_CXX_FLAGS}") # 打印所有变量 get_cmake_property(_variableNames VARIABLES) list(SORT _variableNames) foreach(_variableName ${_variableNames}) message(STATUS "${_variableName}=${${_variableName}}") endforeach()

9.2 检查编译器标志

检查实际的编译器标志可以帮助您了解为什么某些选项没有被应用：

# 打印编译器标志 function(print_flags target) get_target_property(cxx_flags ${target} COMPILE_OPTIONS) message(STATUS "Compile options for ${target}: ${cxx_flags}") get_target_property(cxx_defs ${target} COMPILE_DEFINITIONS) message(STATUS "Compile definitions for ${target}: ${cxx_defs}") get_target_property(include_dirs ${target} INCLUDE_DIRECTORIES) message(STATUS "Include directories for ${target}: ${include_dirs}") get_target_property(link_libs ${target} LINK_LIBRARIES) message(STATUS "Link libraries for ${target}: ${link_libs}") endfunction() # 使用函数 print_flags(my_lib)

9.3 使用CMake的调试工具

CMake提供了一些工具来帮助调试构建系统：

# 检查依赖关系 function(print_dependencies target) message(STATUS "Dependencies for ${target}:") get_target_property(deps ${target} LINK_LIBRARIES) foreach(dep ${deps}) if(TARGET ${dep}) message(STATUS " ${dep} (target)") print_dependencies(${dep}) else() message(STATUS " ${dep} (library)") endif() endforeach() endfunction() # 使用函数 print_dependencies(my_app) # 检查源文件 function(print_sources target) get_target_property(sources ${target} SOURCES) message(STATUS "Sources for ${target}:") foreach(source ${sources}) message(STATUS " ${source}") endforeach() endfunction() # 使用函数 print_sources(my_lib)

9.4 常见问题和解决方案

9.4.1 找不到头文件

如果编译器报告找不到头文件，可能是包含路径设置不正确：

# 检查包含路径 get_target_property(include_dirs my_lib INCLUDE_DIRECTORIES) message(STATUS "Include directories: ${include_dirs}") # 添加缺失的包含路径 target_include_directories(my_lib PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include )

9.4.2 找不到库

如果链接器报告找不到库，可能是库路径或库名称不正确：

# 检查链接库 get_target_property(link_libs my_lib LINK_LIBRARIES) message(STATUS "Link libraries: ${link_libs}") # 添加缺失的库路径 link_directories(${CMAKE_CURRENT_SOURCE_DIR}/lib) # 或者使用完整路径 target_link_libraries(my_lib PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/lib/mylib.a )

9.4.3 编译器标志不生效

如果某些编译器标志似乎没有生效，可能是被其他设置覆盖了：

# 检查编译标志 get_target_property(cxx_flags my_lib COMPILE_OPTIONS) message(STATUS "Compile options: ${cxx_flags}") # 使用生成器表达式确保标志正确应用 target_compile_options(my_lib PRIVATE $<$<COMPILE_LANGUAGE:CXX>:-Wall -Wextra> )

9.4.4 构建类型不正确

如果构建类型不正确，可能会导致错误的优化级别或调试信息：

# 检查构建类型 message(STATUS "Build type: ${CMAKE_BUILD_TYPE}") # 设置默认构建类型 if(NOT CMAKE_BUILD_TYPE) set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Build type" FORCE) endif() # 验证构建类型是否有效 set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "RelWithDebInfo" "MinSizeRel")

10. 实际项目案例分析

10.1 简单的C++项目

让我们从一个简单的C++项目开始，该项目包含一个可执行文件和一个库：

my_project/ ├── CMakeLists.txt ├── include/ │ └── mylib/ │ └── mylib.h ├── src/ │ ├── mylib.cpp │ └── main.cpp └── tests/ ├── CMakeLists.txt └── test_mylib.cpp

主CMakeLists.txt文件：

# 指定CMake最低版本要求 cmake_minimum_required(VERSION 3.10) # 定义项目名称和版本 project(MyProject VERSION 1.0.0 DESCRIPTION "My awesome project" LANGUAGES CXX ) # 设置C++标准 set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS OFF) # 设置输出目录 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin) set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib) set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib) # 添加子目录 add_subdirectory(src) add_subdirectory(tests)

src/CMakeLists.txt文件：

# 添加库 add_library(mylib STATIC mylib.cpp ) # 设置包含目录 target_include_directories(mylib PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../include> $<INSTALL_INTERFACE:include> ) # 设置编译选项 target_compile_options(mylib PRIVATE $<$<CXX_COMPILER_ID:GNU|Clang>:-Wall -Wextra> $<$<CXX_COMPILER_ID:MSVC>:/W4> ) # 添加可执行文件 add_executable(myapp main.cpp ) # 链接库 target_link_libraries(myapp PRIVATE mylib ) # 设置安装规则 install(TARGETS mylib myapp EXPORT MyProjectTargets LIBRARY DESTINATION lib ARCHIVE DESTINATION lib RUNTIME DESTINATION bin ) install(DIRECTORY ../include/mylib DESTINATION include )

tests/CMakeLists.txt文件：

# 启用测试 enable_testing() # 添加测试可执行文件 add_executable(test_mylib test_mylib.cpp ) # 链接库 target_link_libraries(test_mylib PRIVATE mylib ) # 添加测试 add_test(NAME test_mylib COMMAND test_mylib)

10.2 复杂的多语言项目

现在让我们看一个更复杂的项目，该项目包含C++、C和CUDA代码：

complex_project/ ├── CMakeLists.txt ├── cmake/ │ └── FindSomeLib.cmake ├── include/ │ ├── common.h │ ├── cpp_lib/ │ │ └── cpp_lib.h │ └── c_lib/ │ └── c_lib.h ├── src/ │ ├── cpp_lib/ │ │ ├── CMakeLists.txt │ │ └── cpp_lib.cpp │ ├── c_lib/ │ │ ├── CMakeLists.txt │ │ └── c_lib.c │ ├── cuda_lib/ │ │ ├── CMakeLists.txt │ │ └── cuda_lib.cu │ └── app/ │ ├── CMakeLists.txt │ └── main.cpp └── tests/ ├── CMakeLists.txt ├── test_cpp.cpp ├── test_c.c └── test_cuda.cu

主CMakeLists.txt文件：

# 指定CMake最低版本要求 cmake_minimum_required(VERSION 3.18) # 定义项目名称和版本 project(ComplexProject VERSION 1.0.0 DESCRIPTION "A complex multi-language project" LANGUAGES CXX C CUDA ) # 设置C++标准 set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS OFF) # 设置C标准 set(CMAKE_C_STANDARD 11) set(CMAKE_C_STANDARD_REQUIRED ON) set(CMAKE_C_EXTENSIONS OFF) # 设置CUDA标准 set(CMAKE_CUDA_STANDARD 14) set(CMAKE_CUDA_STANDARD_REQUIRED ON) set(CMAKE_CUDA_EXTENSIONS OFF) # 设置输出目录 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin) set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib) set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib) # 添加模块路径 list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake) # 查找依赖 find_package(Boost 1.70 REQUIRED COMPONENTS filesystem system) find_package(Threads REQUIRED) find_package(SomeLib REQUIRED) # 添加子目录 add_subdirectory(src) add_subdirectory(tests) # 配置头文件 configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/include/config.h.in ${CMAKE_CURRENT_BINARY_DIR}/include/config.h ) # 安装规则 install(DIRECTORY include/ DESTINATION include) install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/include/ DESTINATION include)

src/cpp_lib/CMakeLists.txt文件：

# 添加库 add_library(cpp_lib STATIC cpp_lib.cpp ) # 设置包含目录 target_include_directories(cpp_lib PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../../include> $<INSTALL_INTERFACE:include> PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/../../include ) # 设置编译选项 target_compile_options(cpp_lib PRIVATE $<$<CXX_COMPILER_ID:GNU|Clang>:-Wall -Wextra -Wpedantic> $<$<CXX_COMPILER_ID:MSVC>:/W4> ) # 链接依赖 target_link_libraries(cpp_lib PUBLIC Boost::filesystem Boost::system Threads::Threads PRIVATE SomeLib::SomeLib ) # 设置属性 set_target_properties(cpp_lib PROPERTIES POSITION_INDEPENDENT_CODE ON CXX_STANDARD 17 ) # 安装规则 install(TARGETS cpp_lib EXPORT ComplexProjectTargets LIBRARY DESTINATION lib ARCHIVE DESTINATION lib )

src/c_lib/CMakeLists.txt文件：

# 添加库 add_library(c_lib STATIC c_lib.c ) # 设置包含目录 target_include_directories(c_lib PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../../include> $<INSTALL_INTERFACE:include> PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/../../include ) # 设置编译选项 target_compile_options(c_lib PRIVATE $<$<C_COMPILER_ID:GNU|Clang>:-Wall -Wextra -Wpedantic> $<$<C_COMPILER_ID:MSVC>:/W4> ) # 链接依赖 target_link_libraries(c_lib PUBLIC Threads::Threads PRIVATE SomeLib::SomeLib ) # 设置属性 set_target_properties(c_lib PROPERTIES POSITION_INDEPENDENT_CODE ON C_STANDARD 11 ) # 安装规则 install(TARGETS c_lib EXPORT ComplexProjectTargets LIBRARY DESTINATION lib ARCHIVE DESTINATION lib )

src/cuda_lib/CMakeLists.txt文件：

# 添加库 add_library(cuda_lib STATIC cuda_lib.cu ) # 设置包含目录 target_include_directories(cuda_lib PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../../include> $<INSTALL_INTERFACE:include> PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/../../include ) # 设置编译选项 target_compile_options(cuda_lib PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:-Xcompiler=-Wall,-Wextra> ) # 链接依赖 target_link_libraries(cuda_lib PUBLIC cpp_lib c_lib ) # 设置属性 set_target_properties(cuda_lib PROPERTIES CUDA_SEPARABLE_COMPILATION ON CUDA_STANDARD 14 ) # 安装规则 install(TARGETS cuda_lib EXPORT ComplexProjectTargets LIBRARY DESTINATION lib ARCHIVE DESTINATION lib )

src/app/CMakeLists.txt文件：

# 添加可执行文件 add_executable(myapp main.cpp ) # 设置包含目录 target_include_directories(myapp PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../../include ${CMAKE_CURRENT_BINARY_DIR}/../../include ) # 设置编译选项 target_compile_options(myapp PRIVATE $<$<CXX_COMPILER_ID:GNU|Clang>:-Wall -Wextra> $<$<CXX_COMPILER_ID:MSVC>:/W4> ) # 链接依赖 target_link_libraries(myapp PRIVATE cpp_lib c_lib cuda_lib ) # 设置属性 set_target_properties(myapp PROPERTIES CXX_STANDARD 17 ) # 安装规则 install(TARGETS myapp RUNTIME DESTINATION bin )

tests/CMakeLists.txt文件：

# 启用测试 enable_testing() # 查找GTest find_package(GTest REQUIRED) # 添加C++测试 add_executable(test_cpp test_cpp.cpp ) target_link_libraries(test_cpp PRIVATE cpp_lib GTest::gtest GTest::gtest_main ) add_test(NAME test_cpp COMMAND test_cpp) # 添加C测试 add_executable(test_c test_c.c ) target_link_libraries(test_c PRIVATE c_lib GTest::gtest GTest::gtest_main ) add_test(NAME test_c COMMAND test_c) # 添加CUDA测试 enable_language(CUDA) add_executable(test_cuda test_cuda.cu ) target_link_libraries(test_cuda PRIVATE cuda_lib GTest::gtest GTest::gtest_main ) add_test(NAME test_cuda COMMAND test_cuda)

10.3 跨平台项目

最后，让我们看一个跨平台项目，该项目的某些部分在不同平台上使用不同的实现：

cross_platform_project/ ├── CMakeLists.txt ├── include/ │ ├── common.h │ └── platform_utils.h ├── src/ │ ├── common.cpp │ ├── posix/ │ │ ├── CMakeLists.txt │ │ └── platform_utils.cpp │ ├── windows/ │ │ ├── CMakeLists.txt │ │ └── platform_utils.cpp │ └── app/ │ ├── CMakeLists.txt │ └── main.cpp └── cmake/ └── PlatformUtilsConfig.cmake.in

主CMakeLists.txt文件：

# 指定CMake最低版本要求 cmake_minimum_required(VERSION 3.10) # 定义项目名称和版本 project(CrossPlatformProject VERSION 1.0.0 DESCRIPTION "A cross-platform project" LANGUAGES CXX ) # 设置C++标准 set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS OFF) # 设置输出目录 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin) set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib) set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib) # 添加平台特定的子目录 if(CMAKE_SYSTEM_NAME STREQUAL "Windows") add_subdirectory(src/windows) add_definitions(-DPLATFORM_WINDOWS) elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux" OR CMAKE_SYSTEM_NAME STREQUAL "Darwin") add_subdirectory(src/posix) add_definitions(-DPLATFORM_POSIX) else() message(FATAL_ERROR "Unsupported platform: ${CMAKE_SYSTEM_NAME}") endif() # 添加通用子目录 add_subdirectory(src/app) # 配置和安装包配置文件 include(CMakePackageConfigHelpers) write_basic_package_version_file( "${CMAKE_CURRENT_BINARY_DIR}/cmake/PlatformUtilsConfigVersion.cmake" VERSION ${PROJECT_VERSION} COMPATIBILITY AnyNewerVersion ) configure_package_config_file( "${CMAKE_CURRENT_SOURCE_DIR}/cmake/PlatformUtilsConfig.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/cmake/PlatformUtilsConfig.cmake" INSTALL_DESTINATION lib/cmake/PlatformUtils ) install( FILES "${CMAKE_CURRENT_BINARY_DIR}/cmake/PlatformUtilsConfig.cmake" "${CMAKE_CURRENT_BINARY_DIR}/cmake/PlatformUtilsConfigVersion.cmake" DESTINATION lib/cmake/PlatformUtils ) # 安装头文件 install(DIRECTORY include/ DESTINATION include)

src/posix/CMakeLists.txt文件：

# 添加库 add_library(platform_utils STATIC platform_utils.cpp ) # 设置包含目录 target_include_directories(platform_utils PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../../include> $<INSTALL_INTERFACE:include> ) # 设置编译选项 target_compile_options(platform_utils PRIVATE $<$<CXX_COMPILER_ID:GNU|Clang>:-Wall -Wextra -Wpedantic> $<$<CXX_COMPILER_ID:MSVC>:/W4> ) # 链接系统库 find_package(Threads REQUIRED) target_link_libraries(platform_utils PUBLIC Threads::Threads ) # 设置属性 set_target_properties(platform_utils PROPERTIES POSITION_INDEPENDENT_CODE ON CXX_STANDARD 17 ) # 安装规则 install(TARGETS platform_utils EXPORT CrossPlatformProjectTargets LIBRARY DESTINATION lib ARCHIVE DESTINATION lib )

src/windows/CMakeLists.txt文件：

# 添加库 add_library(platform_utils STATIC platform_utils.cpp ) # 设置包含目录 target_include_directories(platform_utils PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../../include> $<INSTALL_INTERFACE:include> ) # 设置编译选项 target_compile_options(platform_utils PRIVATE $<$<CXX_COMPILER_ID:GNU|Clang>:-Wall -Wextra -Wpedantic> $<$<CXX_COMPILER_ID:MSVC>:/W4> ) # 设置Windows特定的定义 target_compile_definitions(platform_utils PRIVATE WIN32_LEAN_AND_MEAN NOMINMAX ) # 链接系统库 target_link_libraries(platform_utils PRIVATE ws2_32 # Winsock ) # 设置属性 set_target_properties(platform_utils PROPERTIES POSITION_INDEPENDENT_CODE ON CXX_STANDARD 17 ) # 安装规则 install(TARGETS platform_utils EXPORT CrossPlatformProjectTargets LIBRARY DESTINATION lib ARCHIVE DESTINATION lib )

src/app/CMakeLists.txt文件：

# 添加可执行文件 add_executable(myapp main.cpp ) # 设置包含目录 target_include_directories(myapp PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../../include ) # 设置编译选项 target_compile_options(myapp PRIVATE $<$<CXX_COMPILER_ID:GNU|Clang>:-Wall -Wextra> $<$<CXX_COMPILER_ID:MSVC>:/W4> ) # 链接依赖 target_link_libraries(myapp PRIVATE platform_utils ) # 设置属性 set_target_properties(myapp PROPERTIES CXX_STANDARD 17 ) # 安装规则 install(TARGETS myapp RUNTIME DESTINATION bin )

11. 最佳实践和总结

11.1 CMake最佳实践

在使用CMake时，遵循一些最佳实践可以帮助您创建更健壮、更易维护的构建系统：

11.1.1 使用现代CMake

现代CMake（3.0及以上版本）引入了许多改进，使构建系统更加模块化和可维护：

# 使用目标特定的命令而不是全局命令 # 推荐 target_include_directories(my_lib PRIVATE include) target_compile_definitions(my_lib PRIVATE MY_DEFINE) target_compile_options(my_lib PRIVATE -Wall) target_link_libraries(my_lib PRIVATE other_lib) # 不推荐 include_directories(include) add_definitions(-DMY_DEFINE) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall") link_libraries(other_lib)

11.1.2 使用变量和函数

使用变量和函数可以减少重复，提高可维护性：

# 定义常用变量 set(PROJECT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}) set(PROJECT_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}) set(PROJECT_INCLUDE_DIR ${PROJECT_SOURCE_DIR}/include) # 定义函数 function(add_common_target target_name) add_library(${target_name} ${ARGN}) target_include_directories(${target_name} PUBLIC $<BUILD_INTERFACE:${PROJECT_INCLUDE_DIR}> $<INSTALL_INTERFACE:include> ) target_compile_options(${target_name} PRIVATE $<$<CXX_COMPILER_ID:GNU|Clang>:-Wall -Wextra> $<$<CXX_COMPILER_ID:MSVC>:/W4> ) set_target_properties(${target_name} PROPERTIES POSITION_INDEPENDENT_CODE ON CXX_STANDARD 17 ) endfunction() # 使用函数 add_common_target(my_lib my_lib.cpp)

11.1.3 使用生成器表达式

生成器表达式提供了强大的条件逻辑，可以根据构建配置、平台等设置不同的参数：

# 使用生成器表达式 target_compile_definitions(my_lib PRIVATE $<$<CONFIG:Debug>:DEBUG_MODE> $<$<CONFIG:Release>:NDEBUG> $<$<PLATFORM_ID:Windows>:PLATFORM_WINDOWS> $<$<PLATFORM_ID:Linux>:PLATFORM_LINUX> ) target_compile_options(my_lib PRIVATE $<$<CXX_COMPILER_ID:GNU>:-Wall -Wextra> $<$<CXX_COMPILER_ID:MSVC>:/W4> )

11.1.4 使用目标属性

目标属性提供了对构建过程的细粒度控制：

# 设置目标属性 set_target_properties(my_lib PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION ${PROJECT_VERSION_MAJOR} POSITION_INDEPENDENT_CODE ON CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF )

11.1.5 使用导出和安装

正确地导出和安装目标可以使您的项目更容易被其他项目使用：

# 导出目标 install(TARGETS my_lib EXPORT MyProjectTargets LIBRARY DESTINATION lib ARCHIVE DESTINATION lib RUNTIME DESTINATION bin ) # 安装导出文件 install(EXPORT MyProjectTargets FILE MyProjectTargets.cmake NAMESPACE MyProject:: DESTINATION lib/cmake/MyProject ) # 创建和安装配置文件 include(CMakePackageConfigHelpers) write_basic_package_version_file( "${CMAKE_CURRENT_BINARY_DIR}/MyProjectConfigVersion.cmake" VERSION ${PROJECT_VERSION} COMPATIBILITY AnyNewerVersion ) configure_package_config_file( "${CMAKE_CURRENT_SOURCE_DIR}/MyProjectConfig.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/MyProjectConfig.cmake" INSTALL_DESTINATION lib/cmake/MyProject ) install( FILES "${CMAKE_CURRENT_BINARY_DIR}/MyProjectConfig.cmake" "${CMAKE_CURRENT_BINARY_DIR}/MyProjectConfigVersion.cmake" DESTINATION lib/cmake/MyProject )