CMake与CMakeExport详解从基础配置到高级导出技巧全面掌握CMake构建系统与库文件导出方法提升项目开发效率

威震华夏关云长

引言

CMake是一个跨平台的构建系统生成器，它使用简单的配置文件来控制软件编译过程，并生成标准的构建文件（如Makefile或Visual Studio项目）。CMakeExport则是CMake中用于导出库文件和目标的重要功能，它使得不同项目之间可以轻松共享和使用已编译的库。本文将从CMake的基础配置开始，逐步深入到高级的CMakeExport技巧，帮助读者全面掌握CMake构建系统与库文件导出方法，从而提升项目开发效率。

CMake基础

CMake简介

CMake是一个开源、跨平台的构建自动化工具，它使用名为CMakeLists.txt的配置文件来生成标准的构建文件（如Unix的Makefile或Windows的Visual Studio项目）。CMake的设计目标是提供一个简单而强大的方式来管理软件构建过程，支持多种编译器和开发环境。

CMake的主要特点包括：

• 跨平台支持：可以在Windows、Linux、macOS等多种操作系统上运行
• 多编译器支持：支持GCC、Clang、MSVC等多种编译器
• 简单语法：使用简单的命令和语法来描述构建过程
• 可扩展性：支持自定义命令和函数
• 大型项目支持：能够管理复杂的项目结构和依赖关系

基本语法和命令

CMake使用一系列命令来配置项目，这些命令在CMakeLists.txt文件中编写。以下是一些基本的CMake命令：

2. # 指定CMake最低版本要求
3. cmake_minimum_required(VERSION 3.10)
5. # 定义项目名称和版本
6. project(MyProject VERSION 1.0.0 LANGUAGES CXX)
8. # 添加可执行文件
9. add_executable(my_app main.cpp)
11. # 添加库
12. add_library(my_lib STATIC lib_source.cpp)
14. # 包含目录
15. include_directories(include)
17. # 链接库
18. target_link_libraries(my_app my_lib)
20. # 设置变量
21. set(MY_VARIABLE "value")
23. # 条件判断
24. if(CMAKE_BUILD_TYPE STREQUAL "Debug")
25.     add_definitions(-DDEBUG)
26. endif()
28. # 打印消息
29. message(STATUS "Building project: ${PROJECT_NAME}")

复制代码

项目结构

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

2. my_project/
3. ├── CMakeLists.txt          # 主CMake配置文件
4. ├── include/                # 头文件目录
5. │   └── my_lib/
6. │       └── my_lib.h
7. ├── src/                    # 源文件目录
8. │   ├── my_lib.cpp
9. │   └── main.cpp
10. ├── build/                  # 构建目录（通常不提交到版本控制）
11. └── README.md               # 项目说明文档

复制代码

这种结构将源代码、头文件和构建文件分开，使项目更加清晰和易于管理。

CMake项目配置

最简单的CMake项目

让我们从一个最简单的CMake项目开始。假设我们有一个包含单个源文件的简单程序：

2. // main.cpp
3. #include <iostream>
5. int main() {
6.     std::cout << "Hello, CMake!" << std::endl;
7.     return 0;
8. }

复制代码

对应的CMakeLists.txt文件非常简单：

2. # 要求CMake最低版本
3. cmake_minimum_required(VERSION 3.10)
5. # 定义项目
6. project(HelloCMake)
8. # 添加可执行文件
9. add_executable(hello_cmake main.cpp)

复制代码

要构建这个项目，可以执行以下命令：

2. mkdir build
3. cd build
4. cmake ..
5. make

复制代码

设置项目属性

CMake允许我们设置各种项目属性，如版本号、语言标准等：

2. cmake_minimum_required(VERSION 3.10)
4. # 设置项目名称、版本和语言
5. project(MyProject
6.     VERSION 1.0.0
7.     DESCRIPTION "My awesome project"
8.     LANGUAGES CXX
9. )
11. # 设置C++标准
12. set(CMAKE_CXX_STANDARD 17)
13. set(CMAKE_CXX_STANDARD_REQUIRED ON)
14. set(CMAKE_CXX_EXTENSIONS OFF)
16. # 定义一些有用的变量
17. set(PROJECT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
18. set(PROJECT_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR})

复制代码

添加源文件

当项目包含多个源文件时，我们可以使用以下方式添加它们：

