1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# ❌ 传统写法（CMake 2.x 风格）—— 千万别再写了

# 设置头文件搜索路径 —— 问题：这会影响当前目录下的「所有」目标！
include_directories(${PROJECT_SOURCE_DIR}/include)

# 设置库搜索路径 —— 问题：同上，全局生效，后面的目标都会受影响
link_directories(/usr/local/lib)

# 添加编译宏 —— 问题：同上，所有目标都会定义这个宏
add_definitions(-DUSE_SSL)

add_executable(myapp main.cpp)
target_link_libraries(myapp ssl crypto)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# ✅ 现代写法 —— 每个目标管好自己的事

# 创建一个库目标叫 mylib
add_library(mylib src/mylib.cpp)

# 给 mylib 设置头文件路径：
#   PUBLIC  = 自己编译时用 + 别人链接我时也能用（公共头文件在这）
#   PRIVATE = 只有自己编译时用（内部实现细节，外部不需要知道）
target_include_directories(mylib
    PUBLIC  ${CMAKE_CURRENT_SOURCE_DIR}/include
    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src
)

# 给 mylib 定义编译宏，PUBLIC 表示链接我的人也会获得这个宏
target_compile_definitions(mylib PUBLIC USE_SSL)

# 创建可执行文件
add_executable(myapp main.cpp)

# myapp 链接 mylib（PRIVATE = myapp 的使用者不需要知道 mylib 的存在）
target_link_libraries(myapp PRIVATE mylib)
# 此时 myapp 自动获得：
#   - mylib 的 PUBLIC include 路径（include/）
#   - mylib 的 PUBLIC 宏定义（USE_SSL）
#   - 但看不到 mylib 的 PRIVATE 路径（src/）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# 创建一个 INTERFACE 库（不会生成 .a 或 .so 文件，仅作为"配置容器"）
add_library(json_utils INTERFACE)

# 对于 INTERFACE 库，只能用 INTERFACE 关键字
# （因为它自己不编译，不存在"自己用"的概念）
target_include_directories(json_utils
    INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/include
    #         ^^^^^^^^^ 意思：谁链接我，谁就把这个路径加到自己的头文件搜索路径
)

# 要求使用者至少用 C++20 编译（因为我的头文件里用了 C++20 语法）
target_compile_features(json_utils INTERFACE cxx_std_20)
#                                  ^^^^^^^^^ 意思：谁链接我，谁就得开启 C++20

1

你的 App ──(PRIVATE 依赖)──▶ LibB ──(PUBLIC 依赖)──▶ LibC

1

你的 App ──(PUBLIC 依赖)──▶ LibB ──(PUBLIC 依赖)──▶ LibC

1
2

$<条件:值>        ← 如果条件为真，展开为"值"；否则展开为空字符串
$<条件:真值,假值>  ← 三元表达式

1
2
3
4
5
6
7
8
9

target_compile_options(mylib PRIVATE
    # $<$<CONFIG:Debug>:...> 意思是：如果当前构建类型是 Debug，就使用冒号后面的选项
    $<$<CONFIG:Debug>:-O0 -g -fsanitize=address>
    #                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Debug 时：不优化 + 调试信息 + 地址检查

    # 如果当前构建类型是 Release，就使用这些选项
    $<$<CONFIG:Release>:-O3 -DNDEBUG>
    #                   ^^^^^^^^^^^^^ Release 时：最大优化 + 关闭 assert
)

1
2
3
4
5
6
7

target_compile_options(mylib PRIVATE
    # GCC 和 Clang 用 -W 系列
    $<$<CXX_COMPILER_ID:GNU,Clang>:-Wall -Wextra -Wpedantic>

    # MSVC 用 /W 系列
    $<$<CXX_COMPILER_ID:MSVC>:/W4 /permissive->
)

1
2
3
4
5
6
7
8
9

target_include_directories(mylib
    PUBLIC
        # BUILD_INTERFACE：在本项目内编译时，用源码目录的绝对路径
        $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>

        # INSTALL_INTERFACE：别人 find_package 找到我之后，用安装目录的相对路径
        $<INSTALL_INTERFACE:include>
        #                   ^^^^^^^ 相对于安装前缀（如 /usr/local/）
)

1
2
3
4
5
6
7
8

target_link_libraries(myapp PRIVATE
    # Windows 需要链接 Winsock 库
    $<$<PLATFORM_ID:Windows>:ws2_32 mswsock>

    # Linux 需要链接 pthread
    $<$<PLATFORM_ID:Linux>:pthread>
)
# 其他平台（如 macOS）什么都不链——生成表达式为空就是不添加

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

