掌握CMake多版本控制技术提升项目构建与管理的灵活性

威震华夏关云长 · 发表于 2025-9-2 17:30:00

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要登录才可以下载或查看，没有账号？立即注册

x

引言

CMake作为跨平台的构建系统生成工具，已成为现代C++项目开发的事实标准。在实际开发中，项目往往需要支持多个版本、多个平台或多种配置，这就要求开发者掌握CMake多版本控制技术。通过灵活运用这些技术，可以显著提升项目构建与管理的灵活性，使项目能够适应不同的需求和场景，从而提高开发效率和产品质量。

CMake基础回顾

CMake使用CMakeLists.txt文件来配置构建过程。这些文件包含一系列命令和指令，用于定义项目、设置编译选项、查找依赖库、生成构建文件等。CMake支持多种生成器，如Unix Makefiles、Ninja、Visual Studio等，可以在不同平台上生成相应的构建文件。

CMake的基本工作流程如下：

1. 编写CMakeLists.txt文件
2. 运行cmake命令生成构建文件
3. 使用生成的构建文件进行编译和链接

一个简单的CMakeLists.txt示例：

cmake_minimum_required(VERSION 3.10)
project(MyProject VERSION 1.0.0)
add_executable(my_app
src/main.cpp
src/utils.cpp
)
target_include_directories(my_app PRIVATE include)

复制代码

CMake版本控制基础

在CMake中，版本控制主要涉及以下几个方面：

1. CMake自身的版本控制：不同版本的CMake可能支持不同的功能和语法
2. 项目版本控制：管理项目自身的版本号和版本信息
3. 依赖库版本控制：管理项目依赖的外部库的版本
4. 目标版本控制：管理项目中不同目标的版本和配置

CMake提供了一些内置变量和命令来支持版本控制：

# 指定所需的CMake最低版本
cmake_minimum_required(VERSION 3.10)
# 设置项目名称和版本
project(MyProject VERSION 1.2.3 LANGUAGES CXX)
# 查找依赖包并指定版本要求
find_package(Boost 1.70.0 REQUIRED COMPONENTS filesystem system)
# 设置目标版本属性
set_target_properties(my_lib PROPERTIES
VERSION ${PROJECT_VERSION}
SOVERSION 1
)

复制代码

多版本控制策略

在实际项目中，可能需要根据不同的需求采用不同的多版本控制策略：

1. 条件编译策略

根据不同的版本或平台，使用条件语句来包含或排除特定的代码或配置。

cmake_minimum_required(VERSION 3.10)
project(ConditionalBuild VERSION 1.0.0)
# 根据CMake版本使用不同的功能
if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.12)
# 使用CMake 3.12及以上版本的新功能
add_library(example_lib STATIC)
target_sources(example_lib PRIVATE
src/file1.cpp
src/file2.cpp
)
else()
# 对于旧版本，使用传统方式
add_library(example_lib STATIC
src/file1.cpp
src/file2.cpp
)
endif()
# 根据平台设置不同的编译选项
if(WIN32)
target_compile_definitions(example_lib PRIVATE WINDOWS_PLATFORM)
target_link_libraries(example_lib PRIVATE ws2_32)
elseif(UNIX AND NOT APPLE)
target_compile_definitions(example_lib PRIVATE LINUX_PLATFORM)
target_link_libraries(example_lib PRIVATE pthread)
elseif(APPLE)
target_compile_definitions(example_lib PRIVATE MACOS_PLATFORM)
endif()

复制代码

2. 特性开关策略

通过CMake选项来控制特定功能的开启或关闭，从而生成不同版本的产品。

cmake_minimum_required(VERSION 3.10)
project(FeatureToggle VERSION 1.0.0)
# 定义特性开关
option(ENABLE_FEATURE_A "Enable Feature A" ON)
option(ENABLE_FEATURE_B "Enable Feature B" OFF)
option(ENABLE_ADVANCED_FEATURES "Enable Advanced Features" OFF)
# 根据特性开关添加不同的源文件
set(COMMON_SOURCES
src/main.cpp
src/common.cpp
)
if(ENABLE_FEATURE_A)
list(APPEND COMMON_SOURCES src/feature_a.cpp)
target_compile_definitions(feature_toggle_app PRIVATE ENABLE_FEATURE_A)
endif()
if(ENABLE_FEATURE_B)
list(APPEND COMMON_SOURCES src/feature_b.cpp)
target_compile_definitions(feature_toggle_app PRIVATE ENABLE_FEATURE_B)
endif()
if(ENABLE_ADVANCED_FEATURES)
list(APPEND COMMON_SOURCES
src/advanced_feature1.cpp
src/advanced_feature2.cpp
)
target_compile_definitions(feature_toggle_app PRIVATE ENABLE_ADVANCED_FEATURES)
# 高级特性可能需要额外的依赖
find_package(Boost REQUIRED)
target_link_libraries(feature_toggle_app PRIVATE Boost::boost)
endif()
# 添加可执行文件
add_executable(feature_toggle_app ${COMMON_SOURCES})

复制代码

3. 组件化策略

将项目分解为多个组件，每个组件可以独立开发和版本控制，然后根据需要组合不同的组件版本。

# 根CMakeLists.txt
cmake_minimum_required(VERSION 3.10)
project(ComponentExample VERSION 1.0.0)
# 添加子目录
add_subdirectory(core)
add_subdirectory(utils)
add_subdirectory(app)
# 根据构建类型包含不同的组件
if(BUILD_TESTING)
enable_testing()
add_subdirectory(tests)
endif()
if(BUILD_EXAMPLES)
add_subdirectory(examples)
endif()

复制代码

# core/CMakeLists.txt
cmake_minimum_required(VERSION 3.10)
# 创建核心库
add_library(core_lib
src/core.cpp
include/core/core.h
)
# 设置包含目录
target_include_directories(core_lib
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>
)
# 设置版本属性
set_target_properties(core_lib PROPERTIES
VERSION ${PROJECT_VERSION}
SOVERSION 1
PUBLIC_HEADER "include/core/core.h"
)
# 安装规则
install(TARGETS core_lib
EXPORT CoreTargets
LIBRARY DESTINATION lib
ARCHIVE DESTINATION lib
RUNTIME DESTINATION bin
PUBLIC_HEADER DESTINATION include
)