2. # 方式1：直接列出所有源文件
3. add_executable(my_app
4.     src/main.cpp
5.     src/class1.cpp
6.     src/class2.cpp
7. )
9. # 方式2：使用变量存储源文件列表
10. set(SOURCES
11.     src/main.cpp
12.     src/class1.cpp
13.     src/class2.cpp
14. )
15. add_executable(my_app ${SOURCES})
17. # 方式3：使用file命令自动收集源文件
18. file(GLOB_RECURSE SOURCES "src/*.cpp")
19. add_executable(my_app ${SOURCES})

复制代码

注意：使用file(GLOB_RECURSE ...)自动收集源文件虽然方便，但也有缺点。CMake无法自动检测到新添加的文件，除非重新运行CMake配置。因此，对于大型项目，建议显式列出源文件。

设置编译选项

CMake允许我们为不同的构建类型设置不同的编译选项：

2. # 设置构建类型（Release, Debug, RelWithDebInfo, MinSizeRel）
3. if(NOT CMAKE_BUILD_TYPE)
4.     set(CMAKE_BUILD_TYPE "Release")
5. endif()
7. # 针对不同构建类型的编译选项
8. set(CMAKE_CXX_FLAGS_DEBUG "-g -O0")
9. set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG")
10. set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g -DNDEBUG")
11. set(CMAKE_CXX_FLAGS_MINSIZEREL "-Os -DNDEBUG")
13. # 添加编译定义
14. if(CMAKE_BUILD_TYPE STREQUAL "Debug")
15.     add_definitions(-DDEBUG=1)
16. endif()
18. # 添加编译器特定的警告选项
19. if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
20.     add_compile_options(-Wall -Wextra -Wpedantic)
21. elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
22.     add_compile_options(/W4)
23. endif()

复制代码

构建可执行文件和库

构建可执行文件

构建可执行文件是CMake的基本功能之一。我们已经在前面的例子中看到了add_executable命令的基本用法。现在让我们看一个更复杂的例子：

2. cmake_minimum_required(VERSION 3.10)
3. project(MyApp VERSION 1.0.0 LANGUAGES CXX)
5. # 设置C++标准
6. set(CMAKE_CXX_STANDARD 17)
7. set(CMAKE_CXX_STANDARD_REQUIRED ON)
9. # 添加源文件
10. set(APP_SOURCES
11.     src/main.cpp
12.     src/app.cpp
13.     src/utils.cpp
14. )
16. # 添加头文件目录
17. include_directories(${PROJECT_SOURCE_DIR}/include)
19. # 添加可执行文件
20. add_executable(${PROJECT_NAME} ${APP_SOURCES})
22. # 设置输出目录
23. set_target_properties(${PROJECT_NAME} PROPERTIES
24.     RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin
25. )
27. # 链接系统库（如果需要）
28. find_package(Threads REQUIRED)
29. target_link_libraries(${PROJECT_NAME} PRIVATE Threads::Threads)

复制代码

构建静态库

静态库是在编译时链接到可执行文件中的库文件。在CMake中，我们可以使用add_library命令创建静态库：

2. cmake_minimum_required(VERSION 3.10)
3. project(MyStaticLib VERSION 1.0.0 LANGUAGES CXX)
5. # 设置C++标准
6. set(CMAKE_CXX_STANDARD 17)
7. set(CMAKE_CXX_STANDARD_REQUIRED ON)
9. # 添加库源文件
10. set(LIB_SOURCES
11.     src/my_lib.cpp
12.     src/utils.cpp
13. )
15. # 添加静态库
16. add_library(${PROJECT_NAME} STATIC ${LIB_SOURCES})
18. # 设置头文件目录
19. target_include_directories(${PROJECT_NAME} PUBLIC
20.     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
21.     $<INSTALL_INTERFACE:include>
22. )
24. # 设置库属性
25. set_target_properties(${PROJECT_NAME} PROPERTIES
26.     ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib
27. )
29. # 编译定义
30. target_compile_definitions(${PROJECT_NAME} PRIVATE MY_LIB_EXPORTS)

复制代码

构建动态库

动态库（在Windows上称为DLL，在Linux/Unix上称为共享库）是在运行时加载的库文件。创建动态库的CMake代码与静态库类似：

