简体中文 繁體中文 English Deutsch 한국 사람 بالعربية TÜRKÇE português คนไทย Français Japanese

开启辅助访问 切换到宽版

站内搜索

搜索

活动公告

通知：为庆祝网站一周年，将在5.1日与5.2日开放注册，具体信息请见后续详细公告
04-22 00:04
通知：本站资源由网友上传分享，如有违规等问题请到版务模块进行投诉，资源失效请在帖子内回复要求补档，会尽快处理！
10-23 09:31
>社区 > 科技 > 经验交流 >帖子
本版发帖返回

CMake构建输出管理全攻略打造整洁高效的项目结构

威震华夏关云长
SunJu_FaceMall

3万

主题

1158

科技点

3万

积分

白金月票

碾压王

积分
32796

立华奏
发表于 2025-10-2 14:40:00 | 显示全部楼层 |阅读模式

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

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

x
1. 引言：CMake构建输出管理的重要性

在软件开发过程中，构建系统扮演着至关重要的角色，它负责将源代码转换为可执行程序、库文件以及其他构建产物。CMake作为跨平台的构建系统生成器，已经被广泛应用于C++项目中。然而，许多开发者在使用CMake时，往往忽视了对构建输出（如可执行文件、库文件、目标文件等）的管理，导致项目目录结构混乱，难以维护和部署。

良好的构建输出管理可以带来诸多好处：

• 提高项目可维护性：清晰的输出结构让开发者能够快速定位所需文件
• 简化部署流程：有序的输出组织便于打包和分发
• 提升构建效率：合理的输出路径配置可以避免不必要的文件操作
• 增强团队协作：统一的输出结构规范有助于团队成员之间的协作

本文将深入探讨CMake构建输出管理的各个方面，从基础概念到高级技巧，帮助您打造整洁高效的项目结构。

2. CMake基础概念与构建流程

2.1 CMake的工作原理

CMake是一个跨平台的构建系统生成器，它读取名为CMakeLists.txt的配置文件，生成特定平台下的构建文件（如Unix下的Makefile、Windows下的Visual Studio项目文件等）。CMake的工作流程可以概括为：

1. 配置阶段：CMake解析CMakeLists.txt文件，生成构建系统
2. 构建阶段：使用生成的构建系统（如make、ninja或Visual Studio）编译链接源代码
3. 安装阶段：将构建产物复制到指定位置，形成最终的产品
  2. # 最简单的CMakeLists.txt示例
  3. cmake_minimum_required(VERSION 3.10)
  4. project(MyProject)
  6. add_executable(my_app main.cpp)
复制代码

2.2 构建目录与源码目录分离

CMake推荐使用源外构建（Out-of-source build）的方式，即构建目录与源码目录分离。这种做法有以下优势：

• 保持源码目录整洁，不会被构建产物污染
• 支持多种构建配置（如Debug、Release）并存
• 便于清理构建产物，只需删除构建目录即可

实践源外构建的步骤：
  2. # 创建项目目录结构
  3. mkdir my_project
  4. cd my_project
  5. mkdir src build
  7. # 在src目录中创建CMakeLists.txt和源代码
  8. cd src
  9. # ... 创建CMakeLists.txt和源代码文件 ...
  11. # 在build目录中进行构建
  12. cd ../build
  13. cmake ../src
  14. make
复制代码

2.3 CMake中的构建目标类型

CMake支持多种构建目标类型，每种类型的输出文件有所不同：

1. 可执行文件（Executable）：通过add_executable()命令定义，生成平台相关的可执行文件
2. 静态库（Static Library）：通过add_library()命令定义，生成.a（Unix）或.lib（Windows）文件
3. 动态库（Shared Library）：通过add_library()命令定义，生成.so（Unix）、.dylib（macOS）或.dll（Windows）文件
4. 模块库（Module Library）：通过add_library()命令定义，生成运行时可加载的模块
5. 自定义目标（Custom Target）：通过add_custom_target()命令定义，用于执行自定义命令
  2. cmake_minimum_required(VERSION 3.10)
  3. project(MyProject)
  5. # 添加可执行文件
  6. add_executable(my_app main.cpp)
  8. # 添加静态库
  9. add_library(my_static_lib STATIC utils.cpp)
  11. # 添加动态库
  12. add_library(my_shared_lib SHARED utils.cpp)
  14. # 添加自定义目标
  15. add_custom_target(run_app
  16.     COMMAND my_app
  17.     DEPENDS my_app
  18. )
复制代码

3. CMake变量与构建输出控制

3.1 关键CMake变量介绍

CMake提供了许多内置变量来控制构建过程和输出位置，了解这些变量对于构建输出管理至关重要：

1. CMAKE_SOURCE_DIR：指向顶层CMakeLists.txt所在的目录
2. CMAKE_BINARY_DIR：指向构建目录的根目录
3. CMAKE_CURRENT_SOURCE_DIR：指向当前处理的CMakeLists.txt所在的目录
4. CMAKE_CURRENT_BINARY_DIR：指向当前处理的CMakeLists.txt对应的构建输出目录
5. PROJECT_SOURCE_DIR：指向项目根目录（即第一个project()命令所在的目录）
6. PROJECT_BINARY_DIR：指向项目根目录对应的构建输出目录
  2. cmake_minimum_required(VERSION 3.10)
  3. project(MyProject)
  5. message(STATUS "CMAKE_SOURCE_DIR: ${CMAKE_SOURCE_DIR}")
  6. message(STATUS "CMAKE_BINARY_DIR: ${CMAKE_BINARY_DIR}")
  7. message(STATUS "CMAKE_CURRENT_SOURCE_DIR: ${CMAKE_CURRENT_SOURCE_DIR}")
  8. message(STATUS "CMAKE_CURRENT_BINARY_DIR: ${CMAKE_CURRENT_BINARY_DIR}")
  9. message(STATUS "PROJECT_SOURCE_DIR: ${PROJECT_SOURCE_DIR}")
  10. message(STATUS "PROJECT_BINARY_DIR: ${PROJECT_BINARY_DIR}")
复制代码

3.2 输出路径控制变量

CMake提供了一组专门用于控制构建输出路径的变量：

1. CMAKE_ARCHIVE_OUTPUT_DIRECTORY：静态库文件的输出目录
2. CMAKE_LIBRARY_OUTPUT_DIRECTORY：动态库文件的输出目录
3. CMAKE_RUNTIME_OUTPUT_DIRECTORY：可执行文件的输出目录