复制代码

# utils/CMakeLists.txt
cmake_minimum_required(VERSION 3.10)
# 创建工具库
add_library(utils_lib
src/utils.cpp
include/utils/utils.h
)
# 设置包含目录
target_include_directories(utils_lib
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>
)
# 链接核心库
target_link_libraries(utils_lib
PUBLIC
core_lib
)
# 设置版本属性
set_target_properties(utils_lib PROPERTIES
VERSION ${PROJECT_VERSION}
SOVERSION 1
PUBLIC_HEADER "include/utils/utils.h"
)
# 安装规则
install(TARGETS utils_lib
EXPORT UtilsTargets
LIBRARY DESTINATION lib
ARCHIVE DESTINATION lib
RUNTIME DESTINATION bin
PUBLIC_HEADER DESTINATION include
)

复制代码

4. 依赖管理策略

使用外部依赖管理工具来管理依赖库的版本，确保不同项目使用一致的依赖版本。

cmake_minimum_required(VERSION 3.10)
project(DependencyManagement VERSION 1.0.0)
# 使用FetchContent下载和管理依赖
include(FetchContent)
# 声明依赖
FetchContent_Declare(
googletest
GIT_REPOSITORY https://github.com/google/googletest.git
GIT_TAG release-1.11.0
)
# 下载依赖
FetchContent_MakeAvailable(googletest)
# 使用find_package查找其他依赖
find_package(OpenSSL 1.1.1 REQUIRED)
if(OpenSSL_FOUND)
message(STATUS "Found OpenSSL version: ${OPENSSL_VERSION}")
endif()
# 使用ExternalProject添加更复杂的依赖
include(ExternalProject)
ExternalProject_Add(
external_example
GIT_REPOSITORY https://github.com/example/external_example.git
GIT_TAG v1.2.3
CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=<INSTALL_DIR>
INSTALL_DIR ${CMAKE_BINARY_DIR}/external
)
# 创建可执行文件
add_executable(dependency_app
src/main.cpp
)
# 链接依赖库
target_link_libraries(dependency_app
PRIVATE
gtest
gtest_main
OpenSSL::SSL
OpenSSL::Crypto
)
# 添加外部项目的头文件路径和库
include_directories(${CMAKE_BINARY_DIR}/external/include)
add_dependencies(dependency_app external_example)
target_link_libraries(dependency_app
PRIVATE
${CMAKE_BINARY_DIR}/external/lib/libexternal_example.a
)

复制代码

高级多版本控制技术

1. 使用生成器表达式

CMake的生成器表达式是一种强大的工具，可以在生成构建系统时进行条件判断。它们通常用于为目标设置特定于配置、平台或其他条件的属性。

cmake_minimum_required(VERSION 3.10)
project(GeneratorExpressions VERSION 1.0.0)
add_library(example_lib STATIC
src/file1.cpp
src/file2.cpp
)
# 使用生成器表达式设置不同的定义
target_compile_definitions(example_lib PRIVATE
$<$<PLATFORM_ID:Windows>:WINDOWS_PLATFORM>
$<$<PLATFORM_ID:Linux>:LINUX_PLATFORM>
$<$<PLATFORM_ID:Darwin>:MACOS_PLATFORM>
)
# 使用生成器表达式设置不同的编译选项
target_compile_options(example_lib PRIVATE
$<$<CXX_COMPILER_ID:GNU>:-Wall -Wextra>
$<$<CXX_COMPILER_ID:Clang>:-Wall -Wextra>
$<$<CXX_COMPILER_ID:MSVC>:/W4>
)
# 使用生成器表达式设置不同的链接库
target_link_libraries(example_lib PRIVATE
$<$<PLATFORM_ID:Windows>:ws2_32>
$<$<PLATFORM_ID:Linux>:pthread>
)
# 使用生成器表达式根据配置设置不同的定义
target_compile_definitions(example_lib PRIVATE
$<$<CONFIG:Debug>:DEBUG_MODE>
$<$<CONFIG:Release>:NDEBUG>
)

复制代码

2. 使用CMake脚本模式

CMake不仅可以用作构建系统生成工具，还可以用作脚本语言，通过-P选项运行CMake脚本。这可以用于实现一些复杂的版本控制逻辑。

# version_script.cmake
# 这是一个CMake脚本，用于处理版本控制逻辑
# 读取版本文件
file(STRINGS "VERSION" VERSION_LINES REGEX "^[^#]")
# 解析版本信息
foreach(LINE ${VERSION_LINES})
if(LINE MATCHES "VERSION_MAJOR=([0-9]+)")
set(VERSION_MAJOR ${CMAKE_MATCH_1})
elseif(LINE MATCHES "VERSION_MINOR=([0-9]+)")
set(VERSION_MINOR ${CMAKE_MATCH_1})
elseif(LINE MATCHES "VERSION_PATCH=([0-9]+)")
set(VERSION_PATCH ${CMAKE_MATCH_1})
elseif(LINE MATCHES "VERSION_EXTRA=([a-zA-Z0-9]+)")
set(VERSION_EXTRA ${CMAKE_MATCH_1})
endif()
endforeach()
# 构建完整版本字符串
set(VERSION_STRING "${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}")
if(VERSION_EXTRA)
set(VERSION_STRING "${VERSION_STRING}-${VERSION_EXTRA}")
endif()
# 输出版本信息
message(STATUS "Version: ${VERSION_STRING}")
message(STATUS "Major: ${VERSION_MAJOR}")
message(STATUS "Minor: ${VERSION_MINOR}")
message(STATUS "Patch: ${VERSION_PATCH}")
if(VERSION_EXTRA)
message(STATUS "Extra: ${VERSION_EXTRA}")
endif()
# 生成版本头文件
configure_file(
"version.h.in"
"version.h"
@ONLY
)
message(STATUS "Generated version.h")

复制代码

# VERSION文件示例
VERSION_MAJOR=1
VERSION_MINOR=0
VERSION_PATCH=0
VERSION_EXTRA=beta

复制代码

// version.h.in示例
#ifndef VERSION_H
#define VERSION_H
#define VERSION_MAJOR @VERSION_MAJOR@
#define VERSION_MINOR @VERSION_MINOR@
#define VERSION_PATCH @VERSION_PATCH@
#define VERSION_STRING "@VERSION_STRING@"
#endif // VERSION_H