2. cmake_minimum_required(VERSION 3.10)
3. project(MySharedLib VERSION 1.0.0 LANGUAGES CXX)
5. # 设置C++标准
6. set(CMAKE_CXX_STANDARD 17)
7. set(CMAKE_CXX_STANDARD_REQUIRED ON)
9. # 添加库源文件
10. set(LIB_SOURCES
11.     src/my_lib.cpp
12.     src/utils.cpp
13. )
15. # 添加动态库
16. add_library(${PROJECT_NAME} SHARED ${LIB_SOURCES})
18. # 设置头文件目录
19. target_include_directories(${PROJECT_NAME} PUBLIC
20.     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
21.     $<INSTALL_INTERFACE:include>
22. )
24. # 设置库属性
25. set_target_properties(${PROJECT_NAME} PROPERTIES
26.     LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib
27.     RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin  # Windows DLL需要
28. )
30. # 编译定义
31. target_compile_definitions(${PROJECT_NAME} PRIVATE MY_SHARED_LIB_EXPORTS)

复制代码

对于动态库，我们通常需要处理符号导出问题。在头文件中，我们可以使用预处理器指令来控制符号的导出：

2. // my_lib.h
3. #pragma once
5. #ifdef MY_SHARED_LIB_EXPORTS
6. #define MY_API __declspec(dllexport)  // Windows导出
7. #else
8. #define MY_API __declspec(dllimport)  // Windows导入
9. #endif
11. // 对于非Windows平台
12. #ifndef _WIN32
13. #define MY_API
14. #endif
16. // 要导出的类或函数
17. class MY_API MyClass {
18. public:
19.     void doSomething();
20. };
22. MY_API void myFunction();

复制代码

CMake导出基础

什么是CMake导出

CMake导出是一种机制，允许我们创建包含构建目标信息的文件，这些文件可以被其他项目使用，而无需知道原始项目的构建细节。通过导出，其他项目可以轻松地找到并使用我们创建的库，包括链接到正确的库文件、包含正确的头文件目录，并传递必要的编译选项。

CMake导出的主要优势包括：

• 简化依赖管理
• 提供跨平台兼容性
• 支持不同构建类型（Debug/Release）
• 处理传递依赖关系
• 支持包管理器集成

基本导出命令

CMake提供了几个关键命令用于导出目标：

2. # 导出目标到文件
3. export(TARGETS my_target FILE my_target.cmake)
5. # 安装并导出目标
6. install(TARGETS my_target
7.     EXPORT my_export
8.     LIBRARY DESTINATION lib
9.     ARCHIVE DESTINATION lib
10.     RUNTIME DESTINATION bin
11.     INCLUDES DESTINATION include
12. )
14. # 安装导出文件
15. install(EXPORT my_export
16.     FILE my_targets.cmake
17.     DESTINATION lib/cmake/my_project
18. )

复制代码

导出目标

让我们看一个完整的例子，展示如何创建一个库并导出它：

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(LIB_SOURCES
11.     src/my_lib.cpp
12.     src/utils.cpp
13. )
15. # 添加动态库
16. add_library(${PROJECT_NAME} SHARED ${LIB_SOURCES})
18. # 设置头文件目录
19. target_include_directories(${PROJECT_NAME} PUBLIC
20.     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
21.     $<INSTALL_INTERFACE:include>
22. )
24. # 设置库属性
25. set_target_properties(${PROJECT_NAME} PROPERTIES
26.     LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib
27.     RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin
28.     VERSION ${PROJECT_VERSION}
29.     SOVERSION 1
30. )
32. # 编译定义
33. target_compile_definitions(${PROJECT_NAME} PRIVATE MY_LIB_EXPORTS)
35. # 生成导出文件
36. export(TARGETS ${PROJECT_NAME} FILE ${PROJECT_BINARY_DIR}/${PROJECT_NAME}Targets.cmake)
38. # 安装规则
39. install(TARGETS ${PROJECT_NAME}
40.     EXPORT ${PROJECT_NAME}Targets
41.     LIBRARY DESTINATION lib
42.     ARCHIVE DESTINATION lib
43.     RUNTIME DESTINATION bin
44.     INCLUDES DESTINATION include
45. )
47. # 安装头文件
48. install(DIRECTORY include/ DESTINATION include)
50. # 安装导出文件
51. install(EXPORT ${PROJECT_NAME}Targets
52.     FILE ${PROJECT_NAME}Targets.cmake
53.     DESTINATION lib/cmake/${PROJECT_NAME}
54. )
56. # 生成配置文件
57. include(CMakePackageConfigHelpers)
58. write_basic_package_version_file(
59.     "${PROJECT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake"
60.     VERSION ${PROJECT_VERSION}
61.     COMPATIBILITY AnyNewerVersion
62. )
64. # 安装配置文件
65. install(FILES
66.     "${PROJECT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake"
67.     DESTINATION lib/cmake/${PROJECT_NAME}
68. )