这些变量可以全局设置，也可以针对特定配置（如Debug、Release）进行设置：
  2. cmake_minimum_required(VERSION 3.10)
  3. project(MyProject)
  5. # 设置全局输出目录
  6. set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
  7. set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
  8. set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
  10. # 为不同配置设置不同的输出目录
  11. set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR}/lib/debug)
  12. set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR}/lib/debug)
  13. set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR}/bin/debug)
  15. set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}/lib/release)
  16. set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}/lib/release)
  17. set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}/bin/release)
  19. add_executable(my_app main.cpp)
  20. add_library(my_lib STATIC utils.cpp)
复制代码

3.3 自定义变量的使用

除了内置变量，我们还可以定义自定义变量来组织构建输出：
  2. cmake_minimum_required(VERSION 3.10)
  3. project(MyProject)
  5. # 定义自定义输出目录变量
  6. set(OUTPUT_ROOT ${CMAKE_BINARY_DIR}/output)
  7. set(OUTPUT_BIN ${OUTPUT_ROOT}/bin)
  8. set(OUTPUT_LIB ${OUTPUT_ROOT}/lib)
  9. set(OUTPUT_INCLUDE ${OUTPUT_ROOT}/include)
  11. # 创建输出目录
  12. file(MAKE_DIRECTORY ${OUTPUT_BIN})
  13. file(MAKE_DIRECTORY ${OUTPUT_LIB})
  14. file(MAKE_DIRECTORY ${OUTPUT_INCLUDE})
  16. # 设置输出目录
  17. set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${OUTPUT_BIN})
  18. set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${OUTPUT_LIB})
  19. set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${OUTPUT_LIB})
  21. # 复制头文件到输出目录
  22. file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/include/ DESTINATION ${OUTPUT_INCLUDE})
  24. add_executable(my_app main.cpp)
  25. add_library(my_lib STATIC utils.cpp)
复制代码

4. 构建输出组织策略

4.1 按类型分类输出

按文件类型组织构建输出是最常见的策略之一，它将不同类型的构建产物（如可执行文件、库文件）放置在不同的目录中：
  2. cmake_minimum_required(VERSION 3.10)
  3. project(MyProject)
  5. # 设置按类型分类的输出目录
  6. set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
  7. set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
  8. set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib/static)
  10. # 添加目标
  11. add_executable(my_app main.cpp)
  12. add_library(my_shared_lib SHARED utils.cpp)
  13. add_library(my_static_lib STATIC utils.cpp)
  15. # 输出目录结构将是：
  16. # build/
  17. #   bin/
  18. #     my_app (或 my_app.exe)
  19. #   lib/
  20. #     my_shared_lib.so (或 .dll/.dylib)
  21. #   lib/static/
  22. #     my_static_lib.a (或 .lib)
复制代码

4.2 按配置分类输出

对于需要同时支持多种构建配置（如Debug、Release）的项目，按配置分类输出是一种有效的策略：
  2. cmake_minimum_required(VERSION 3.10)
  3. project(MyProject)
  5. # 为不同配置设置输出目录
  6. foreach(config IN ITEMS DEBUG RELEASE RELWITHDEBINFO MINSIZEREL)
  7.     string(TOLOWER ${config} lower_config)
  8.     set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${config} ${CMAKE_BINARY_DIR}/bin/${lower_config})
  9.     set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_${config} ${CMAKE_BINARY_DIR}/lib/${lower_config})
  10.     set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${config} ${CMAKE_BINARY_DIR}/lib/static/${lower_config})
  11. endforeach()
  13. # 添加目标
  14. add_executable(my_app main.cpp)
  15. add_library(my_lib SHARED utils.cpp)
  17. # 输出目录结构将是：
  18. # build/
  19. #   bin/
  20. #     debug/
  21. #       my_app
  22. #     release/
  23. #       my_app
  24. #   lib/
  25. #     debug/
  26. #       my_lib.so
  27. #     release/
  28. #       my_lib.so
  29. #   lib/static/
  30. #     debug/
  31. #       my_lib.a
  32. #     release/
  33. #       my_lib.a
复制代码

4.3 多项目构建输出管理

对于包含多个子项目的大型项目，需要更加细致的输出管理策略：
  2. cmake_minimum_required(VERSION 3.10)
  3. project(SuperProject)
  5. # 设置全局输出目录
  6. set(OUTPUT_ROOT ${CMAKE_BINARY_DIR}/output)
  7. set(OUTPUT_BIN ${OUTPUT_ROOT}/bin)
  8. set(OUTPUT_LIB ${OUTPUT_ROOT}/lib)
  9. set(OUTPUT_INCLUDE ${OUTPUT_ROOT}/include)
  11. # 创建输出目录
  12. file(MAKE_DIRECTORY ${OUTPUT_BIN})
  13. file(MAKE_DIRECTORY ${OUTPUT_LIB})
  14. file(MAKE_DIRECTORY ${OUTPUT_INCLUDE})
  16. # 设置全局输出变量
  17. set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${OUTPUT_BIN})
  18. set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${OUTPUT_LIB})
  19. set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${OUTPUT_LIB})
  21. # 添加子项目
  22. add_subdirectory(app)
  23. add_subdirectory(libs)
  24. add_subdirectory(plugins)
复制代码

子项目app/CMakeLists.txt:
  2. # 应用程序子项目
  3. project(App)
  5. add_executable(my_app main.cpp)
  6. target_link_libraries(my_app PRIVATE core_lib)
  8. # 设置应用程序特定的输出目录
  9. set_target_properties(my_app PROPERTIES
  10.     RUNTIME_OUTPUT_DIRECTORY "${OUTPUT_BIN}/apps"
  11. )
复制代码

子项目libs/CMakeLists.txt:
  2. # 库子项目
  3. project(Libs)
  5. add_library(core_lib STATIC core.cpp)
  6. add_library(utils_lib SHARED utils.cpp)
  8. # 设置库特定的输出目录
  9. set_target_properties(core_lib PROPERTIES
  10.     ARCHIVE_OUTPUT_DIRECTORY "${OUTPUT_LIB}/core"
  11. )
  13. set_target_properties(utils_lib PROPERTIES
  14.     LIBRARY_OUTPUT_DIRECTORY "${OUTPUT_LIB}/utils"
  15. )
  17. # 复制头文件到输出目录
  18. file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/core/ DESTINATION ${OUTPUT_INCLUDE}/core)
  19. file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/utils/ DESTINATION ${OUTPUT_INCLUDE}/utils)
复制代码