复制代码

要运行这个脚本，可以使用以下命令：

cmake -P version_script.cmake

复制代码

3. 使用CMake函数和宏

CMake支持定义函数和宏，这可以帮助我们封装常用的版本控制逻辑，提高代码的重用性。

cmake_minimum_required(VERSION 3.10)
project(FunctionsAndMacros VERSION 1.0.0)
# 定义一个函数，用于添加具有版本控制的库
function(add_versioned_library LIB_NAME VERSION)
# 解析版本参数
set(VERSION_ARGS ${VERSION})
list(LENGTH VERSION_ARGS VERSION_COUNT)
if(VERSION_COUNT EQUAL 1)
set(VERSION_MAJOR ${VERSION})
set(VERSION_MINOR 0)
set(VERSION_PATCH 0)
elseif(VERSION_COUNT EQUAL 2)
list(GET VERSION_ARGS 0 VERSION_MAJOR)
list(GET VERSION_ARGS 1 VERSION_MINOR)
set(VERSION_PATCH 0)
elseif(VERSION_COUNT EQUAL 3)
list(GET VERSION_ARGS 0 VERSION_MAJOR)
list(GET VERSION_ARGS 1 VERSION_MINOR)
list(GET VERSION_ARGS 2 VERSION_PATCH)
else()
message(FATAL_ERROR "Invalid version format: ${VERSION}")
endif()
# 构建版本字符串
set(VERSION_STRING "${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}")
# 创建库
add_library(${LIB_NAME} STATIC)
# 设置版本属性
set_target_properties(${LIB_NAME} PROPERTIES
VERSION ${VERSION_STRING}
SOVERSION ${VERSION_MAJOR}
)
# 输出信息
message(STATUS "Added versioned library ${LIB_NAME} with version ${VERSION_STRING}")
endfunction()
# 定义一个宏，用于条件添加源文件
macro(conditionally_add_sources TARGET_NAME)
foreach(SOURCE ${ARGN})
if(EXISTS ${SOURCE})
target_sources(${TARGET_NAME} PRIVATE ${SOURCE})
message(STATUS "Added source file: ${SOURCE}")
else()
message(WARNING "Source file not found: ${SOURCE}")
endif()
endforeach()
endmacro()
# 使用函数添加版本控制的库
add_versioned_library(example_lib 1 2 3)
# 使用宏条件添加源文件
conditionally_add_sources(example_lib
src/file1.cpp
src/file2.cpp
src/file3.cpp
)

复制代码

4. 版本比较与检查

实现版本比较和检查功能，确保依赖库的版本满足项目要求。

cmake_minimum_required(VERSION 3.10)
project(VersionComparison VERSION 1.0.0)
# 定义一个函数，用于解析版本字符串
function(parse_version_string VERSION_STRING OUTPUT_VAR)
# 使用正则表达式匹配版本字符串
string(REGEX MATCH "^([0-9]+)\\.([0-9]+)\\.([0-9]+)(-([a-zA-Z0-9]+))?$" VERSION_MATCH ${VERSION_STRING})
if(VERSION_MATCH)
set(VERSION_MAJOR ${CMAKE_MATCH_1})
set(VERSION_MINOR ${CMAKE_MATCH_2})
set(VERSION_PATCH ${CMAKE_MATCH_3})
set(VERSION_EXTRA ${CMAKE_MATCH_5})
# 设置输出变量
set(${OUTPUT_VAR}_MAJOR ${VERSION_MAJOR} PARENT_SCOPE)
set(${OUTPUT_VAR}_MINOR ${VERSION_MINOR} PARENT_SCOPE)
set(${OUTPUT_VAR}_PATCH ${VERSION_PATCH} PARENT_SCOPE)
set(${OUTPUT_VAR}_EXTRA ${VERSION_EXTRA} PARENT_SCOPE)
set(${OUTPUT_VAR}_STRING ${VERSION_STRING} PARENT_SCOPE)
else()
message(FATAL_ERROR "Invalid version string: ${VERSION_STRING}")
endif()
endfunction()
# 定义一个函数，用于比较版本
function(compare_versions VERSION1 OP VERSION2 RESULT_VAR)
# 解析版本字符串
parse_version_string(${VERSION1} V1)
parse_version_string(${VERSION2} V2)
# 比较主版本号
if(V1_MAJOR GREATER V2_MAJOR)
set(RESULT TRUE)
elseif(V1_MAJOR LESS V2_MAJOR)
set(RESULT FALSE)
else()
# 主版本号相同，比较次版本号
if(V1_MINOR GREATER V2_MINOR)
set(RESULT TRUE)
elseif(V1_MINOR LESS V2_MINOR)
set(RESULT FALSE)
else()
# 次版本号相同，比较修订号
if(V1_PATCH GREATER V2_PATCH)
set(RESULT TRUE)
elseif(V1_PATCH LESS V2_PATCH)
set(RESULT FALSE)
else()
# 修订号相同，比较额外版本
if(DEFINED V1_EXTRA AND NOT DEFINED V2_EXTRA)
set(RESULT FALSE)
elseif(NOT DEFINED V1_EXTRA AND DEFINED V2_EXTRA)
set(RESULT TRUE)
elseif(DEFINED V1_EXTRA AND DEFINED V2_EXTRA)
string(COMPARE LESS ${V1_EXTRA} ${V2_EXTRA} RESULT)
else()
set(RESULT FALSE)
endif()
endif()
endif()
endif()
# 根据操作符调整结果
if(OP STREQUAL "EQUAL")
string(COMPARE EQUAL ${VERSION1} ${VERSION2} RESULT)
elseif(OP STREQUAL "LESS")
string(COMPARE LESS ${VERSION1} ${VERSION2} RESULT)
elseif(OP STREQUAL "GREATER")
string(COMPARE GREATER ${VERSION1} ${VERSION2} RESULT)
elseif(OP STREQUAL "LESS_EQUAL")
string(COMPARE LESS ${VERSION1} ${VERSION2} TEMP)
string(COMPARE EQUAL ${VERSION1} ${VERSION2} TEMP2)
set(RESULT ${TEMP} OR ${TEMP2})
elseif(OP STREQUAL "GREATER_EQUAL")
string(COMPARE GREATER ${VERSION1} ${VERSION2} TEMP)
string(COMPARE EQUAL ${VERSION1} ${VERSION2} TEMP2)
set(RESULT ${TEMP} OR ${TEMP2})
else()
message(FATAL_ERROR "Invalid comparison operator: ${OP}")
endif()
# 设置输出变量
set(${RESULT_VAR} ${RESULT} PARENT_SCOPE)
endfunction()
# 使用函数比较版本
compare_versions("1.2.3" "GREATER" "1.2.2" RESULT)
message(STATUS "1.2.3 > 1.2.2: ${RESULT}")
compare_versions("1.2.3" "LESS" "1.2.4" RESULT)
message(STATUS "1.2.3 < 1.2.4: ${RESULT}")
compare_versions("1.2.3" "EQUAL" "1.2.3" RESULT)
message(STATUS "1.2.3 == 1.2.3: ${RESULT}")
# 定义一个宏，用于检查依赖版本
macro(check_dependency_version PACKAGE_NAME VERSION_STRING)
# 查找包
find_package(${PACKAGE_NAME} QUIET)
# 检查是否找到包
if(NOT ${PACKAGE_NAME}_FOUND)
message(FATAL_ERROR "Package ${PACKAGE_NAME} not found")
endif()
# 获取包的版本
if(DEFINED ${PACKAGE_NAME}_VERSION)
set(DEPENDENCY_VERSION ${${PACKAGE_NAME}_VERSION})
elseif(DEFINED ${PACKAGE_NAME}_VERSION_STRING)
set(DEPENDENCY_VERSION ${${PACKAGE_NAME}_VERSION_STRING})
else()
message(WARNING "Cannot determine version of package ${PACKAGE_NAME}")
return()
endif()
# 比较版本
compare_versions(${DEPENDENCY_VERSION} "GREATER_EQUAL" ${VERSION_STRING} VERSION_OK)
# 输出结果
if(VERSION_OK)
message(STATUS "Package ${PACKAGE_NAME} version ${DEPENDENCY_VERSION} meets requirement ${VERSION_STRING}")
else()
message(FATAL_ERROR "Package ${PACKAGE_NAME} version ${DEPENDENCY_VERSION} does not meet requirement ${VERSION_STRING}")
endif()
endmacro()
# 使用宏检查依赖版本
check_dependency_version(OpenSSL "1.1.1")