复制代码

高级导出技巧

导出配置

CMake允许我们为不同的构建类型创建不同的导出配置。这对于支持多配置生成器（如Visual Studio）特别有用：

2. # 为每个配置创建单独的导出文件
3. foreach(config_type DEBUG RELEASE RELWITHDEBINFO MINSIZEREL)
4.     export(TARGETS my_target
5.         FILE "my_target_${config_type}.cmake"
6.         EXPORT_LINK_INTERFACE_LIBRARIES
7.         CXX_MODULES_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/modules"
8.     )
9. endforeach()
11. # 安装时处理多配置
12. install(TARGETS my_target
13.     EXPORT my_export
14.     RUNTIME DESTINATION bin
15.     LIBRARY DESTINATION lib
16.     ARCHIVE DESTINATION lib
17.     COMPONENT runtime
18. )
20. # 针对不同配置设置不同的属性
21. set_target_properties(my_target PROPERTIES
22.     DEBUG_POSTFIX "d"
23.     RELWITHDEBINFO_POSTFIX "rd"
24. )

复制代码

命名空间

使用命名空间可以避免目标名称冲突，特别是在大型项目中：

2. # 创建命名空间
3. add_library(my_lib STATIC lib.cpp)
4. add_library(my_ns::my_lib ALIAS my_lib)
6. # 导出时使用命名空间
7. export(TARGETS my_lib NAMESPACE my_ns:: FILE MyLibTargets.cmake)
9. # 在其他项目中使用
10. find_package(MyLib REQUIRED)
11. target_link_libraries(my_app PRIVATE my_ns::my_lib)

复制代码

版本控制

版本控制对于库的维护和兼容性非常重要。CMake提供了强大的版本控制功能：

2. # 设置项目版本
3. project(MyLib VERSION 1.2.3)
5. # 设置目标版本属性
6. set_target_properties(MyLib PROPERTIES
7.     VERSION ${PROJECT_VERSION}        # 完整版本号 (1.2.3)
8.     SOVERSION ${PROJECT_VERSION_MAJOR}  # 主版本号 (1)
9. )
11. # 生成版本文件
12. include(CMakePackageConfigHelpers)
13. write_basic_package_version_file(
14.     "${CMAKE_CURRENT_BINARY_DIR}/MyLibConfigVersion.cmake"
15.     VERSION ${PROJECT_VERSION}
16.     COMPATIBILITY AnyNewerVersion  # 或 SameMajorVersion
17. )
19. # 安装版本文件
20. install(FILES
21.     "${CMAKE_CURRENT_BINARY_DIR}/MyLibConfigVersion.cmake"
22.     DESTINATION lib/cmake/MyLib
23. )

复制代码

依赖管理

在导出库时，正确处理依赖关系至关重要：

2. # 假设我们的库依赖于其他库
3. find_package(Boost REQUIRED COMPONENTS filesystem system)
4. find_package(Threads REQUIRED)
6. # 创建库
7. add_library(MyLib SHARED my_lib.cpp)
9. # 链接依赖库
10. target_link_libraries(MyLib
11.     PUBLIC
12.         Boost::filesystem
13.         Boost::system
14.     PRIVATE
15.         Threads::Threads
16. )
18. # 导出时包含依赖关系
19. export(TARGETS MyLib
20.     FILE MyLibTargets.cmake
21.     LINK_INTERFACE_LIBRARIES  # 确保链接接口被正确导出
22. )
24. # 在配置文件中处理依赖
25. configure_package_config_file(
26.     "${CMAKE_CURRENT_SOURCE_DIR}/MyLibConfig.cmake.in"
27.     "${CMAKE_CURRENT_BINARY_DIR}/MyLibConfig.cmake"
28.     INSTALL_DESTINATION lib/cmake/MyLib
29. )

复制代码

对应的MyLibConfig.cmake.in文件可能如下：