子项目plugins/CMakeLists.txt:
  2. # 插件子项目
  3. project(Plugins)
  5. add_library(plugin1 MODULE plugin1.cpp)
  6. add_library(plugin2 MODULE plugin2.cpp)
  8. # 设置插件特定的输出目录
  9. set_target_properties(plugin1 PROPERTIES
  10.     LIBRARY_OUTPUT_DIRECTORY "${OUTPUT_BIN}/plugins"
  11. )
  13. set_target_properties(plugin2 PROPERTIES
  14.     LIBRARY_OUTPUT_DIRECTORY "${OUTPUT_BIN}/plugins"
  15. )
复制代码

输出目录结构将是：
  2. build/
  3.   output/
  4.     bin/
  5.       apps/
  6.         my_app
  7.       plugins/
  8.         plugin1.so
  9.         plugin2.so
  10.     lib/
  11.       core/
  12.         core_lib.a
  13.       utils/
  14.         utils_lib.so
  15.     include/
  16.       core/
  17.         core.h
  18.       utils/
  19.         utils.h
复制代码

4.4 跨平台输出一致性处理

在跨平台开发中，不同平台可能有不同的文件命名约定和目录结构。为了保持一致性，我们可以进行以下处理：
  2. cmake_minimum_required(VERSION 3.10)
  3. project(CrossPlatformProject)
  5. # 定义平台相关的变量
  6. if(WIN32)
  7.     set(EXE_EXT ".exe")
  8.     set(SHARED_LIB_EXT ".dll")
  9.     set(STATIC_LIB_EXT ".lib")
  10.     set(PLUGIN_EXT ".dll")
  11. elseif(APPLE)
  12.     set(EXE_EXT "")
  13.     set(SHARED_LIB_EXT ".dylib")
  14.     set(STATIC_LIB_EXT ".a")
  15.     set(PLUGIN_EXT ".so")
  16. else()
  17.     set(EXE_EXT "")
  18.     set(SHARED_LIB_EXT ".so")
  19.     set(STATIC_LIB_EXT ".a")
  20.     set(PLUGIN_EXT ".so")
  21. endif()
  23. # 设置输出目录
  24. set(OUTPUT_ROOT ${CMAKE_BINARY_DIR}/output)
  25. set(OUTPUT_BIN ${OUTPUT_ROOT}/bin)
  26. set(OUTPUT_LIB ${OUTPUT_ROOT}/lib)
  27. set(OUTPUT_PLUGIN ${OUTPUT_ROOT}/plugins)
  29. # 创建输出目录
  30. file(MAKE_DIRECTORY ${OUTPUT_BIN})
  31. file(MAKE_DIRECTORY ${OUTPUT_LIB})
  32. file(MAKE_DIRECTORY ${OUTPUT_PLUGIN})
  34. # 添加目标
  35. add_executable(my_app main.cpp)
  36. add_library(my_shared_lib SHARED utils.cpp)
  37. add_library(my_static_lib STATIC utils.cpp)
  38. add_library(my_plugin MODULE plugin.cpp)
  40. # 设置输出属性
  41. set_target_properties(my_app PROPERTIES
  42.     RUNTIME_OUTPUT_DIRECTORY ${OUTPUT_BIN}
  43.     RUNTIME_OUTPUT_NAME "my_app${EXE_EXT}"
  44. )
  46. set_target_properties(my_shared_lib PROPERTIES
  47.     LIBRARY_OUTPUT_DIRECTORY ${OUTPUT_LIB}
  48.     LIBRARY_OUTPUT_NAME "my_shared_lib${SHARED_LIB_EXT}"
  49. )
  51. set_target_properties(my_static_lib PROPERTIES
  52.     ARCHIVE_OUTPUT_DIRECTORY ${OUTPUT_LIB}
  53.     ARCHIVE_OUTPUT_NAME "my_static_lib${STATIC_LIB_EXT}"
  54. )
  56. set_target_properties(my_plugin PROPERTIES
  57.     LIBRARY_OUTPUT_DIRECTORY ${OUTPUT_PLUGIN}
  58.     LIBRARY_OUTPUT_NAME "my_plugin${PLUGIN_EXT}"
  59. )
复制代码

5. 高级构建输出管理技巧

5.1 自定义命令与输出

有时我们需要在构建过程中执行自定义命令，并管理这些命令的输出文件：
  2. cmake_minimum_required(VERSION 3.10)
  3. project(CustomCommandProject)
  5. # 设置输出目录
  6. set(OUTPUT_DIR ${CMAKE_BINARY_DIR}/output)
  7. set(RESOURCE_DIR ${OUTPUT_DIR}/resources)
  9. # 创建资源目录
  10. file(MAKE_DIRECTORY ${RESOURCE_DIR})
  12. # 添加自定义命令生成资源文件
  13. add_custom_command(
  14.     OUTPUT ${RESOURCE_DIR}/version.h
  15.     COMMAND ${CMAKE_COMMAND} -E echo
  16.         "#pragma once" > ${RESOURCE_DIR}/version.h
  17.     COMMAND ${CMAKE_COMMAND} -E echo
  18.         "#define VERSION_MAJOR 1" >> ${RESOURCE_DIR}/version.h
  19.     COMMAND ${CMAKE_COMMAND} -E echo
  20.         "#define VERSION_MINOR 0" >> ${RESOURCE_DIR}/version.h
  21.     COMMAND ${CMAKE_COMMAND} -E echo
  22.         "#define VERSION_PATCH 0" >> ${RESOURCE_DIR}/version.h
  23.     DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
  24.     COMMENT "Generating version.h"
  25. )
  27. # 添加自定义目标
  28. add_custom_target(generate_version
  29.     DEPENDS ${RESOURCE_DIR}/version.h
  30. )
  32. # 添加可执行文件
  33. add_executable(my_app main.cpp)
  34. target_include_directories(my_app PRIVATE ${RESOURCE_DIR})
  36. # 确保在构建my_app之前先生成version.h
  37. add_dependencies(my_app generate_version)
  39. # 设置输出目录
  40. set_target_properties(my_app PROPERTIES
  41.     RUNTIME_OUTPUT_DIRECTORY ${OUTPUT_DIR}/bin
  42. )
复制代码

5.2 构建后处理与文件组织