复制代码

实际应用案例

案例1：多平台支持与条件编译

cmake_minimum_required(VERSION 3.10)
project(CrossPlatformApp VERSION 1.0.0)
# 设置C++标准
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
# 根据平台设置不同的编译选项
if(WIN32)
add_definitions(-DWINDOWS_PLATFORM)
set(PLATFORM_SOURCES src/windows_specific.cpp)
set(PLATFORM_LIBS ws2_32)
elseif(UNIX AND NOT APPLE)
add_definitions(-DLINUX_PLATFORM)
set(PLATFORM_SOURCES src/linux_specific.cpp)
set(PLATFORM_LIBS pthread)
elseif(APPLE)
add_definitions(-DMACOS_PLATFORM)
set(PLATFORM_SOURCES src/macos_specific.cpp)
set(PLATFORM_LIBS "-framework Foundation")
endif()
# 根据编译器设置不同的警告选项
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
set(COMMON_WARNING_FLAGS "-Wall -Wextra -Wpedantic")
if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
list(APPEND COMMON_WARNING_FLAGS "-Wshadow")
endif()
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
set(COMMON_WARNING_FLAGS "/W4")
endif()
# 添加可执行文件
add_executable(cross_platform_app
src/main.cpp
src/common.cpp
${PLATFORM_SOURCES}
)
# 设置编译选项
target_compile_options(cross_platform_app PRIVATE ${COMMON_WARNING_FLAGS})
# 链接库
target_link_libraries(cross_platform_app PRIVATE ${PLATFORM_LIBS})
# 根据构建类型设置不同的定义
target_compile_definitions(cross_platform_app PRIVATE
$<$<CONFIG:Debug>:DEBUG_MODE>
$<$<CONFIG:Release>:NDEBUG>
)
# 根据CMake版本使用不同的功能
if(CMAKE_VERSION VERSION_GREATER_EQUAL 3.12)
target_sources(cross_platform_app PRIVATE
src/new_feature.cpp
)
target_compile_definitions(cross_platform_app PRIVATE USE_NEW_FEATURE)
endif()

复制代码

案例2：组件化构建与版本管理

# 根CMakeLists.txt
cmake_minimum_required(VERSION 3.10)
project(MyApp VERSION 1.0.0)
# 设置C++标准
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
# 添加子目录
add_subdirectory(third_party)
add_subdirectory(core)
add_subdirectory(utils)
add_subdirectory(modules)
add_subdirectory(app)
# 构建配置选项
option(BUILD_TESTS "Build tests" OFF)
option(BUILD_EXAMPLES "Build examples" OFF)
option(BUILD_DOCUMENTATION "Build documentation" OFF)
# 根据选项添加额外的组件
if(BUILD_TESTS)
enable_testing()
add_subdirectory(tests)
endif()
if(BUILD_EXAMPLES)
add_subdirectory(examples)
endif()
if(BUILD_DOCUMENTATION)
add_subdirectory(docs)
endif()
# 安装配置
include(GNUInstallDirs)
# 安装CMake配置文件
include(CMakePackageConfigHelpers)
write_basic_package_version_file(
"${CMAKE_CURRENT_BINARY_DIR}/MyAppConfigVersion.cmake"
VERSION ${PROJECT_VERSION}
COMPATIBILITY AnyNewerVersion
)
install(FILES
"${CMAKE_CURRENT_BINARY_DIR}/MyAppConfigVersion.cmake"
DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/MyApp
)

复制代码