2. @PACKAGE_INIT@
4. include(CMakeFindDependencyMacro)
6. # 检查并加载依赖
7. find_dependency(Boost REQUIRED COMPONENTS filesystem system)
8. find_dependency(Threads REQUIRED)
10. # 包含目标文件
11. include("${CMAKE_CURRENT_LIST_DIR}/MyLibTargets.cmake")
13. # 检查兼容性
14. check_required_components(MyLib)

复制代码

实际项目案例

简单库的导出和使用

让我们创建一个完整的例子，展示如何创建一个简单的数学库，导出它，然后在另一个项目中使用它。

首先，创建数学库项目结构：

2. MathLib/
3. ├── CMakeLists.txt
4. ├── include/
5. │   └── mathlib.h
6. └── src/
7.     └── mathlib.cpp

复制代码

mathlib.h文件：

2. #pragma once
4. #ifdef MATHLIB_EXPORTS
5. #define MATHLIB_API __declspec(dllexport)
6. #else
7. #define MATHLIB_API __declspec(dllimport)
8. #endif
10. class MATHLIB_API MathOperations {
11. public:
12.     static double add(double a, double b);
13.     static double subtract(double a, double b);
14.     static double multiply(double a, double b);
15.     static double divide(double a, double b);
16. };

复制代码

mathlib.cpp文件：

2. #include "mathlib.h"
3. #include <stdexcept>
5. double MathOperations::add(double a, double b) {
6.     return a + b;
7. }
9. double MathOperations::subtract(double a, double b) {
10.     return a - b;
11. }
13. double MathOperations::multiply(double a, double b) {
14.     return a * b;
15. }
17. double MathOperations::divide(double a, double b) {
18.     if (b == 0) {
19.         throw std::invalid_argument("Division by zero");
20.     }
21.     return a / b;
22. }

复制代码

CMakeLists.txt文件：

2. cmake_minimum_required(VERSION 3.10)
3. project(MathLib VERSION 1.0.0 LANGUAGES CXX)
5. # 设置C++标准
6. set(CMAKE_CXX_STANDARD 17)
7. set(CMAKE_CXX_STANDARD_REQUIRED ON)
9. # 添加库源文件
10. add_library(${PROJECT_NAME} SHARED
11.     src/mathlib.cpp
12. )
14. # 设置头文件目录
15. target_include_directories(${PROJECT_NAME} PUBLIC
16.     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
17.     $<INSTALL_INTERFACE:include>
18. )
20. # 设置库属性
21. set_target_properties(${PROJECT_NAME} PROPERTIES
22.     VERSION ${PROJECT_VERSION}
23.     SOVERSION 1
24. )
26. # 编译定义
27. target_compile_definitions(${PROJECT_NAME} PRIVATE MATHLIB_EXPORTS)
29. # 生成导出文件
30. export(TARGETS ${PROJECT_NAME} FILE ${PROJECT_BINARY_DIR}/${PROJECT_NAME}Targets.cmake)
32. # 安装规则
33. include(GNUInstallDirs)
35. install(TARGETS ${PROJECT_NAME}
36.     EXPORT ${PROJECT_NAME}Targets
37.     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
38.     ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
39.     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
40.     INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
41. )
43. # 安装头文件
44. install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
46. # 安装导出文件
47. install(EXPORT ${PROJECT_NAME}Targets
48.     FILE ${PROJECT_NAME}Targets.cmake
49.     DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}
50. )
52. # 生成配置文件
53. include(CMakePackageConfigHelpers)
54. configure_package_config_file(
55.     "${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}Config.cmake.in"
56.     "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
57.     INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}
58. )
60. # 生成版本文件
61. write_basic_package_version_file(
62.     "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake"
63.     VERSION ${PROJECT_VERSION}
64.     COMPATIBILITY AnyNewerVersion
65. )
67. # 安装配置文件
68. install(FILES
69.     "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
70.     "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake"
71.     DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}
72. )

复制代码

MathLibConfig.cmake.in文件：

2. @PACKAGE_INIT@
4. include("${CMAKE_CURRENT_LIST_DIR}/MathLibTargets.cmake")
6. check_required_components(MathLib)

复制代码

现在，让我们创建一个使用这个库的应用程序项目：

2. MathApp/
3. ├── CMakeLists.txt
4. └── src/
5.     └── main.cpp

复制代码

main.cpp文件：