构建后处理可以帮助我们进一步组织输出文件，例如复制依赖文件、创建符号链接等：
  2. cmake_minimum_required(VERSION 3.10)
  3. project(PostBuildProject)
  5. # 设置输出目录
  6. set(OUTPUT_DIR ${CMAKE_BINARY_DIR}/output)
  7. set(OUTPUT_BIN ${OUTPUT_DIR}/bin)
  8. set(OUTPUT_LIB ${OUTPUT_DIR}/lib)
  9. set(OUTPUT_DATA ${OUTPUT_DIR}/data)
  11. # 创建输出目录
  12. file(MAKE_DIRECTORY ${OUTPUT_BIN})
  13. file(MAKE_DIRECTORY ${OUTPUT_LIB})
  14. file(MAKE_DIRECTORY ${OUTPUT_DATA})
  16. # 添加库
  17. add_library(my_lib SHARED utils.cpp)
  18. set_target_properties(my_lib PROPERTIES
  19.     LIBRARY_OUTPUT_DIRECTORY ${OUTPUT_LIB}
  20. )
  22. # 添加可执行文件
  23. add_executable(my_app main.cpp)
  24. target_link_libraries(my_app PRIVATE my_lib)
  25. set_target_properties(my_app PROPERTIES
  26.     RUNTIME_OUTPUT_DIRECTORY ${OUTPUT_BIN}
  27. )
  29. # 添加构建后处理命令
  30. if(WIN32)
  31.     # Windows平台：复制DLL到bin目录
  32.     add_custom_command(TARGET my_app POST_BUILD
  33.         COMMAND ${CMAKE_COMMAND} -E copy_if_different
  34.         $<TARGET_FILE:my_lib> $<TARGET_FILE_DIR:my_app>
  35.         COMMENT "Copying my_lib.dll to bin directory"
  36.     )
  37. else()
  38.     # Unix-like平台：创建符号链接
  39.     add_custom_command(TARGET my_app POST_BUILD
  40.         COMMAND ${CMAKE_COMMAND} -E create_symlink
  41.         $<TARGET_FILE:my_lib> $<TARGET_FILE_DIR:my_app>/$<TARGET_FILE_NAME:my_lib>
  42.         COMMENT "Creating symlink to my_lib in bin directory"
  43.     )
  44. endif()
  46. # 复制数据文件
  47. file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/data/ DESTINATION ${OUTPUT_DATA})
  49. # 创建一个打包目标
  50. add_custom_target(package_output
  51.     COMMAND ${CMAKE_COMMAND} -E tar czf ${CMAKE_BINARY_DIR}/output.tar.gz ${OUTPUT_DIR}
  52.     DEPENDS my_app my_lib
  53.     COMMENT "Creating output package"
  54. )
复制代码

5.3 安装规则与打包

CMake的install命令允许我们定义安装规则，将构建产物安装到指定位置，这对于创建分发包非常重要：
  2. cmake_minimum_required(VERSION 3.10)
  3. project(InstallProject)
  5. # 设置版本信息
  6. set(PROJECT_VERSION_MAJOR 1)
  7. set(PROJECT_VERSION_MINOR 0)
  8. set(PROJECT_VERSION_PATCH 0)
  9. set(PROJECT_VERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH})
  11. # 添加库
  12. add_library(my_lib SHARED utils.cpp)
  13. target_include_directories(my_lib PUBLIC
  14.     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
  15.     $<INSTALL_INTERFACE:include>
  16. )
  18. # 添加可执行文件
  19. add_executable(my_app main.cpp)
  20. target_link_libraries(my_app PRIVATE my_lib)
  22. # 设置输出目录
  23. set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
  24. set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
  25. set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
  27. # 定义安装规则
  28. install(TARGETS my_lib
  29.     EXPORT my_libTargets
  30.     LIBRARY DESTINATION lib
  31.     ARCHIVE DESTINATION lib
  32.     RUNTIME DESTINATION bin
  33.     INCLUDES DESTINATION include
  34. )
  36. install(TARGETS my_app
  37.     RUNTIME DESTINATION bin
  38. )
  40. # 安装头文件
  41. install(DIRECTORY include/ DESTINATION include)
  43. # 安装导出文件
  44. install(EXPORT my_libTargets
  45.     FILE my_libTargets.cmake
  46.     NAMESPACE my_lib::
  47.     DESTINATION lib/cmake/my_lib
  48. )
  50. # 创建配置文件
  51. include(CMakePackageConfigHelpers)
  52. write_basic_package_version_file(
  53.     "${CMAKE_CURRENT_BINARY_DIR}/my_libConfigVersion.cmake"
  54.     VERSION ${PROJECT_VERSION}
  55.     COMPATIBILITY AnyNewerVersion
  56. )
  58. # 安装配置文件
  59. install(FILES
  60.     "${CMAKE_CURRENT_BINARY_DIR}/my_libConfigVersion.cmake"
  61.     DESTINATION lib/cmake/my_lib
  62. )
  64. # 创建包
  65. set(CPACK_PACKAGE_NAME "my_project")
  66. set(CPACK_PACKAGE_VERSION ${PROJECT_VERSION})
  67. set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "My Project")
  68. set(CPACK_PACKAGE_VENDOR "My Company")
  70. set(CPACK_DEBIAN_PACKAGE_MAINTAINER "maintainer@example.com")
  71. set(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6 (>= 2.3.1-6)")
  73. include(CPack)
复制代码

6. 实际项目案例分析

6.1 简单可执行程序的输出管理

对于一个简单的可执行程序项目，我们可以采用以下输出管理策略：
  2. cmake_minimum_required(VERSION 3.10)
  3. project(SimpleApp VERSION 1.0.0 LANGUAGES CXX)
  5. # 设置C++标准
  6. set(CMAKE_CXX_STANDARD 17)
  7. set(CMAKE_CXX_STANDARD_REQUIRED ON)
  9. # 设置输出目录
  10. set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
  12. # 查找依赖包
  13. find_package(Boost REQUIRED COMPONENTS filesystem system)
  15. # 添加可执行文件
  16. add_executable(simple_app
  17.     src/main.cpp
  18.     src/utils.cpp
  19. )
  21. # 链接依赖库
  22. target_link_libraries(simple_app PRIVATE
  23.     Boost::filesystem
  24.     Boost::system
  25. )
  27. # 包含目录
  28. target_include_directories(simple_app PRIVATE
  29.     ${CMAKE_CURRENT_SOURCE_DIR}/include
  30. )
  32. # 复制资源文件
  33. file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/resources/ DESTINATION
  34.     ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/resources)
  36. # 安装规则
  37. install(TARGETS simple_app
  38.     RUNTIME DESTINATION bin
  39. )
  41. install(DIRECTORY resources/ DESTINATION share/simple_app/resources)
  42. install(DIRECTORY include/ DESTINATION include)
复制代码

6.2 静态/动态库项目的输出管理