# core/CMakeLists.txt
cmake_minimum_required(VERSION 3.10)
# 创建核心库
add_library(core_lib
src/core.cpp
include/core/core.h
include/core/version.h
)
# 设置包含目录
target_include_directories(core_lib
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/src
)
# 设置C++标准
target_compile_features(core_lib PUBLIC cxx_std_17)
# 链接第三方库
target_link_libraries(core_lib
PUBLIC
OpenSSL::SSL
OpenSSL::Crypto
PRIVATE
fmt::fmt
)
# 设置版本属性
set_target_properties(core_lib PROPERTIES
VERSION ${PROJECT_VERSION}
SOVERSION 1
PUBLIC_HEADER "include/core/core.h;include/core/version.h"
)
# 生成版本头文件
configure_file(
"${CMAKE_CURRENT_SOURCE_DIR}/include/core/version.h.in"
"${CMAKE_CURRENT_BINARY_DIR}/include/core/version.h"
@ONLY
)
target_include_directories(core_lib PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
)
# 安装规则
install(TARGETS core_lib
EXPORT CoreTargets
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
)
# 安装导出文件
install(EXPORT CoreTargets
FILE CoreTargets.cmake
NAMESPACE MyApp::
DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/MyApp
)

复制代码

# utils/CMakeLists.txt
cmake_minimum_required(VERSION 3.10)
# 创建工具库
add_library(utils_lib
src/utils.cpp
include/utils/utils.h
)
# 设置包含目录
target_include_directories(utils_lib
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/src
)
# 设置C++标准
target_compile_features(utils_lib PUBLIC cxx_std_17)
# 链接核心库
target_link_libraries(utils_lib
PUBLIC
MyApp::core_lib
PRIVATE
Boost::filesystem
Boost::system
)
# 设置版本属性
set_target_properties(utils_lib PROPERTIES
VERSION ${PROJECT_VERSION}
SOVERSION 1
PUBLIC_HEADER "include/utils/utils.h"
)
# 安装规则
install(TARGETS utils_lib
EXPORT UtilsTargets
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
)
# 安装导出文件
install(EXPORT UtilsTargets
FILE UtilsTargets.cmake
NAMESPACE MyApp::
DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/MyApp
)

复制代码

# modules/CMakeLists.txt
cmake_minimum_required(VERSION 3.10)
# 添加模块子目录
add_subdirectory(networking)
add_subdirectory(database)
add_subdirectory(ui)
# 模块选项
option(ENABLE_NETWORKING_MODULE "Enable networking module" ON)
option(ENABLE_DATABASE_MODULE "Enable database module" ON)
option(ENABLE_UI_MODULE "Enable UI module" OFF)
# 根据选项创建模块别名
if(ENABLE_NETWORKING_MODULE)
add_library(MyApp::networking ALIAS networking_lib)
endif()
if(ENABLE_DATABASE_MODULE)
add_library(MyApp::database ALIAS database_lib)
endif()
if(ENABLE_UI_MODULE)
add_library(MyApp::ui ALIAS ui_lib)
endif()

复制代码

# modules/networking/CMakeLists.txt
cmake_minimum_required(VERSION 3.10)
# 创建网络模块库
add_library(networking_lib
src/http_client.cpp
src/tcp_server.cpp
include/networking/http_client.h
include/networking/tcp_server.h
)
# 设置包含目录
target_include_directories(networking_lib
PUBLIC
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/src
)
# 设置C++标准
target_compile_features(networking_lib PUBLIC cxx_std_17)
# 链接核心库和工具库
target_link_libraries(networking_lib
PUBLIC
MyApp::core_lib
MyApp::utils_lib
PRIVATE
Boost::asio
)
# 设置版本属性
set_target_properties(networking_lib PROPERTIES
VERSION ${PROJECT_VERSION}
SOVERSION 1
PUBLIC_HEADER "include/networking/http_client.h;include/networking/tcp_server.h"
)
# 安装规则
install(TARGETS networking_lib
EXPORT NetworkingTargets
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
)
# 安装导出文件
install(EXPORT NetworkingTargets
FILE NetworkingTargets.cmake
NAMESPACE MyApp::
DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/MyApp
)

复制代码

# app/CMakeLists.txt
cmake_minimum_required(VERSION 3.10)
# 创建可执行文件
add_executable(my_app
src/main.cpp
src/app_config.cpp
)
# 设置包含目录
target_include_directories(my_app PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/include
)
# 设置C++标准
target_compile_features(my_app PRIVATE cxx_std_17)
# 链接核心库和工具库
target_link_libraries(my_app
PRIVATE
MyApp::core_lib
MyApp::utils_lib
)
# 根据选项链接模块
if(ENABLE_NETWORKING_MODULE)
target_link_libraries(my_app PRIVATE MyApp::networking_lib)
target_compile_definitions(my_app PRIVATE ENABLE_NETWORKING)
endif()
if(ENABLE_DATABASE_MODULE)
target_link_libraries(my_app PRIVATE MyApp::database_lib)
target_compile_definitions(my_app PRIVATE ENABLE_DATABASE)
endif()
if(ENABLE_UI_MODULE)
target_link_libraries(my_app PRIVATE MyApp::ui_lib)
target_compile_definitions(my_app PRIVATE ENABLE_UI)
endif()
# 根据平台链接额外的库
if(WIN32)
target_link_libraries(my_app PRIVATE
shell32
shlwapi
)
endif()
# 安装规则
install(TARGETS my_app
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)
# 安装配置文件
install(FILES
"${CMAKE_CURRENT_SOURCE_DIR}/config/my_app.conf"
DESTINATION ${CMAKE_INSTALL_SYSCONFDIR}/my_app
)

复制代码

最佳实践

1. 使用语义化版本控制

语义化版本控制（Semantic Versioning）是一种广泛使用的版本控制规范，它使用MAJOR.MINOR.PATCH的格式来表示版本号，并遵循以下规则：

• MAJOR版本号：当进行不兼容的API更改时递增
• MINOR版本号：当以向后兼容的方式添加功能时递增
• PATCH版本号：当进行向后兼容的错误修复时递增

在CMake中，我们可以使用project()命令来设置项目版本：

project(MyProject VERSION 1.2.3)

复制代码

这将设置以下变量：

• PROJECT_VERSION：完整版本字符串（如”1.2.3”）
• PROJECT_VERSION_MAJOR：主版本号（如”1”）
• PROJECT_VERSION_MINOR：次版本号（如”2”）
• PROJECT_VERSION_PATCH：修订号（如”3”）

2. 使用CMake的版本兼容性命令

CMake提供了一些命令来处理版本兼容性，如cmake_minimum_required()和cmake_policy()。