2. #include <iostream>
3. #include "mathlib.h"
5. int main() {
6.     double a = 10.0;
7.     double b = 5.0;
8.    
9.     std::cout << a << " + " << b << " = " << MathOperations::add(a, b) << std::endl;
10.     std::cout << a << " - " << b << " = " << MathOperations::subtract(a, b) << std::endl;
11.     std::cout << a << " * " << b << " = " << MathOperations::multiply(a, b) << std::endl;
12.     std::cout << a << " / " << b << " = " << MathOperations::divide(a, b) << std::endl;
13.    
14.     return 0;
15. }

复制代码

CMakeLists.txt文件：

2. cmake_minimum_required(VERSION 3.10)
3. project(MathApp VERSION 1.0.0 LANGUAGES CXX)
5. # 设置C++标准
6. set(CMAKE_CXX_STANDARD 17)
7. set(CMAKE_CXX_STANDARD_REQUIRED ON)
9. # 查找MathLib库
10. find_package(MathLib REQUIRED)
12. # 添加可执行文件
13. add_executable(${PROJECT_NAME} src/main.cpp)
15. # 链接MathLib库
16. target_link_libraries(${PROJECT_NAME} PRIVATE MathLib::MathLib)

复制代码

要构建这个项目，首先构建并安装MathLib：

2. cd MathLib
3. mkdir build
4. cd build
5. cmake ..
6. make
7. sudo make install  # 或者使用适当的权限安装

复制代码

然后构建MathApp：

2. cd MathApp
3. mkdir build
4. cd build
5. cmake ..
6. make

复制代码

复杂项目的多级导出

在更复杂的项目中，我们可能需要导出多个相互依赖的库。让我们考虑一个项目，其中包含三个库：CoreLib、UtilsLib和AppLib。CoreLib是基础库，UtilsLib依赖于CoreLib，AppLib依赖于前两者。

项目结构：

2. MyProject/
3. ├── CMakeLists.txt
4. ├── CoreLib/
5. │   ├── CMakeLists.txt
6. │   ├── include/
7. │   │   └── corelib.h
8. │   └── src/
9. │       └── corelib.cpp
10. ├── UtilsLib/
11. │   ├── CMakeLists.txt
12. │   ├── include/
13. │   │   └── utilslib.h
14. │   └── src/
15. │       └── utilslib.cpp
16. ├── AppLib/
17. │   ├── CMakeLists.txt
18. │   ├── include/
19. │   │   └── applib.h
20. │   └── src/
21. │       └── applib.cpp
22. └── examples/
23.     ├── CMakeLists.txt
24.     └── demo_app.cpp

复制代码

顶层CMakeLists.txt：

2. cmake_minimum_required(VERSION 3.10)
3. project(MyProject VERSION 1.0.0 LANGUAGES CXX)
5. # 设置C++标准
6. set(CMAKE_CXX_STANDARD 17)
7. set(CMAKE_CXX_STANDARD_REQUIRED ON)
9. # 添加子目录
10. add_subdirectory(CoreLib)
11. add_subdirectory(UtilsLib)
12. add_subdirectory(AppLib)
13. add_subdirectory(examples)
15. # 导出所有目标
16. export(TARGETS CoreLib UtilsLib AppLib
17.     FILE ${PROJECT_BINARY_DIR}/MyProjectTargets.cmake
18.     NAMESPACE MyProject::
19. )
21. # 安装规则
22. include(GNUInstallDirs)
24. # 安装导出文件
25. install(EXPORT MyProjectTargets
26.     FILE MyProjectTargets.cmake
27.     NAMESPACE MyProject::
28.     DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/MyProject
29. )
31. # 生成配置文件
32. include(CMakePackageConfigHelpers)
33. configure_package_config_file(
34.     "${CMAKE_CURRENT_SOURCE_DIR}/MyProjectConfig.cmake.in"
35.     "${CMAKE_CURRENT_BINARY_DIR}/MyProjectConfig.cmake"
36.     INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/MyProject
37. )
39. # 生成版本文件
40. write_basic_package_version_file(
41.     "${CMAKE_CURRENT_BINARY_DIR}/MyProjectConfigVersion.cmake"
42.     VERSION ${PROJECT_VERSION}
43.     COMPATIBILITY AnyNewerVersion
44. )
46. # 安装配置文件
47. install(FILES
48.     "${CMAKE_CURRENT_BINARY_DIR}/MyProjectConfig.cmake"
49.     "${CMAKE_CURRENT_BINARY_DIR}/MyProjectConfigVersion.cmake"
50.     DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/MyProject
51. )