对于一个库项目，我们需要同时管理静态库和动态库的输出：
  2. cmake_minimum_required(VERSION 3.10)
  3. project(MyLib VERSION 1.0.0 LANGUAGES CXX)
  5. # 设置C++标准
  6. set(CMAKE_CXX_STANDARD 17)
  7. set(CMAKE_CXX_STANDARD_REQUIRED ON)
  9. # 设置输出目录
  10. set(OUTPUT_DIR ${CMAKE_BINARY_DIR}/output)
  11. set(OUTPUT_LIB ${OUTPUT_DIR}/lib)
  12. set(OUTPUT_INCLUDE ${OUTPUT_DIR}/include)
  14. # 创建输出目录
  15. file(MAKE_DIRECTORY ${OUTPUT_LIB})
  16. file(MAKE_DIRECTORY ${OUTPUT_INCLUDE})
  18. # 添加库源文件
  19. set(LIB_SOURCES
  20.     src/utils.cpp
  21.     src/network.cpp
  22.     src/database.cpp
  23. )
  25. # 添加静态库
  26. add_library(my_lib_static STATIC ${LIB_SOURCES})
  27. set_target_properties(my_lib_static PROPERTIES
  28.     OUTPUT_NAME my_lib
  29.     ARCHIVE_OUTPUT_DIRECTORY ${OUTPUT_LIB}
  30. )
  32. # 添加动态库
  33. add_library(my_lib_shared SHARED ${LIB_SOURCES})
  34. set_target_properties(my_lib_shared PROPERTIES
  35.     OUTPUT_NAME my_lib
  36.     LIBRARY_OUTPUT_DIRECTORY ${OUTPUT_LIB}
  37.     RUNTIME_OUTPUT_DIRECTORY ${OUTPUT_LIB}  # Windows上的DLL
  38. )
  40. # 设置包含目录
  41. target_include_directories(my_lib_static PUBLIC
  42.     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
  43.     $<INSTALL_INTERFACE:include>
  44. )
  46. target_include_directories(my_lib_shared PUBLIC
  47.     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
  48.     $<INSTALL_INTERFACE:include>
  49. )
  51. # 复制头文件到输出目录
  52. file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/include/ DESTINATION ${OUTPUT_INCLUDE})
  54. # 添加别名目标
  55. add_library(my_lib::static ALIAS my_lib_static)
  56. add_library(my_lib::shared ALIAS my_lib_shared)
  58. # 安装规则
  59. install(TARGETS my_lib_static my_lib_shared
  60.     EXPORT my_libTargets
  61.     LIBRARY DESTINATION lib
  62.     ARCHIVE DESTINATION lib
  63.     RUNTIME DESTINATION lib
  64.     INCLUDES DESTINATION include
  65. )
  67. # 安装头文件
  68. install(DIRECTORY include/ DESTINATION include)
  70. # 安装导出文件
  71. install(EXPORT my_libTargets
  72.     FILE my_libTargets.cmake
  73.     NAMESPACE my_lib::
  74.     DESTINATION lib/cmake/my_lib
  75. )
  77. # 创建包配置文件
  78. include(CMakePackageConfigHelpers)
  79. configure_package_config_file(
  80.     ${CMAKE_CURRENT_SOURCE_DIR}/cmake/my_libConfig.cmake.in
  81.     ${CMAKE_CURRENT_BINARY_DIR}/my_libConfig.cmake
  82.     INSTALL_DESTINATION lib/cmake/my_lib
  83. )
  85. write_basic_package_version_file(
  86.     ${CMAKE_CURRENT_BINARY_DIR}/my_libConfigVersion.cmake
  87.     VERSION ${PROJECT_VERSION}
  88.     COMPATIBILITY SameMajorVersion
  89. )
  91. # 安装配置文件
  92. install(FILES
  93.     ${CMAKE_CURRENT_BINARY_DIR}/my_libConfig.cmake
  94.     ${CMAKE_CURRENT_BINARY_DIR}/my_libConfigVersion.cmake
  95.     DESTINATION lib/cmake/my_lib
  96. )
  98. # 打包支持
  99. include(CPack)
复制代码

6.3 复杂多模块项目的输出管理

对于一个复杂的多模块项目，我们需要更加精细的输出管理策略：
  2. # 顶层 CMakeLists.txt
  3. cmake_minimum_required(VERSION 3.10)
  4. project(ComplexProject VERSION 1.0.0 LANGUAGES CXX C)
  6. # 设置C++标准
  7. set(CMAKE_CXX_STANDARD 17)
  8. set(CMAKE_CXX_STANDARD_REQUIRED ON)
  10. # 设置全局变量
  11. set(OUTPUT_ROOT ${CMAKE_BINARY_DIR}/output)
  12. set(OUTPUT_BIN ${OUTPUT_ROOT}/bin)
  13. set(OUTPUT_LIB ${OUTPUT_ROOT}/lib)
  14. set(OUTPUT_INCLUDE ${OUTPUT_ROOT}/include)
  15. set(OUTPUT_PLUGIN ${OUTPUT_ROOT}/plugins)
  16. set(OUTPUT_DATA ${OUTPUT_ROOT}/data)
  17. set(OUTPUT_DOC ${OUTPUT_ROOT}/doc)
  19. # 创建输出目录
  20. file(MAKE_DIRECTORY ${OUTPUT_BIN})
  21. file(MAKE_DIRECTORY ${OUTPUT_LIB})
  22. file(MAKE_DIRECTORY ${OUTPUT_INCLUDE})
  23. file(MAKE_DIRECTORY ${OUTPUT_PLUGIN})
  24. file(MAKE_DIRECTORY ${OUTPUT_DATA})
  25. file(MAKE_DIRECTORY ${OUTPUT_DOC})
  27. # 设置全局输出变量
  28. set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${OUTPUT_BIN})
  29. set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${OUTPUT_LIB})
  30. set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${OUTPUT_LIB})
  32. # 添加子目录
  33. add_subdirectory(third_party)
  34. add_subdirectory(core)
  35. add_subdirectory(modules)
  36. add_subdirectory(apps)
  37. add_subdirectory(plugins)
  38. add_subdirectory(tests)
  40. # 安装规则
  41. install(DIRECTORY ${OUTPUT_INCLUDE}/ DESTINATION include)
  42. install(DIRECTORY ${OUTPUT_DATA}/ DESTINATION share/complexproject)
  43. install(DIRECTORY ${OUTPUT_DOC}/ DESTINATION share/doc/complexproject)
  45. # 打包支持
  46. set(CPACK_PACKAGE_NAME "complexproject")
  47. set(CPACK_PACKAGE_VERSION ${PROJECT_VERSION})
  48. set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Complex Project")
  49. set(CPACK_PACKAGE_VENDOR "My Company")
  51. set(CPACK_DEB_COMPONENT_INSTALL ON)
  52. set(CPACK_RPM_COMPONENT_INSTALL ON)
  54. set(CPACK_COMPONENTS_ALL core apps plugins data doc)
  56. set(CPACK_COMPONENT_CORE_DISPLAY_NAME "Core Libraries")
  57. set(CPACK_COMPONENT_CORE_DESCRIPTION "Core libraries for Complex Project")
  58. set(CPACK_COMPONENT_CORE_DEPENDS data)
  60. set(CPACK_COMPONENT_APPS_DISPLAY_NAME "Applications")
  61. set(CPACK_COMPONENT_APPS_DESCRIPTION "Applications for Complex Project")
  62. set(CPACK_COMPONENT_APPS_DEPENDS core)
  64. set(CPACK_COMPONENT_PLUGINS_DISPLAY_NAME "Plugins")
  65. set(CPACK_COMPONENT_PLUGINS_DESCRIPTION "Plugins for Complex Project")
  66. set(CPACK_COMPONENT_PLUGINS_DEPENDS core)
  68. set(CPACK_COMPONENT_DATA_DISPLAY_NAME "Data Files")
  69. set(CPACK_COMPONENT_DATA_DESCRIPTION "Data files for Complex Project")
  71. set(CPACK_COMPONENT_DOC_DISPLAY_NAME "Documentation")
  72. set(CPACK_COMPONENT_DOC_DESCRIPTION "Documentation for Complex Project")
  74. include(CPack)