# 指定所需的CMake最低版本
cmake_minimum_required(VERSION 3.10)
# 设置策略
cmake_policy(SET CMP0077 NEW) # option()命令优先使用缓存值
cmake_policy(SET CMP0048 NEW) # project()命令管理版本

复制代码

3. 使用目标属性和生成器表达式

CMake的目标属性和生成器表达式可以帮助我们实现更精细的版本控制。

add_library(my_lib STATIC src/my_lib.cpp)
# 设置目标属性
set_target_properties(my_lib PROPERTIES
VERSION ${PROJECT_VERSION}
SOVERSION 1
)
# 使用生成器表达式
target_compile_definitions(my_lib PRIVATE
$<$<VERSION_GREATER:${PROJECT_VERSION},1.0.0>:NEW_FEATURE>
)

复制代码

4. 使用配置文件和模块

将复杂的版本控制逻辑封装在配置文件或模块中，可以提高代码的重用性和可维护性。

# 在cmake/目录下创建VersionControl.cmake文件
# 包含版本控制相关的函数和宏
# 在主CMakeLists.txt中包含配置文件
include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/VersionControl.cmake)

复制代码

5. 使用外部依赖管理工具

对于复杂的项目，可以考虑使用外部依赖管理工具，如Conan、vcpkg或Hunter，来管理依赖库的版本。

# 使用Conan
if(NOT EXISTS "${CMAKE_BINARY_DIR}/conan.cmake")
message(STATUS "Downloading conan.cmake from https://github.com/conan-io/cmake-conan")
file(DOWNLOAD "https://raw.githubusercontent.com/conan-io/cmake-conan/master/conan.cmake"
"${CMAKE_BINARY_DIR}/conan.cmake")
endif()
include(${CMAKE_BINARY_DIR}/conan.cmake)
conan_cmake_run(REQUIRES
openssl/1.1.1l
boost/1.77.0
BASIC_SETUP
BUILD missing)

复制代码

6. 使用条件编译和特性开关

使用条件编译和特性开关可以根据不同的需求生成不同版本的产品。

# 定义特性开关
option(ENABLE_FEATURE_A "Enable Feature A" ON)
option(ENABLE_FEATURE_B "Enable Feature B" OFF)
# 根据特性开关添加不同的源文件
if(ENABLE_FEATURE_A)
list(APPEND SOURCES src/feature_a.cpp)
add_definitions(-DENABLE_FEATURE_A)
endif()
if(ENABLE_FEATURE_B)
list(APPEND SOURCES src/feature_b.cpp)
add_definitions(-DENABLE_FEATURE_B)
endif()
# 添加可执行文件
add_executable(my_app ${SOURCES})

复制代码

7. 使用版本控制文件

将版本信息存储在单独的文件中，可以方便地管理和更新版本。

# 从VERSION文件读取版本信息
file(STRINGS "VERSION" VERSION_INFO REGEX "^[^#]")
# 解析版本信息
foreach(LINE ${VERSION_INFO})
if(LINE MATCHES "VERSION_MAJOR=([0-9]+)")
set(VERSION_MAJOR ${CMAKE_MATCH_1})
elseif(LINE MATCHES "VERSION_MINOR=([0-9]+)")
set(VERSION_MINOR ${CMAKE_MATCH_1})
elseif(LINE MATCHES "VERSION_PATCH=([0-9]+)")
set(VERSION_PATCH ${CMAKE_MATCH_1})
endif()
endforeach()
# 构建版本字符串
set(PROJECT_VERSION "${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}")

复制代码

8. 使用CMake的包管理功能

CMake提供了一些包管理功能，如FetchContent和ExternalProject，可以帮助我们更好地管理依赖库的版本。

# 使用FetchContent
include(FetchContent)
FetchContent_Declare(
googletest
GIT_REPOSITORY https://github.com/google/googletest.git
GIT_TAG release-1.11.0
)
FetchContent_MakeAvailable(googletest)

复制代码

9. 使用CMake的导出和安装功能

CMake的导出和安装功能可以帮助我们创建可重用的包，并在不同的项目之间共享。

# 安装目标
install(TARGETS my_lib
EXPORT MyLibTargets
LIBRARY DESTINATION lib
ARCHIVE DESTINATION lib
RUNTIME DESTINATION bin
PUBLIC_HEADER DESTINATION include
)
# 安装导出文件
install(EXPORT MyLibTargets
FILE MyLibTargets.cmake
NAMESPACE MyLib::
DESTINATION lib/cmake/MyLib
)
# 生成配置文件
include(CMakePackageConfigHelpers)
write_basic_package_version_file(
"MyLibConfigVersion.cmake"
VERSION ${PROJECT_VERSION}
COMPATIBILITY AnyNewerVersion
)
# 安装配置文件
install(FILES
"MyLibConfig.cmake"
"${CMAKE_CURRENT_BINARY_DIR}/MyLibConfigVersion.cmake"
DESTINATION lib/cmake/MyLib
)

复制代码

10. 使用CMake的测试功能

CMake的测试功能可以帮助我们验证不同版本的功能是否正常工作。

# 启用测试
enable_testing()
# 添加测试
add_test(NAME my_test COMMAND my_app)
# 根据版本添加不同的测试
if(PROJECT_VERSION VERSION_GREATER_EQUAL 1.2.0)
add_test(NAME new_feature_test COMMAND my_app --test-new-feature)
endif()

复制代码

常见问题与解决方案

1. 问题：如何处理不同CMake版本之间的兼容性问题？

解决方案：使用cmake_minimum_required()命令指定所需的CMake最低版本，并使用cmake_policy()命令设置策略。

# 指定所需的CMake最低版本
cmake_minimum_required(VERSION 3.10)
# 设置策略
if(POLICY CMP0077)
cmake_policy(SET CMP0077 NEW) # option()命令优先使用缓存值
endif()
if(POLICY CMP0048)
cmake_policy(SET CMP0048 NEW) # project()命令管理版本
endif()

复制代码

2. 问题：如何管理不同平台上的依赖库版本？

解决方案：使用find_package()命令查找依赖库，并指定版本要求。对于不同平台，可以使用条件语句来设置不同的查找路径和链接选项。