复制代码

CoreLib/CMakeLists.txt：

2. # 添加库
3. add_library(CoreLib SHARED
4.     src/corelib.cpp
5. )
7. # 设置头文件目录
8. target_include_directories(CoreLib PUBLIC
9.     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
10.     $<INSTALL_INTERFACE:include>
11. )
13. # 设置库属性
14. set_target_properties(CoreLib PROPERTIES
15.     VERSION ${PROJECT_VERSION}
16.     SOVERSION 1
17. )
19. # 编译定义
20. target_compile_definitions(CoreLib PRIVATE CORELIB_EXPORTS)
22. # 安装规则
23. install(TARGETS CoreLib
24.     EXPORT MyProjectTargets
25.     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
26.     ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
27.     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
28.     INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
29. )
31. # 安装头文件
32. install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})

复制代码

UtilsLib/CMakeLists.txt：

2. # 添加库
3. add_library(UtilsLib SHARED
4.     src/utilslib.cpp
5. )
7. # 设置头文件目录
8. target_include_directories(UtilsLib PUBLIC
9.     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
10.     $<INSTALL_INTERFACE:include>
11. )
13. # 链接CoreLib
14. target_link_libraries(UtilsLib PUBLIC CoreLib)
16. # 设置库属性
17. set_target_properties(UtilsLib PROPERTIES
18.     VERSION ${PROJECT_VERSION}
19.     SOVERSION 1
20. )
22. # 编译定义
23. target_compile_definitions(UtilsLib PRIVATE UTILSLIB_EXPORTS)
25. # 安装规则
26. install(TARGETS UtilsLib
27.     EXPORT MyProjectTargets
28.     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
29.     ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
30.     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
31.     INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
32. )
34. # 安装头文件
35. install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})

复制代码

AppLib/CMakeLists.txt：

2. # 添加库
3. add_library(AppLib SHARED
4.     src/applib.cpp
5. )
7. # 设置头文件目录
8. target_include_directories(AppLib PUBLIC
9.     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
10.     $<INSTALL_INTERFACE:include>
11. )
13. # 链接其他库
14. target_link_libraries(AppLib PUBLIC CoreLib UtilsLib)
16. # 设置库属性
17. set_target_properties(AppLib PROPERTIES
18.     VERSION ${PROJECT_VERSION}
19.     SOVERSION 1
20. )
22. # 编译定义
23. target_compile_definitions(AppLib PRIVATE APPLIB_EXPORTS)
25. # 安装规则
26. install(TARGETS AppLib
27.     EXPORT MyProjectTargets
28.     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
29.     ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
30.     RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
31.     INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
32. )
34. # 安装头文件
35. install(DIRECTORY include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})

复制代码

examples/CMakeLists.txt：

2. # 添加可执行文件
3. add_executable(demo_app demo_app.cpp)
5. # 链接库
6. target_link_libraries(demo_app PRIVATE AppLib)

复制代码

这个例子展示了如何在复杂项目中管理多个相互依赖的库，并将它们作为一个整体导出。通过这种方式，其他项目可以简单地使用find_package(MyProject REQUIRED)来访问所有这些库。

最佳实践和常见问题

目录结构建议

良好的目录结构可以使项目更易于维护和理解。以下是一个推荐的项目结构：

2. MyProject/
3. ├── CMakeLists.txt              # 顶层CMake配置文件
4. ├── README.md                   # 项目说明
5. ├── LICENSE                     # 许可证文件
6. ├── cmake/                      # CMake辅助文件
7. │   ├── FindSomeLib.cmake       # 自定义查找模块
8. │   └── MyProjectUtils.cmake    # 项目特定的CMake函数
9. ├── include/                    # 公共头文件
10. │   └── myproject/
11. │       ├── config.h.in
12. │       └── api.h
13. ├── src/                        # 源文件
14. │   ├── core/
15. │   │   ├── core.cpp
16. │   │   └── CMakeLists.txt
17. │   ├── utils/
18. │   │   ├── utils.cpp
19. │   │   └── CMakeLists.txt
20. │   └── CMakeLists.txt
21. ├── tests/                      # 测试文件
22. │   ├── CMakeLists.txt
23. │   ├── test_core.cpp
24. │   └── test_utils.cpp
25. ├── examples/                   # 示例程序
26. │   ├── CMakeLists.txt
27. │   └── demo.cpp
28. ├── docs/                       # 文档
29. │   └── ...
30. ├── third_party/                # 第三方库
31. │   └── ...
32. ├── scripts/                    # 构建和部署脚本
33. │   └── ...
34. └── build/                      # 构建目录（不提交到版本控制）