# find_package(包名 版本 REQUIRED COMPONENTS 子模块...)
#   包名      —— 库的名字，大小写敏感（一般首字母大写）
#   版本      —— 最低版本要求（可选）
#   REQUIRED  —— 找不到就报错终止（否则只是警告，继续配置）
#   COMPONENTS —— 大型库（如 Boost）有很多子模块，只列你需要的
find_package(Boost 1.82 REQUIRED COMPONENTS system json)
find_package(OpenSSL REQUIRED)
find_package(GTest REQUIRED)

add_executable(myapp main.cpp)
target_link_libraries(myapp
    PRIVATE
        # 这些 "Xxx::yyy" 格式叫 "imported targets"（导入目标）
        # 它们是 find_package 找到库后自动创建的"虚拟目标"
        # 链接它们时，头文件路径、编译选项等会自动传播——不需要你手动设置！
        Boost::system       # Boost 的 system 子模块
        Boost::json         # Boost 的 JSON 子模块
        OpenSSL::SSL        # OpenSSL 的 SSL 部分
        OpenSSL::Crypto     # OpenSSL 的 Crypto 部分
        GTest::gtest_main   # GoogleTest + 自动生成 main 函数
)

1
2
3
4
5
6
7
8
9

# ❌ 老式写法——find_package 设置一堆变量，你手动拼接
find_package(Boost REQUIRED)
include_directories(${Boost_INCLUDE_DIRS})    # 手动加头文件路径
target_link_libraries(myapp ${Boost_LIBRARIES})  # 手动加库文件

# ✅ 现代写法——直接用 imported target，一切自动传播
find_package(Boost REQUIRED COMPONENTS json)
target_link_libraries(myapp PRIVATE Boost::json)
# 头文件路径？自动有。编译宏？自动有。依赖的其他库？也自动有。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

# ===== 第一步：安装你的库目标 =====
install(TARGETS mylib
    EXPORT mylib-targets           # 把这个目标记录到一个"导出集"
    ARCHIVE DESTINATION lib        # .a/.lib 静态库文件放这
    LIBRARY DESTINATION lib        # .so/.dylib 动态库文件放这
    INCLUDES DESTINATION include   # 安装后头文件在这（给 INTERFACE 用）
)

# ===== 第二步：导出 targets 文件（核心！）=====
install(EXPORT mylib-targets
    FILE mylibTargets.cmake        # 生成的文件名
    NAMESPACE mylib::              # 给目标加命名空间前缀（最佳实践）
    DESTINATION lib/cmake/mylib    # 安装到这个相对路径
)
# 安装后，别人的 CMake 能在这找到 mylibTargets.cmake
# 里面定义了 mylib::mylib 这个 imported target

# ===== 第三步：生成 Config 文件（入口）=====
include(CMakePackageConfigHelpers)
configure_package_config_file(
    cmake/mylibConfig.cmake.in                    # 输入模板
    ${CMAKE_CURRENT_BINARY_DIR}/mylibConfig.cmake # 输出
    INSTALL_DESTINATION lib/cmake/mylib
)

# ===== 第四步：生成版本兼容文件 =====
write_basic_package_version_file(
    ${CMAKE_CURRENT_BINARY_DIR}/mylibConfigVersion.cmake
    VERSION ${PROJECT_VERSION}
    COMPATIBILITY SameMajorVersion  # 主版本号相同就认为兼容
)