复制代码

core/CMakeLists.txt:
  2. # 核心库模块
  3. project(CoreLib)
  5. # 设置输出目录
  6. set(CORE_OUTPUT_DIR ${OUTPUT_LIB}/core)
  8. # 添加核心库
  9. add_library(core_lib
  10.     src/utils.cpp
  11.     src/logger.cpp
  12.     src/config.cpp
  13. )
  15. set_target_properties(core_lib PROPERTIES
  16.     LIBRARY_OUTPUT_DIRECTORY ${CORE_OUTPUT_DIR}
  17.     ARCHIVE_OUTPUT_DIRECTORY ${CORE_OUTPUT_DIR}
  18.     RUNTIME_OUTPUT_DIRECTORY ${CORE_OUTPUT_DIR}
  19. )
  21. # 设置包含目录
  22. target_include_directories(core_lib PUBLIC
  23.     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
  24.     $<INSTALL_INTERFACE:include/core>
  25. )
  27. # 复制头文件到输出目录
  28. file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/include/ DESTINATION ${OUTPUT_INCLUDE}/core)
  30. # 安装规则
  31. install(TARGETS core_lib
  32.     EXPORT coreTargets
  33.     LIBRARY DESTINATION lib/core
  34.     ARCHIVE DESTINATION lib/core
  35.     RUNTIME DESTINATION lib/core
  36.     INCLUDES DESTINATION include/core
  37.     COMPONENT core
  38. )
  40. # 安装导出文件
  41. install(EXPORT coreTargets
  42.     FILE coreTargets.cmake
  43.     NAMESPACE core::
  44.     DESTINATION lib/cmake/core
  45.     COMPONENT core
  46. )
复制代码

modules/CMakeLists.txt:
  2. # 功能模块
  3. project(Modules)
  5. # 添加网络模块
  6. add_subdirectory(network)
  7. # 添加数据库模块
  8. add_subdirectory(database)
  9. # 添加图形模块
  10. add_subdirectory(graphics)
复制代码

modules/network/CMakeLists.txt:
  2. # 网络模块
  3. project(NetworkModule)
  5. # 设置输出目录
  6. set(NETWORK_OUTPUT_DIR ${OUTPUT_LIB}/modules/network)
  8. # 添加网络库
  9. add_library(network_module
  10.     src/client.cpp
  11.     src/server.cpp
  12.     src/protocol.cpp
  13. )
  15. set_target_properties(network_module PROPERTIES
  16.     LIBRARY_OUTPUT_DIRECTORY ${NETWORK_OUTPUT_DIR}
  17.     ARCHIVE_OUTPUT_DIRECTORY ${NETWORK_OUTPUT_DIR}
  18.     RUNTIME_OUTPUT_DIRECTORY ${NETWORK_OUTPUT_DIR}
  19. )
  21. # 设置包含目录和依赖
  22. target_include_directories(network_module PUBLIC
  23.     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
  24.     $<INSTALL_INTERFACE:include/modules/network>
  25. )
  27. target_link_libraries(network_module PUBLIC core_lib)
  29. # 复制头文件到输出目录
  30. file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/include/ DESTINATION ${OUTPUT_INCLUDE}/modules/network)
  32. # 安装规则
  33. install(TARGETS network_module
  34.     EXPORT networkTargets
  35.     LIBRARY DESTINATION lib/modules/network
  36.     ARCHIVE DESTINATION lib/modules/network
  37.     RUNTIME DESTINATION lib/modules/network
  38.     INCLUDES DESTINATION include/modules/network
  39.     COMPONENT core
  40. )
  42. # 安装导出文件
  43. install(EXPORT networkTargets
  44.     FILE networkTargets.cmake
  45.     NAMESPACE network::
  46.     DESTINATION lib/cmake/network
  47.     COMPONENT core
  48. )
复制代码

apps/CMakeLists.txt:
  2. # 应用程序
  3. project(Apps)
  5. # 添加主应用程序
  6. add_executable(main_app
  7.     src/main.cpp
  8.     src/mainwindow.cpp
  9. )
  11. set_target_properties(main_app PROPERTIES
  12.     RUNTIME_OUTPUT_DIRECTORY ${OUTPUT_BIN}/apps
  13. )
  15. target_link_libraries(main_app PRIVATE
  16.     core_lib
  17.     network_module
  18.     database_module
  19.     graphics_module
  20. )
  22. # 添加工具应用程序
  23. add_executable(tool_app
  24.     src/tool.cpp
  25. )
  27. set_target_properties(tool_app PROPERTIES
  28.     RUNTIME_OUTPUT_DIRECTORY ${OUTPUT_BIN}/tools
  29. )
  31. target_link_libraries(tool_app PRIVATE
  32.     core_lib
  33.     database_module
  34. )
  36. # 安装规则
  37. install(TARGETS main_app
  38.     RUNTIME DESTINATION bin
  39.     COMPONENT apps
  40. )
  42. install(TARGETS tool_app
  43.     RUNTIME DESTINATION bin
  44.     COMPONENT apps
  45. )