# 设置依赖版本要求
set(OPENSSL_MIN_VERSION "1.1.1")
# 查找OpenSSL
find_package(OpenSSL ${OPENSSL_MIN_VERSION} REQUIRED)
if(OpenSSL_FOUND)
message(STATUS "Found OpenSSL version: ${OPENSSL_VERSION}")
else()
message(FATAL_ERROR "OpenSSL not found or version is less than ${OPENSSL_MIN_VERSION}")
endif()
# 根据平台设置不同的链接选项
if(WIN32)
target_link_libraries(my_app
OpenSSL::SSL
OpenSSL::Crypto
ws2_32 # Windows socket库
)
else()
target_link_libraries(my_app
OpenSSL::SSL
OpenSSL::Crypto
pthread # POSIX线程库
)
endif()

复制代码

3. 问题：如何在构建时动态选择依赖库的版本？

解决方案：使用CMake的选项来允许用户在配置时选择依赖库的版本。

# 定义选项
set(BOOST_VERSION "1.70.0" CACHE STRING "Boost version to use")
set_property(CACHE BOOST_VERSION PROPERTY STRINGS "1.70.0" "1.75.0" "1.77.0")
# 根据选择的版本查找Boost
find_package(Boost ${BOOST_VERSION} REQUIRED COMPONENTS filesystem system)
if(Boost_FOUND)
message(STATUS "Found Boost version: ${Boost_VERSION}")
else()
message(FATAL_ERROR "Boost ${BOOST_VERSION} not found")
endif()

复制代码

4. 问题：如何处理依赖库之间的版本冲突？

解决方案：使用CMake的find_package()命令的EXACT选项来确保使用特定版本的依赖库，或者使用FetchContent或ExternalProject来下载和管理依赖库的版本。

# 使用EXACT选项确保使用特定版本的依赖库
find_package(OpenSSL 1.1.1 EXACT REQUIRED)
# 使用FetchContent下载和管理依赖库的版本
include(FetchContent)
FetchContent_Declare(
googletest
GIT_REPOSITORY https://github.com/google/googletest.git
GIT_TAG release-1.11.0
)
FetchContent_MakeAvailable(googletest)

复制代码

5. 问题：如何在不同的构建配置（Debug、Release等）中使用不同的依赖库版本？

解决方案：使用生成器表达式来根据构建配置选择不同的依赖库。

# 添加库
add_library(my_lib STATIC src/my_lib.cpp)
# 根据构建配置链接不同的库
target_link_libraries(my_lib
PRIVATE
$<$<CONFIG:Debug>:debug_library>
$<$<CONFIG:Release>:release_library>
)
# 根据构建配置设置不同的定义
target_compile_definitions(my_lib
PRIVATE
$<$<CONFIG:Debug>:DEBUG_MODE>
$<$<CONFIG:Release>:NDEBUG>
)

复制代码

6. 问题：如何在不同的编译器版本中使用不同的代码路径？

解决方案：使用CMake的编译器信息和生成器表达式来根据编译器版本选择不同的代码路径。

# 添加可执行文件
add_executable(my_app src/main.cpp)
# 根据编译器版本设置不同的定义
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 9.0)
target_compile_definitions(my_app PRIVATE USE_LEGACY_GCC)
else()
target_compile_definitions(my_app PRIVATE USE_MODERN_GCC)
endif()
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 10.0)
target_compile_definitions(my_app PRIVATE USE_LEGACY_CLANG)
else()
target_compile_definitions(my_app PRIVATE USE_MODERN_CLANG)
endif()
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.20)
target_compile_definitions(my_app PRIVATE USE_LEGACY_MSVC)
else()
target_compile_definitions(my_app PRIVATE USE_MODERN_MSVC)
endif()
endif()

复制代码

7. 问题：如何在CMake中实现语义化版本控制？

解决方案：使用project()命令设置项目版本，并创建自定义函数来解析和比较版本字符串。

# 设置项目版本
project(MyProject VERSION 1.2.3)
# 创建函数来解析版本字符串
function(parse_version VERSION_STRING OUTPUT_PREFIX)
# 使用正则表达式匹配版本字符串
string(REGEX MATCH "^([0-9]+)\\.([0-9]+)\\.([0-9]+)(-([a-zA-Z0-9]+))?$" VERSION_MATCH ${VERSION_STRING})
if(VERSION_MATCH)
set(${OUTPUT_PREFIX}_MAJOR ${CMAKE_MATCH_1} PARENT_SCOPE)
set(${OUTPUT_PREFIX}_MINOR ${CMAKE_MATCH_2} PARENT_SCOPE)
set(${OUTPUT_PREFIX}_PATCH ${CMAKE_MATCH_3} PARENT_SCOPE)
set(${OUTPUT_PREFIX}_EXTRA ${CMAKE_MATCH_5} PARENT_SCOPE)
else()
message(FATAL_ERROR "Invalid version string: ${VERSION_STRING}")
endif()
endfunction()
# 创建函数来比较版本
function(compare_versions VERSION1 OP VERSION2 RESULT_VAR)
# 解析版本字符串
parse_version(${VERSION1} V1)
parse_version(${VERSION2} V2)
# 比较版本
if(V1_MAJOR GREATER V2_MAJOR)
set(RESULT TRUE)
elseif(V1_MAJOR LESS V2_MAJOR)
set(RESULT FALSE)
else()
if(V1_MINOR GREATER V2_MINOR)
set(RESULT TRUE)
elseif(V1_MINOR LESS V2_MINOR)
set(RESULT FALSE)
else()
if(V1_PATCH GREATER V2_PATCH)
set(RESULT TRUE)
elseif(V1_PATCH LESS V2_PATCH)
set(RESULT FALSE)
else()
set(RESULT FALSE)
endif()
endif()
endif()
# 根据操作符调整结果
if(OP STREQUAL "EQUAL")
string(COMPARE EQUAL ${VERSION1} ${VERSION2} RESULT)
elseif(OP STREQUAL "LESS")
string(COMPARE LESS ${VERSION1} ${VERSION2} RESULT)
elseif(OP STREQUAL "GREATER")
string(COMPARE GREATER ${VERSION1} ${VERSION2} RESULT)
elseif(OP STREQUAL "LESS_EQUAL")
string(COMPARE LESS ${VERSION1} ${VERSION2} TEMP)
string(COMPARE EQUAL ${VERSION1} ${VERSION2} TEMP2)
set(RESULT ${TEMP} OR ${TEMP2})
elseif(OP STREQUAL "GREATER_EQUAL")
string(COMPARE GREATER ${VERSION1} ${VERSION2} TEMP)
string(COMPARE EQUAL ${VERSION1} ${VERSION2} TEMP2)
set(RESULT ${TEMP} OR ${TEMP2})
else()
message(FATAL_ERROR "Invalid comparison operator: ${OP}")
endif()
# 设置输出变量
set(${RESULT_VAR} ${RESULT} PARENT_SCOPE)
endfunction()
# 使用函数比较版本
compare_versions(${PROJECT_VERSION} "GREATER_EQUAL" "1.2.0" RESULT)
if(RESULT)
message(STATUS "Project version ${PROJECT_VERSION} is compatible with required version 1.2.0")
else()
message(FATAL_ERROR "Project version ${PROJECT_VERSION} is not compatible with required version 1.2.0")
endif()