# ===== 第五步：安装 Config 和 Version 文件 =====
install(FILES
    ${CMAKE_CURRENT_BINARY_DIR}/mylibConfig.cmake
    ${CMAKE_CURRENT_BINARY_DIR}/mylibConfigVersion.cmake
    DESTINATION lib/cmake/mylib
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# @PACKAGE_INIT@ 会被 CMake 自动替换为初始化代码
@PACKAGE_INIT@

# 如果你的库依赖其他库，在这里声明
# find_dependency 和 find_package 类似，但用于 Config 文件内部
include(CMakeFindDependencyMacro)
find_dependency(Boost 1.82 COMPONENTS system json)
find_dependency(OpenSSL)

# 加载实际的 targets 定义
include("${CMAKE_CURRENT_LIST_DIR}/mylibTargets.cmake")

# 检查所有请求的组件是否存在
check_required_components(mylib)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

/usr/local/
├── lib/
│   ├── libmylib.a                    ← 库文件本体
│   └── cmake/mylib/                  ← CMake 配置目录
│       ├── mylibConfig.cmake         ← find_package 的入口
│       ├── mylibConfigVersion.cmake  ← 版本检查
│       └── mylibTargets.cmake        ← imported target 定义
└── include/
    └── mylib/                        ← 公共头文件
        └── mylib.h

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 引入 FetchContent 模块（CMake 自带，不需要额外安装）
include(FetchContent)

# 声明依赖：告诉 CMake 去哪下载、下载哪个版本
FetchContent_Declare(
    googletest                      # 依赖的名字（你自己起，后面引用用）
    GIT_REPOSITORY https://github.com/google/googletest.git  # Git 仓库地址
    GIT_TAG        v1.14.0          # 具体版本标签（切忌用 master/main！）
    GIT_SHALLOW    TRUE             # 浅克隆：只下载这个 tag 的快照，不拉全部历史
)

FetchContent_Declare(
    fmt
    GIT_REPOSITORY https://github.com/fmtlib/fmt.git
    GIT_TAG        10.2.1
)

# 让 CMake 去下载并把它们加入构建（相当于 add_subdirectory）
FetchContent_MakeAvailable(googletest fmt)

# 下载完成后，就能直接用它们提供的 targets 了
target_link_libraries(myapp PRIVATE fmt::fmt GTest::gtest_main)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

FetchContent_Declare(
    fmt
    GIT_REPOSITORY https://github.com/fmtlib/fmt.git
    GIT_TAG        10.2.1
    FIND_PACKAGE_ARGS   # 这一行的含义：先执行 find_package(fmt)
                        # 如果系统上找到了，就直接用，不下载
                        # 如果找不到，再走 Git 下载流程
)
FetchContent_MakeAvailable(fmt)
# 不管是系统找到的还是下载的，后面都统一用 fmt::fmt

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

{
    "version": 6,   // Preset 文件格式版本（不是你项目的版本）
    "cmakeMinimumRequired": { "major": 3, "minor": 25 },

    // ===== 配置阶段 preset（cmake -B build 时用哪些选项）=====
    "configurePresets": [
        {
            "name": "dev-gcc",              // preset 的唯一标识符
            "displayName": "GCC Debug",     // 给人看的友好名称
            "generator": "Ninja",           // 用 Ninja 构建（比 Make 快）
            "binaryDir": "${sourceDir}/build/gcc-debug",  // 构建产物放哪
            "cacheVariables": {             // 等价于 -DXXX=YYY 参数
                "CMAKE_BUILD_TYPE": "Debug",
                "CMAKE_CXX_COMPILER": "g++-14",
                "CMAKE_EXPORT_COMPILE_COMMANDS": "ON"
            }
        },
        {
            "name": "dev-msvc",
            "displayName": "MSVC Release",
            "generator": "Ninja",
            "binaryDir": "${sourceDir}/build/msvc-release",
            "toolchainFile": "C:/vcpkg/scripts/buildsystems/vcpkg.cmake",
            "cacheVariables": {
                "CMAKE_BUILD_TYPE": "Release"
            }
        },
        {
            "name": "ci-linux",
            "displayName": "CI Linux",
            "inherits": "dev-gcc",          // 继承 dev-gcc 的所有配置，然后覆盖部分
            "cacheVariables": {
                "CMAKE_BUILD_TYPE": "Release",  // 只改这两个，其他沿用 dev-gcc
                "BUILD_TESTING": "ON"
            }
        }
    ],

    // ===== 构建阶段 preset（cmake --build 时的选项）=====
    "buildPresets": [
        {
            "name": "dev-gcc",
            "configurePreset": "dev-gcc",   // 关联到哪个 configure preset
            "jobs": 8                       // 并行编译数（-j8）
        }
    ],

    // ===== 测试阶段 preset（ctest 时的选项）=====
    "testPresets": [
        {
            "name": "dev-gcc",
            "configurePreset": "dev-gcc",
            "output": { "outputOnFailure": true },  // 失败时显示详细输出
            "execution": { "timeout": 60 }          // 单个测试超时 60 秒
        }
    ]
}

1
2
3
4
5
6
7
8

# 配置（替代：cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=Debug -DCMAKE_CXX_COMPILER=g++-14 ...）
cmake --preset dev-gcc

# 构建（替代：cmake --build build -j8）
cmake --build --preset dev-gcc

# 测试（替代：ctest --test-dir build --output-on-failure --timeout 60）
ctest --preset dev-gcc

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

# 文件名：arm-toolchain.cmake
# 用途：在 x86 机器上编译 ARM64 Linux 的程序

# 告诉 CMake：目标系统是 Linux（不是当前的 Windows/macOS）
set(CMAKE_SYSTEM_NAME Linux)
# 目标 CPU 架构是 aarch64（ARM 64 位）
set(CMAKE_SYSTEM_PROCESSOR aarch64)

# 指定交叉编译器（这些编译器生成 ARM 代码，而非 x86 代码）
set(CMAKE_C_COMPILER   aarch64-linux-gnu-gcc)
set(CMAKE_CXX_COMPILER aarch64-linux-gnu-g++)

# 告诉 CMake 去哪找目标平台的库和头文件
set(CMAKE_FIND_ROOT_PATH /usr/aarch64-linux-gnu)

# 查找策略：
#   NEVER = 不在 sysroot 里找可执行程序（用宿主机的 cmake/make 等）
#   ONLY  = 只在 sysroot 里找库/头文件（不要找到宿主机的 x86 库）
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

1
2
3
4

# 在配置阶段通过 -DCMAKE_TOOLCHAIN_FILE 传入
cmake -B build -DCMAKE_TOOLCHAIN_FILE=arm-toolchain.cmake
cmake --build build
# 生成的二进制文件是 ARM 架构的，不能在当前 x86 机器上直接运行

1

cmake -B build -DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake

1
2
3
4
5
6
7

{
    "name": "vcpkg-release",
    "toolchainFile": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake",
    "cacheVariables": {
        "CMAKE_BUILD_TYPE": "Release"
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

project/
├── CMakeLists.txt              # 顶层入口：定义项目、选项、引入子目录
├── CMakePresets.json           # 构建配置 preset（团队共享）
├── cmake/                      # 自定义 CMake 模块（可复用的 .cmake 脚本）
│   ├── projectConfig.cmake.in  #   → 第四章讲的 Config 模板
│   └── CompilerWarnings.cmake  #   → 封装编译器警告设置的函数
├── src/                        # 库的源码（.cpp 和内部 .h）
│   ├── CMakeLists.txt          #   → 定义库 target
│   ├── core/                   #   → 按功能模块划分子目录
│   └── utils/
├── include/                    # 公共头文件（别人 include 的入口）
│   └── project/                #   → 加一层项目名前缀，避免冲突
│       └── project.h           #   → #include <project/project.h>
├── tests/                      # 测试代码
│   └── CMakeLists.txt          #   → 定义测试 target
├── examples/                   # 使用示例
│   └── CMakeLists.txt
└── docs/                       # 文档

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

# ===== 这一行必须是文件的第一条命令 =====
# 声明最低 CMake 版本要求（3.20 是目前比较安全的起点）
cmake_minimum_required(VERSION 3.20)

# 声明项目信息
# VERSION：语义化版本号，后面可以通过 PROJECT_VERSION_MAJOR/MINOR/PATCH 引用
# LANGUAGES：本项目用到的语言（CXX = C++）
project(myproject
    VERSION 1.2.0
    LANGUAGES CXX
    DESCRIPTION "A modern C++ project"
)

# ===== 仅当本项目是顶层项目时，才设置这些选项 =====
# 为什么？因为如果别人通过 FetchContent 把你的项目拉进去当子目录，
# 你不应该覆盖他们的全局设置
if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
    # 禁止 GNU 扩展（如 typeof、typeof 等），确保代码可移植
    set(CMAKE_CXX_EXTENSIONS OFF)

    # 定义构建选项（用户可以通过 -DBUILD_TESTING=OFF 关闭）
    option(BUILD_TESTING "Build tests" ON)
    option(BUILD_EXAMPLES "Build examples" ON)
endif()

# ===== 声明外部依赖 =====
find_package(Boost 1.82 REQUIRED COMPONENTS system json)
find_package(OpenSSL REQUIRED)

# ===== 添加子目录（每个子目录有自己的 CMakeLists.txt）=====
add_subdirectory(src)   # 核心库

# 测试：仅在开启时编译（CI 可能 OFF 以节省时间）
if(BUILD_TESTING)
    enable_testing()          # 告诉 CMake "本项目有测试"
    add_subdirectory(tests)
endif()

# 示例
if(BUILD_EXAMPLES)
    add_subdirectory(examples)
endif()

1
2
3

# ❌ 看起来很方便，实际上是定时炸弹
file(GLOB SOURCES "src/*.cpp")
add_library(mylib ${SOURCES})

1
2
3
4
5
6

# ✅ 虽然啰嗦，但安全可靠
add_library(mylib
    src/core.cpp
    src/router.cpp
    src/middleware.cpp
)

1
2
3

# 折中方案：每次构建前重新扫描目录
# 注意：官方说这"不保证在所有生成器上都有效"，但实际上 Ninja/Make 都支持
file(GLOB_RECURSE SOURCES CONFIGURE_DEPENDS "src/*.cpp")

1
2
3
4
5

# ❌ 修改全局变量——影响所有 target（包括第三方库！）
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")

# ✅ 只影响指定目标
target_compile_options(mylib PRIVATE -Wall)

1
2
3
4
5
6
7

# ✅ 正确顺序
cmake_minimum_required(VERSION 3.20)
project(myapp)

# ❌ 错误——project() 在前，CMake 会用默认的旧版 policy 行为
project(myapp)
cmake_minimum_required(VERSION 3.20)

1
2

# 意思是：我最低需要 3.20，但请启用到 3.30 的所有 policy 改进
cmake_minimum_required(VERSION 3.20...3.30)

1
2
3
4
5

# ❌ 老代码常见写法——含义模糊，CMake 会猜测传播行为
target_link_libraries(myapp Boost::system)

# ✅ 现代写法——显式声明：这个依赖是 myapp 的私有实现细节
target_link_libraries(myapp PRIVATE Boost::system)

1
2
3
4
5
6

# ❌ 全局设置库搜索路径——和 include_directories 一样是全局污染
link_directories(/opt/mylibs/lib)

# ✅ 正确方式：通过 find_package 或 imported target 传递
find_package(MyLib REQUIRED)
target_link_libraries(myapp PRIVATE MyLib::MyLib)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

# 文件：cmake/CompilerWarnings.cmake
# 用法：include(cmake/CompilerWarnings.cmake)
#       set_project_warnings(mylib)

function(set_project_warnings target)
    # GCC / Clang 的警告选项
    set(GCC_WARNINGS
        -Wall                   # 基本警告全开
        -Wextra                 # 额外警告
        -Wpedantic              # 严格标准兼容
        -Wshadow                # 变量遮蔽（外层同名变量被内层覆盖）
        -Wnon-virtual-dtor      # 基类析构不是 virtual（可能内存泄漏）
        -Wold-style-cast        # C 风格强转（建议用 static_cast 等）
        -Wcast-align            # 可能导致未对齐访问的转换
        -Woverloaded-virtual    # 重载（而非覆写）了虚函数
        -Wconversion            # 隐式类型转换可能丢失数据
        -Wsign-conversion       # signed/unsigned 隐式转换
        -Wnull-dereference      # 可能解引用空指针
        -Wformat=2              # printf 格式串检查
        -Wimplicit-fallthrough  # switch case 缺少 break/[[fallthrough]]
    )

    # MSVC 的警告选项（/W4 已经相当于 GCC 的 -Wall -Wextra）
    set(MSVC_WARNINGS
        /W4             # 开启到第 4 级警告
        /permissive-    # 严格标准模式
        /w14242         # 类型转换精度丢失
        /w14254         # 逻辑位运算符优先级
        /w14263         # 成员函数不覆写基类虚函数
        /w14265         # 类有虚函数但析构不是 virtual
        /w14287         # 无符号/负常量不匹配
        /w14296         # 表达式永远为 true/false
    )

    # 根据编译器选择对应的警告集
    if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
        target_compile_options(${target} PRIVATE ${MSVC_WARNINGS})
    else()
        target_compile_options(${target} PRIVATE ${GCC_WARNINGS})
    endif()
endfunction()

1
2
3
4

include(cmake/CompilerWarnings.cmake)

add_library(mylib src/mylib.cpp)
set_project_warnings(mylib)  # 一行搞定

1
2

# 在顶层 CMakeLists.txt 或 Preset 里设置
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 基本选项：用户可以通过 -DMYPROJECT_WITH_SSL=OFF 关闭
# option(变量名 "描述文字" 默认值)
option(MYPROJECT_WITH_SSL "Enable SSL support" ON)

# 依赖选项：只有当 SSL 开启时，HTTP/2 选项才有意义
include(CMakeDependentOption)
cmake_dependent_option(
    MYPROJECT_WITH_HTTP2            # 选项变量名
    "Enable HTTP/2 (requires SSL)" # 描述
    ON                              # 默认值（在条件满足时）
    "MYPROJECT_WITH_SSL"            # 前置条件（为真时选项才可用）
    OFF                             # 条件不满足时强制设为 OFF
)
# 效果：如果用户关了 SSL，HTTP/2 自动关闭，cmake-gui 里也不显示这个选项

1
2
3
4
5
6
7
8

# CMakeLists.txt
project(mylib VERSION 2.6.0)   # 唯一的版本号来源

# 用 configure_file 自动生成版本头文件
configure_file(
    src/Version.h.in                                    # 输入模板
    ${CMAKE_CURRENT_BINARY_DIR}/include/mylib/Version.h # 输出到构建目录
)

1
2
3
4
5
6
7

#pragma once

// @xxx@ 会被 CMake 替换为实际值
#define MYLIB_VERSION_MAJOR @PROJECT_VERSION_MAJOR@   // → 2
#define MYLIB_VERSION_MINOR @PROJECT_VERSION_MINOR@   // → 6
#define MYLIB_VERSION_PATCH @PROJECT_VERSION_PATCH@   // → 0
#define MYLIB_VERSION       "@PROJECT_VERSION@"       // → "2.6.0"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

{
    "name": "myproject",
    "version-semver": "1.0.0",
    "dependencies": [
        "boost-asio",       // 只装 Boost 的 Asio 模块（不是整个 Boost）
        "boost-json",
        "openssl",
        "gtest"
    ]
}

1
2
3

# 通过 toolchain 文件告诉 CMake "用 vcpkg 找依赖"
cmake -B build -DCMAKE_TOOLCHAIN_FILE=$VCPKG_ROOT/scripts/buildsystems/vcpkg.cmake
cmake --build build

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# conanfile.py
from conan import ConanFile
from conan.tools.cmake import cmake_layout

class MyProjectConan(ConanFile):
    settings = "os", "compiler", "build_type", "arch"  # 影响编译的环境因素
    generators = "CMakeDeps", "CMakeToolchain"          # 生成 CMake 能理解的文件

    def requirements(self):
        self.requires("boost/1.84.0")    # 声明依赖和精确版本
        self.requires("openssl/3.2.0")

    def layout(self):
        cmake_layout(self)  # 使用标准 CMake 目录布局

1
2
3
4
5
6
7
8

# 第一步：安装依赖（Conan 下载/编译依赖，生成 CMake toolchain）
conan install . --output-folder=build --build=missing

# 第二步：正常 CMake 配置（使用 Conan 生成的 toolchain）
cmake -B build -DCMAKE_TOOLCHAIN_FILE=build/conan_toolchain.cmake

# 第三步：正常构建
cmake --build build

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# 在顶层 CMakeLists.txt 里开启测试支持
enable_testing()

# 创建测试可执行文件
add_executable(test_router tests/test_router.cpp)
target_link_libraries(test_router PRIVATE mylib GTest::gtest_main)
#                                               ^^^^^^^^^^^^^^^^
# gtest_main 提供了 main 函数，你的测试文件不需要自己写 main()

# 自动发现测试用例（CMake 3.10+，推荐方式）
include(GoogleTest)  # 引入 CMake 自带的 GoogleTest 集成模块
gtest_discover_tests(test_router
    # gtest_discover_tests 会在构建后运行你的测试程序加 --gtest_list_tests 参数
    # 自动把每个 TEST/TEST_F 注册为一个 CTest 测试用例
    PROPERTIES TIMEOUT 60  # 每个测试用例超时 60 秒
)

1
2
3
4
5
6

gtest_discover_tests(test_integration
    PROPERTIES
        TIMEOUT 120                         # 集成测试通常更慢，给更多时间
        LABELS "integration"                # 打标签，方便过滤
        ENVIRONMENT "TEST_DB_HOST=localhost" # 注入环境变量
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 运行所有测试
ctest --test-dir build --output-on-failure

# 只运行带 "integration" 标签的测试
ctest --test-dir build -L integration --output-on-failure

# 只运行名字匹配 "Router" 的测试
ctest --test-dir build -R Router --output-on-failure

# 并行运行（-j4 = 4 个测试同时跑）
ctest --test-dir build -j4 --output-on-failure

# MSVC 多配置生成器需要指定配置
ctest --test-dir build -C Release --output-on-failure

1

从 "我在这个目录下需要什么" → "这个目标需要什么、暴露什么"