复制代码

plugins/CMakeLists.txt:
  2. # 插件模块
  3. project(Plugins)
  5. # 添加插件1
  6. add_library(plugin1 MODULE
  7.     src/plugin1.cpp
  8. )
  10. set_target_properties(plugin1 PROPERTIES
  11.     LIBRARY_OUTPUT_DIRECTORY ${OUTPUT_PLUGIN}
  12. )
  14. target_link_libraries(plugin1 PRIVATE
  15.     core_lib
  16.     graphics_module
  17. )
  19. # 添加插件2
  20. add_library(plugin2 MODULE
  21.     src/plugin2.cpp
  22. )
  24. set_target_properties(plugin2 PROPERTIES
  25.     LIBRARY_OUTPUT_DIRECTORY ${OUTPUT_PLUGIN}
  26. )
  28. target_link_libraries(plugin2 PRIVATE
  29.     core_lib
  30.     network_module
  31. )
  33. # 安装规则
  34. install(TARGETS plugin1 plugin2
  35.     LIBRARY DESTINATION lib/plugins
  36.     COMPONENT plugins
  37. )
复制代码

7. 最佳实践与常见问题

7.1 构建输出管理的最佳实践

1. 始终使用源外构建：保持源码目录整洁，避免构建产物污染源码。
2. 统一输出目录结构：制定并遵循一致的输出目录命名和组织规则，例如：build/
output/
   bin/          # 可执行文件
   lib/          # 库文件
     static/     # 静态库
     shared/     # 动态库
   include/      # 头文件
   plugins/      # 插件
   data/         # 数据文件
   doc/          # 文档
3. 使用CMake变量控制输出路径：充分利用CMake提供的输出路径变量，如CMAKE_RUNTIME_OUTPUT_DIRECTORY等。
4. 按类型和配置组织输出：根据文件类型（可执行文件、库文件）和构建配置（Debug、Release）组织输出目录。
5.
  2. 使用生成器表达式：利用CMake的生成器表达式实现更灵活的输出控制，例如：set_target_properties(my_lib PROPERTIES
  3.    LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib/$<CONFIG>"
  4. )
复制代码
6. 为多项目定义清晰的层次结构：对于包含多个子项目的大型项目，定义清晰的层次结构和命名规则。
7. 使用目标属性控制输出：使用set_target_properties()为特定目标设置输出属性，而不是全局设置。
8. 考虑跨平台兼容性：处理不同平台的文件扩展名和路径分隔符差异，确保输出结构在所有目标平台上保持一致。
9. 定义明确的安装规则：使用install()命令定义清晰的安装规则，便于创建分发包。
10. 文档化输出结构：在项目文档中说明构建输出的组织结构，帮助团队成员理解和使用。

始终使用源外构建：保持源码目录整洁，避免构建产物污染源码。

统一输出目录结构：制定并遵循一致的输出目录命名和组织规则，例如：
  2. build/
  3. output/
  4.    bin/          # 可执行文件
  5.    lib/          # 库文件
  6.      static/     # 静态库
  7.      shared/     # 动态库
  8.    include/      # 头文件
  9.    plugins/      # 插件
  10.    data/         # 数据文件
  11.    doc/          # 文档
复制代码

使用CMake变量控制输出路径：充分利用CMake提供的输出路径变量，如CMAKE_RUNTIME_OUTPUT_DIRECTORY等。

按类型和配置组织输出：根据文件类型（可执行文件、库文件）和构建配置（Debug、Release）组织输出目录。

使用生成器表达式：利用CMake的生成器表达式实现更灵活的输出控制，例如：
  2. set_target_properties(my_lib PROPERTIES
  3.    LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib/$<CONFIG>"
  4. )
复制代码

为多项目定义清晰的层次结构：对于包含多个子项目的大型项目，定义清晰的层次结构和命名规则。

使用目标属性控制输出：使用set_target_properties()为特定目标设置输出属性，而不是全局设置。

考虑跨平台兼容性：处理不同平台的文件扩展名和路径分隔符差异，确保输出结构在所有目标平台上保持一致。

定义明确的安装规则：使用install()命令定义清晰的安装规则，便于创建分发包。

文档化输出结构：在项目文档中说明构建输出的组织结构，帮助团队成员理解和使用。

7.2 常见问题及解决方案

原因：没有统一设置输出目录变量，或者使用了混合的源内构建和源外构建。

解决方案：
  2. # 在顶层CMakeLists.txt中统一设置输出目录
  3. set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
  4. set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
  5. set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
  7. # 确保所有子项目都遵循这些设置
复制代码

原因：没有为不同配置（Debug、Release等）设置不同的输出目录。

解决方案：
  2. # 为不同配置设置不同的输出目录
  3. set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR}/bin/debug)
  4. set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}/bin/release)
  5. set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR}/lib/debug)
  6. set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}/lib/release)
  7. set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR}/lib/debug)
  8. set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}/lib/release)
复制代码

原因：动态库和可执行文件的输出目录不一致。

解决方案：
  2. # 将动态库和可执行文件放在同一目录
  3. set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
  4. set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)  # 动态库也输出到bin目录
  6. # 或者使用构建后处理命令复制动态库
  7. add_custom_command(TARGET my_app POST_BUILD
  8.     COMMAND ${CMAKE_COMMAND} -E copy_if_different
  9.     $<TARGET_FILE:my_lib> $<TARGET_FILE_DIR:my_app>
  10. )
复制代码

原因：没有正确设置头文件的安装规则或复制规则。

解决方案：
  2. # 设置包含目录
  3. target_include_directories(my_lib PUBLIC
  4.     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
  5.     $<INSTALL_INTERFACE:include>
  6. )
  8. # 复制头文件到输出目录
  9. file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/include/ DESTINATION ${OUTPUT_INCLUDE})
  11. # 安装头文件
  12. install(DIRECTORY include/ DESTINATION include)
复制代码

原因：没有考虑不同平台的路径分隔符和文件扩展名差异。

解决方案：
  2. # 使用file命令处理路径，自动处理路径分隔符
  3. file(TO_CMAKE_PATH "/path/to/somewhere" NORMALIZED_PATH)
  5. # 处理不同平台的文件扩展名
  6. if(WIN32)
  7.     set(EXE_EXT ".exe")
  8.     set(SHARED_LIB_EXT ".dll")
  9. else()
  10.     set(EXE_EXT "")
  11.     set(SHARED_LIB_EXT ".so")
  12. endif()
  14. set_target_properties(my_app PROPERTIES
  15.     RUNTIME_OUTPUT_NAME "my_app${EXE_EXT}"
  16. )