复制代码

常见错误和解决方案

1. 找不到依赖库

问题：find_package找不到所需的库。

解决方案：

2. # 设置查找路径
3.    list(APPEND CMAKE_PREFIX_PATH /path/to/lib)
5.    # 或者设置特定的变量
6.    set(SomeLib_DIR /path/to/lib/cmake/somelib)
8.    # 提供更详细的错误信息
9.    find_package(SomeLib REQUIRED
10.        HINTS /path/to/lib
11.        PATH_SUFFIXES cmake/somelib
12.    )

复制代码

1. 链接错误

问题：链接阶段出现未定义的引用。

解决方案：

2. # 确保所有必要的库都被链接
3.    target_link_libraries(my_target
4.        PUBLIC
5.            LibA
6.            LibB
7.        PRIVATE
8.            LibC
9.    )
11.    # 检查链接顺序（对于某些编译器很重要）
12.    target_link_libraries(my_target
13.        LibA
14.        LibB
15.        LibC
16.    )

复制代码

1. 头文件找不到

问题：编译时找不到头文件。

解决方案：

2. # 确保正确设置了包含目录
3.    target_include_directories(my_target
4.        PUBLIC
5.            $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
6.            $<INSTALL_INTERFACE:include>
7.    )
9.    # 对于系统头文件
10.    target_include_directories(my_target SYSTEM PRIVATE /usr/include/somelib)

复制代码

1. 导出问题

问题：导出的目标在使用时出现问题。

解决方案：

2. # 确保正确设置了目标属性
3.    set_target_properties(my_lib PROPERTIES
4.        INTERFACE_INCLUDE_DIRECTORIES "$<INSTALL_INTERFACE:include>"
5.        INTERFACE_LINK_LIBRARIES ""
6.    )
8.    # 检查导出文件
9.    export(TARGETS my_lib
10.        FILE my_libTargets.cmake
11.        NAMESPACE my_lib::
12.    )

复制代码

性能优化

1. 减少配置时间

2. # 使用更快的查找方法
3.    find_package(Boost REQUIRED COMPONENTS filesystem system)
5.    # 而不是
6.    find_path(BOOST_INCLUDE_DIR boost/filesystem.hpp)
7.    find_library(BOOST_FILESYSTEM_LIB boost_filesystem)
8.    find_library(BOOST_SYSTEM_LIB boost_system)
10.    # 避免不必要的文件操作
11.    file(GLOB_RECURSE SOURCES "src/*.cpp")  # 避免在大型项目中使用

复制代码

1. 并行构建

2. # 启用并行构建
3.    set(CMAKE_BUILD_PARALLEL_LEVEL 8)  # 使用8个并行任务
5.    # 或者使用命令行
6.    # cmake --build . --parallel 8

复制代码

1. 预编译头

2. # 启用预编译头
3.    target_precompile_headers(my_target
4.        PRIVATE
5.            stdafx.h
6.    )

复制代码

1. 统一构建目录

2. # 使用统一的构建目录可以避免重复构建
3.    set(CMAKE_BINARY_DIR ${CMAKE_SOURCE_DIR}/build)

复制代码

结论

CMake是一个强大而灵活的构建系统，通过正确使用CMake和CMakeExport功能，我们可以大大提高项目开发效率。本文从CMake的基础配置开始，逐步深入到高级的导出技巧，涵盖了从简单库到复杂多级依赖项目的各种情况。

通过掌握CMake的基础知识，我们可以轻松管理项目的构建过程；通过使用CMakeExport，我们可以创建易于分发和使用的库；通过采用最佳实践，我们可以确保项目的可维护性和可扩展性。

随着CMake的不断发展和完善，它已经成为现代C++项目的事实标准构建系统。无论是小型个人项目还是大型企业级应用，CMake都能提供强大而灵活的解决方案。希望本文能够帮助读者全面掌握CMake构建系统与库文件导出方法，从而在实际项目中更加高效地使用这些工具。