复制代码

8. 问题：如何在CMake中实现条件编译？

解决方案：使用CMake的if()语句和add_definitions()命令来实现条件编译。

# 定义选项
option(ENABLE_FEATURE_A "Enable Feature A" ON)
option(ENABLE_FEATURE_B "Enable Feature B" OFF)
# 根据选项添加定义
if(ENABLE_FEATURE_A)
add_definitions(-DENABLE_FEATURE_A)
endif()
if(ENABLE_FEATURE_B)
add_definitions(-DENABLE_FEATURE_B)
endif()
# 根据平台添加定义
if(WIN32)
add_definitions(-DWINDOWS_PLATFORM)
elseif(UNIX AND NOT APPLE)
add_definitions(-DLINUX_PLATFORM)
elseif(APPLE)
add_definitions(-DMACOS_PLATFORM)
endif()
# 根据编译器添加定义
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
add_definitions(-DGNUC)
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
add_definitions(-DCLANG)
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
add_definitions(-DMSVC)
endif()

复制代码

9. 问题：如何在CMake中管理大型项目的多版本构建？

解决方案：使用CMake的子目录和组件化构建来管理大型项目的多版本构建。

# 根CMakeLists.txt
cmake_minimum_required(VERSION 3.10)
project(LargeProject VERSION 1.0.0)
# 添加子目录
add_subdirectory(core)
add_subdirectory(utils)
add_subdirectory(app)
# 根据构建类型包含不同的组件
if(BUILD_TESTING)
enable_testing()
add_subdirectory(tests)
endif()
if(BUILD_EXAMPLES)
add_subdirectory(examples)
endif()
if(BUILD_DOCUMENTATION)
add_subdirectory(docs)
endif()

复制代码

10. 问题：如何在CMake中实现自动版本更新？

解决方案：使用CMake脚本和版本控制系统的钩子来实现自动版本更新。

# version_script.cmake
# 这是一个CMake脚本，用于自动更新版本信息
# 读取当前版本
file(STRINGS "VERSION" VERSION_LINES REGEX "^[^#]")
# 解析版本信息
foreach(LINE ${VERSION_LINES})
if(LINE MATCHES "VERSION_MAJOR=([0-9]+)")
set(VERSION_MAJOR ${CMAKE_MATCH_1})
elseif(LINE MATCHES "VERSION_MINOR=([0-9]+)")
set(VERSION_MINOR ${CMAKE_MATCH_1})
elseif(LINE MATCHES "VERSION_PATCH=([0-9]+)")
set(VERSION_PATCH ${CMAKE_MATCH_1})
endif()
endforeach()
# 根据参数更新版本
if(ARGV0 STREQUAL "major")
math(EXPR VERSION_MAJOR "${VERSION_MAJOR} + 1")
set(VERSION_MINOR 0)
set(VERSION_PATCH 0)
elseif(ARGV0 STREQUAL "minor")
math(EXPR VERSION_MINOR "${VERSION_MINOR} + 1")
set(VERSION_PATCH 0)
elseif(ARGV0 STREQUAL "patch")
math(EXPR VERSION_PATCH "${VERSION_PATCH} + 1")
else()
message(FATAL_ERROR "Invalid argument: ${ARGV0}. Use 'major', 'minor' or 'patch'.")
endif()
# 构建新版本字符串
set(NEW_VERSION "${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}")
# 写入新版本文件
file(WRITE "VERSION" "VERSION_MAJOR=${VERSION_MAJOR}\n")
file(APPEND "VERSION" "VERSION_MINOR=${VERSION_MINOR}\n")
file(APPEND "VERSION" "VERSION_PATCH=${VERSION_PATCH}\n")
# 输出新版本
message(STATUS "Updated version to: ${NEW_VERSION}")

复制代码

要运行这个脚本，可以使用以下命令：

cmake -P version_script.cmake patch

复制代码

结论

CMake多版本控制技术是现代软件开发中不可或缺的一部分，它可以帮助我们更好地管理项目的构建和依赖关系，提高项目的灵活性和可维护性。通过掌握CMake多版本控制技术，我们可以：

1. 更好地管理项目自身的版本和依赖库的版本
2. 根据不同的需求生成不同版本的产品
3. 提高项目的可维护性和可扩展性
4. 减少版本冲突和兼容性问题
5. 提高开发效率和产品质量

在实际应用中，我们需要根据项目的具体需求和规模，选择合适的版本控制策略和技术。同时，我们也需要遵循最佳实践，避免常见的陷阱和问题。

随着CMake的不断发展和完善，我们可以期待更多强大的版本控制功能和工具的出现，为我们的项目构建和管理提供更好的支持。通过不断学习和实践，我们可以更好地掌握CMake多版本控制技术，为我们的项目带来更大的价值。

	通知：关于部分勋章领取条件及购买价格调整的通知	05-18 21:22
	通知：本站资源由网友上传分享，如有违规等问题请到版务模块进行投诉，资源失效请在帖子内回复要求补档，会尽快处理！	10-23 09:31

活动公告

掌握CMake多版本控制技术提升项目构建与管理的灵活性

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

浏览过的版块

塔罗

立华奏

站长推荐 /1

友情链接

Tencent QQ

活动公告

掌握CMake多版本控制技术 提升项目构建与管理的灵活性

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

浏览过的版块

塔罗

立华奏

站长推荐 /1

友情链接

Tencent QQ

掌握CMake多版本控制技术提升项目构建与管理的灵活性