复制代码

7.3 跨平台兼容性考虑

在跨平台项目中，构建输出管理需要考虑不同平台的特性和差异：

1. 路径分隔符：使用CMake的路径处理函数，而不是硬编码路径分隔符。
2. 文件扩展名：根据平台设置不同的文件扩展名。
3. 大小写敏感：Unix系统通常区分大小写，而Windows不区分，保持文件名大小写一致。
4. 库文件命名：不同平台对库文件的命名约定不同，需要适当处理。
5. RPATH和RUNPATH：在Unix系统上，可能需要设置RPATH或RUNPATH以帮助找到动态库。

路径分隔符：使用CMake的路径处理函数，而不是硬编码路径分隔符。

文件扩展名：根据平台设置不同的文件扩展名。

大小写敏感：Unix系统通常区分大小写，而Windows不区分，保持文件名大小写一致。

库文件命名：不同平台对库文件的命名约定不同，需要适当处理。

RPATH和RUNPATH：在Unix系统上，可能需要设置RPATH或RUNPATH以帮助找到动态库。
  2. # 跨平台兼容的输出管理示例
  3. cmake_minimum_required(VERSION 3.10)
  4. project(CrossPlatformProject)
  6. # 设置平台相关变量
  7. if(WIN32)
  8.     set(EXE_EXT ".exe")
  9.     set(SHARED_LIB_EXT ".dll")
  10.     set(STATIC_LIB_EXT ".lib")
  11.     set(IMPORT_LIB_EXT ".lib")
  12.     set(PLUGIN_EXT ".dll")
  13. elseif(APPLE)
  14.     set(EXE_EXT "")
  15.     set(SHARED_LIB_EXT ".dylib")
  16.     set(STATIC_LIB_EXT ".a")
  17.     set(PLUGIN_EXT ".so")
  18.     # 设置RPATH
  19.     set(CMAKE_MACOSX_RPATH ON)
  20.     set(CMAKE_INSTALL_RPATH "@loader_path/../lib")
  21. else()
  22.     set(EXE_EXT "")
  23.     set(SHARED_LIB_EXT ".so")
  24.     set(STATIC_LIB_EXT ".a")
  25.     set(PLUGIN_EXT ".so")
  26.     # 设置RPATH
  27.     set(CMAKE_INSTALL_RPATH "\$ORIGIN/../lib")
  28. endif()
  30. # 设置输出目录
  31. set(OUTPUT_ROOT ${CMAKE_BINARY_DIR}/output)
  32. set(OUTPUT_BIN ${OUTPUT_ROOT}/bin)
  33. set(OUTPUT_LIB ${OUTPUT_ROOT}/lib)
  34. set(OUTPUT_INCLUDE ${OUTPUT_ROOT}/include)
  36. # 创建输出目录
  37. file(MAKE_DIRECTORY ${OUTPUT_BIN})
  38. file(MAKE_DIRECTORY ${OUTPUT_LIB})
  39. file(MAKE_DIRECTORY ${OUTPUT_INCLUDE})
  41. # 添加库
  42. add_library(my_lib SHARED utils.cpp)
  43. set_target_properties(my_lib PROPERTIES
  44.     LIBRARY_OUTPUT_DIRECTORY ${OUTPUT_LIB}
  45.     LIBRARY_OUTPUT_NAME "my_lib${SHARED_LIB_EXT}"
  46.     ARCHIVE_OUTPUT_NAME "my_lib${STATIC_LIB_EXT}"
  47. )
  49. # 添加可执行文件
  50. add_executable(my_app main.cpp)
  51. target_link_libraries(my_app PRIVATE my_lib)
  52. set_target_properties(my_app PROPERTIES
  53.     RUNTIME_OUTPUT_DIRECTORY ${OUTPUT_BIN}
  54.     RUNTIME_OUTPUT_NAME "my_app${EXE_EXT}"
  55. )
  57. # 在Unix系统上设置RPATH
  58. if(UNIX AND NOT APPLE)
  59.     set_target_properties(my_app PROPERTIES
  60.         INSTALL_RPATH "\$ORIGIN/../lib"
  61.         BUILD_WITH_INSTALL_RPATH ON
  62.     )
  63. endif()
  65. # 复制头文件
  66. file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/include/ DESTINATION ${OUTPUT_INCLUDE})
  68. # 安装规则
  69. install(TARGETS my_lib my_app
  70.     RUNTIME DESTINATION bin
  71.     LIBRARY DESTINATION lib
  72.     ARCHIVE DESTINATION lib
  73. )
  75. install(DIRECTORY include/ DESTINATION include)
复制代码

8. 总结与展望

CMake构建输出管理是项目组织和维护的重要方面。通过本文的介绍，我们了解了CMake构建输出的基本概念、控制变量、组织策略以及高级技巧。良好的构建输出管理可以带来以下好处：

1. 提高项目可维护性：清晰的输出结构使开发者能够快速定位所需文件。
2. 简化部署流程：有序的输出组织便于打包和分发。
3. 提升构建效率：合理的输出路径配置可以避免不必要的文件操作。
4. 增强团队协作：统一的输出结构规范有助于团队成员之间的协作。

在实践中，我们应该根据项目规模和需求选择合适的输出管理策略，遵循最佳实践，并注意解决常见问题和跨平台兼容性。

随着CMake的不断发展，构建输出管理也在不断演进。未来，我们可以期待CMake提供更加灵活和强大的输出管理功能，例如更细粒度的输出控制、更智能的依赖管理以及更好的跨平台支持。作为开发者，我们应该持续关注CMake的发展，及时学习和应用新的技术和最佳实践，以打造更加整洁高效的项目结构。
跨平台, 扮演着, 全攻略
「七転び八起き（ななころびやおき）」
回复

使用道具 举报

返回列表 发新帖
您需要登录后才可以回帖 登录 | 立即注册
高级模式
B Color Image Link Quote Code Smilies

本版积分规则

关闭

站长推荐上一条 /1 下一条

友情链接

keba
磕巴白菜
别管 别听 就是玩
二次元论坛
二次元论坛
按下F逃离世界！
友链交换
友链交换
友链为随机排序，不代表本论坛观点
Telegram

Telegram

Discord

Discord

Tencent QQ

Tencent QQ

手机版|联系我们|小黑屋|TG频道|RSS |网站地图

Powered by Pixtech

© 2025-2026 Pixtech Team.

>