CMake构建Qt项目从入门到精通掌握跨平台开发的必备技巧与实践指南解决依赖管理与构建配置的常见问题

威震华夏关云长

引言

CMake是一个跨平台的自动化构建系统，它使用平台无关的配置文件来生成特定平台的构建文件。Qt是一个功能强大的跨平台C++图形用户界面应用程序开发框架。将CMake与Qt结合使用，可以极大地简化跨平台开发过程，提高开发效率。

在当今软件开发环境中，跨平台能力变得越来越重要。开发人员需要确保他们的应用程序能够在不同的操作系统（如Windows、macOS和Linux）上运行。CMake和Qt的组合为这一需求提供了理想的解决方案。CMake负责管理构建过程，而Qt提供了丰富的跨平台库和工具。

本文将深入探讨如何使用CMake构建Qt项目，从基础概念到高级技巧，帮助您掌握跨平台开发的必备技能，并解决依赖管理与构建配置中的常见问题。

CMake基础

CMake是一个开源、跨平台的构建自动化工具，它使用名为CMakeLists.txt的配置文件来生成标准的构建文件（如Unix的Makefile或Windows Visual Studio项目）。CMake的主要优势在于其抽象了不同平台和编译器之间的差异，使开发者能够使用统一的构建系统。

CMake基本语法

CMake使用简单的命令语言，主要由命令（commands）、变量（variables）和属性（properties）组成。以下是一些基本的CMake命令：

2. # 设置CMake最低版本要求
3. cmake_minimum_required(VERSION 3.15)
5. # 项目名称
6. project(MyProject)
8. # 添加可执行文件
9. add_executable(my_app main.cpp)
11. # 添加库
12. add_library(my_lib STATIC lib.cpp)
14. # 包含目录
15. include_directories(include)
17. # 链接库
18. target_link_libraries(my_app my_lib)

复制代码

CMake变量和缓存

CMake使用变量来存储信息，这些变量可以是普通变量，也可以是缓存变量。缓存变量存储在CMakeCache.txt文件中，可以在CMake运行之间保持。

2. # 设置普通变量
3. set(MY_VARIABLE "value")
5. # 设置缓存变量
6. set(MY_CACHE_VARIABLE "value" CACHE STRING "Description")
8. # 引用变量
9. message(STATUS "Variable value: ${MY_VARIABLE}")

复制代码

CMake控制结构

CMake提供了基本的控制结构，如条件语句和循环：

2. # 条件语句
3. if(WIN32)
4.     message(STATUS "Windows platform")
5. elseif(UNIX AND NOT APPLE)
6.     message(STATUS "Linux platform")
7. elseif(APPLE)
8.     message(STATUS "macOS platform")
9. endif()
11. # 循环
12. foreach(item IN ITEMS item1 item2 item3)
13.     message(STATUS "Item: ${item}")
14. endforeach()

复制代码

Qt基础

Qt是一个跨平台的C++应用程序开发框架，提供了丰富的类库和工具，用于开发GUI应用程序、非GUI程序（如命令行工具和服务器）以及嵌入式系统。Qt的核心特性包括：

• 信号和槽机制（用于对象间通信）
• 丰富的GUI组件
• 跨平台能力
• 国际化支持
• 数据库访问
• 网络编程
• 多线程支持

Qt应用程序通常使用qmake（Qt的构建系统）或CMake进行构建。近年来，Qt官方越来越推荐使用CMake作为构建系统，因为它提供了更强大和灵活的功能。

使用CMake构建Qt项目的基础

基本项目结构

一个典型的Qt项目结构可能如下所示：

2. my_qt_project/
3. ├── CMakeLists.txt
4. ├── src/
5. │   ├── main.cpp
6. │   ├── mainwindow.cpp
7. │   └── mainwindow.h
8. ├── include/
9. │   └── mainwindow.h
10. ├── resources/
11. │   └── icons.qrc
12. └── translations/
13.     └── my_app_zh_CN.ts

复制代码

基本的CMakeLists.txt文件

以下是一个基本的CMakeLists.txt文件，用于构建Qt项目：

2. # 设置CMake最低版本要求
3. cmake_minimum_required(VERSION 3.15)
5. # 项目名称
6. project(MyQtApp VERSION 1.0.0 LANGUAGES CXX)
8. # 设置C++标准
9. set(CMAKE_CXX_STANDARD 17)
10. set(CMAKE_CXX_STANDARD_REQUIRED ON)
12. # 查找Qt包
13. find_package(Qt6 REQUIRED COMPONENTS Core Widgets)
15. # 设置Qt自动化工具
16. set(CMAKE_AUTOMOC ON)
17. set(CMAKE_AUTORCC ON)
18. set(CMAKE_AUTOUIC ON)
20. # 添加可执行文件
21. add_executable(my_app
22.     src/main.cpp
23.     src/mainwindow.cpp
24.     src/mainwindow.h
25.     resources/icons.qrc
26. )
28. # 包含目录
29. target_include_directories(my_app PRIVATE include)
31. # 链接Qt库
32. target_link_libraries(my_app PRIVATE Qt6::Core Qt6::Widgets)

复制代码

构建和运行

使用CMake构建Qt项目通常涉及以下步骤：

1. 创建构建目录：mkdir build
cd build
2. 运行CMake配置项目：cmake ..
3. 构建项目：cmake --build .
4. 运行应用程序：
“`bash在Linux和macOS上./my_app

创建构建目录：

2. mkdir build
3. cd build

复制代码

运行CMake配置项目：

2. cmake ..

复制代码

构建项目：

2. cmake --build .

复制代码

运行应用程序：
“`bash

./my_app

# 在Windows上
   Debug\my_app.exe

2. ## 跨平台开发技巧
4. ### 处理平台差异
6. 在跨平台开发中，处理不同操作系统之间的差异是一个重要挑战。CMake提供了多种方式来处理这些差异：
8. ```cmake
9. # 检测操作系统
10. if(WIN32)
11.     # Windows特定代码
12.     add_definitions(-DWINDOWS_PLATFORM)
13.     set(PLATFORM_SOURCES src/windows_specific.cpp)
14. elseif(UNIX AND NOT APPLE)
15.     # Linux特定代码
16.     add_definitions(-DLINUX_PLATFORM)
17.     set(PLATFORM_SOURCES src/linux_specific.cpp)
18. elseif(APPLE)
19.     # macOS特定代码
20.     add_definitions(-DMACOS_PLATFORM)
21.     set(PLATFORM_SOURCES src/macos_specific.cpp)
22. endif()
24. # 添加平台特定源文件
25. target_sources(my_app PRIVATE ${PLATFORM_SOURCES})

复制代码

条件编译

有时，您可能需要根据不同的条件包含或排除某些代码。CMake允许您定义预处理器宏来实现这一点：

2. # 定义特性宏
3. option(ENABLE_FEATURE_X "Enable feature X" ON)
5. if(ENABLE_FEATURE_X)
6.     add_definitions(-DENABLE_FEATURE_X)
7.     target_sources(my_app PRIVATE src/feature_x.cpp)
8. endif()

复制代码

然后在C++代码中：

2. #ifdef ENABLE_FEATURE_X
3.     // 特性X的代码
4. #endif

复制代码

路径处理

不同平台使用不同的路径分隔符和约定。CMake提供了路径处理函数来帮助处理这些差异：

2. # 构建路径
3. set(APP_DATA_DIR "${CMAKE_INSTALL_PREFIX}/data")
4. if(WIN32)
5.     set(APP_DATA_DIR "$ENV{APPDATA}/MyApp")
6. elseif(APPLE)
7.     set(APP_DATA_DIR "$ENV{HOME}/Library/Application Support/MyApp")
8. else()
9.     set(APP_DATA_DIR "$ENV{HOME}/.config/MyApp")
10. endif()
12. # 将路径转换为适合当前平台的格式
13. file(TO_NATIVE_PATH "${APP_DATA_DIR}" NATIVE_APP_DATA_DIR)
15. # 添加编译定义
16. target_compile_definitions(my_app PRIVATE APP_DATA_PATH="${NATIVE_APP_DATA_DIR}")

复制代码

依赖管理

查找依赖包

CMake的find_package命令是管理依赖的关键工具。它可以查找系统上安装的库和包：

2. # 查找Qt
3. find_package(Qt6 REQUIRED COMPONENTS Core Widgets Network)
5. # 查找其他库
6. find_package(OpenSSL REQUIRED)
7. find_package(Boost REQUIRED COMPONENTS filesystem system)
9. # 检查是否找到包
10. if(Qt6_FOUND)
11.     message(STATUS "Qt6 found")
12.     target_link_libraries(my_app PRIVATE Qt6::Core Qt6::Widgets Qt6::Network)
13. endif()
15. if(OpenSSL_FOUND)
16.     message(STATUS "OpenSSL found")
17.     target_link_libraries(my_app PRIVATE OpenSSL::SSL OpenSSL::Crypto)
18. endif()
20. if(Boost_FOUND)
21.     message(STATUS "Boost found")
22.     target_link_libraries(my_app PRIVATE Boost::filesystem Boost::system)
23. endif()

复制代码

使用ExternalProject管理外部依赖

有时，您需要构建外部依赖项作为项目的一部分。ExternalProject_Add命令可以帮助您实现这一点：

2. include(ExternalProject)
4. # 添加外部项目
5. ExternalProject_Add(
6.     ext_catch2
7.     GIT_REPOSITORY https://github.com/catchorg/Catch2.git
8.     GIT_TAG v2.13.7
9.     GIT_SHALLOW ON
10.     UPDATE_COMMAND ""
11.     CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${CMAKE_BINARY_DIR}/ext_install
12.                 -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
13.                 -DBUILD_TESTING=OFF
14. )
16. # 创建导入的目标
17. add_library(Catch2::Catch2 IMPORTED INTERFACE)
18. set_target_properties(Catch2::Catch2 PROPERTIES
19.     INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_BINARY_DIR}/ext_install/include"
20. )
22. # 添加依赖关系
23. add_dependencies(Catch2::Catch2 ext_catch2)
25. # 链接到主项目
26. target_link_libraries(my_app PRIVATE Catch2::Catch2)

复制代码

使用FetchContent

CMake 3.11及更高版本提供了FetchContent模块，它是ExternalProject的更简单替代方案：

2. include(FetchContent)
4. # 声明要获取的内容
5. FetchContent_Declare(
6.     catch2
7.     GIT_REPOSITORY https://github.com/catchorg/Catch2.git
8.     GIT_TAG v2.13.7
9. )
11. # 获取内容
12. FetchContent_MakeAvailable(catch2)
14. # 链接到主项目
15. target_link_libraries(my_app PRIVATE Catch2::Catch2)

复制代码

构建配置常见问题及解决方案

调试和发布配置

CMake支持多种构建类型，最常见的是Debug和Release。以下是如何配置这些构建类型：

2. # 设置默认构建类型
3. if(NOT CMAKE_BUILD_TYPE)
4.     set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build." FORCE)
5. endif()
7. # 设置编译器和链接器标志
8. set(CMAKE_CXX_FLAGS_DEBUG "-g -O0")
9. set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG")
11. # 为不同配置设置不同的定义
12. target_compile_definitions(my_app PRIVATE
13.     $<$<CONFIG:Debug>:DEBUG_BUILD>
14.     $<$<CONFIG:Release>:NDEBUG>
15. )

复制代码

构建类型设置

有时，您可能需要为不同的构建类型设置不同的库或标志：

2. # 为Debug构建添加调试库
3. target_link_libraries(my_app PRIVATE
4.     $<$<CONFIG:Debug>:Qt6::CorePrivate>
5.     $<$<CONFIG:Debug>:Qt6::WidgetsPrivate>
6. )
8. # 为特定平台添加库
9. target_link_libraries(my_app PRIVATE
10.     $<$<PLATFORM_ID:Windows>:winmm>
11.     $<$<PLATFORM_ID:Linux>:dl>
12. )

复制代码

构建选项和变量

使用CMake选项可以让用户在配置时自定义构建：

2. # 定义选项
3. option(ENABLE_TESTS "Build tests" ON)
4. option(ENABLE_EXAMPLES "Build examples" ON)
5. option(USE_SYSTEM_LIBS "Use system libraries instead of bundled ones" OFF)
7. # 根据选项添加子目录
8. if(ENABLE_TESTS)
9.     add_subdirectory(tests)
10. endif()
12. if(ENABLE_EXAMPLES)
13.     add_subdirectory(examples)
14. endif()
16. # 根据选项设置变量
17. if(USE_SYSTEM_LIBS)
18.     find_package(SomeLib REQUIRED)
19.     set(SOME_LIB_SOURCE "")
20. else()
21.     add_subdirectory(third_party/somelib)
22.     set(SOME_LIB_SOURCE third_party/somelib)
23. endif()

复制代码

高级技巧

自定义命令和目标

有时，您需要在构建过程中执行自定义命令，如生成代码或文件：

2. # 添加自定义命令以生成版本信息文件
3. add_custom_command(
4.     OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/version.cpp
5.     COMMAND ${CMAKE_COMMAND}
6.         -DPROJECT_VERSION=${PROJECT_VERSION}
7.         -DOUTPUT_FILE=${CMAKE_CURRENT_BINARY_DIR}/version.cpp
8.         -P ${CMAKE_SOURCE_DIR}/cmake/generate_version.cmake
9.     DEPENDS ${CMAKE_SOURCE_DIR}/cmake/generate_version.cmake
10.     VERBATIM
11. )
13. # 将生成的文件添加到源列表
14. target_sources(my_app PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/version.cpp)
16. # 添加自定义目标以运行代码格式化工具
17. add_custom_target(
18.     format
19.     COMMAND clang-format -i src/*.cpp include/*.h
20.     WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
21.     VERBATIM
22. )

复制代码

安装规则

定义安装规则可以让用户使用make install（或cmake --install .）安装您的应用程序：

2. # 安装目标
3. install(TARGETS my_app
4.     RUNTIME DESTINATION bin
5.     LIBRARY DESTINATION lib
6.     ARCHIVE DESTINATION lib
7. )
9. # 安装头文件
10. install(DIRECTORY include/ DESTINATION include)
12. # 安装资源文件
13. install(DIRECTORY resources/ DESTINATION share/my_app/resources)
15. # 安装桌面文件（Linux）
16. if(UNIX AND NOT APPLE)
17.     install(FILES linux/my_app.desktop DESTINATION share/applications)
18.     install(FILES linux/my_app.png DESTINATION share/icons/hicolor/48x48/apps)
19. endif()
21. # 安装macOS bundle
22. if(APPLE)
23.     set_target_properties(my_app PROPERTIES
24.         MACOSX_BUNDLE TRUE
25.         MACOSX_BUNDLE_INFO_PLIST ${CMAKE_SOURCE_DIR}/macos/Info.plist
26.     )
27.     install(TARGETS my_app BUNDLE DESTINATION .)
28. endif()

复制代码

打包和分发

CMake支持使用CPack创建安装程序和分发包：

2. # 包含CPack模块
3. include(InstallRequiredSystemLibraries)
4. include(CPack)
6. # 设置CPack变量
7. set(CPACK_PACKAGE_NAME "MyQtApp")
8. set(CPACK_PACKAGE_VERSION ${PROJECT_VERSION})
9. set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "My Qt Application")
10. set(CPACK_PACKAGE_VENDOR "My Company")
12. # 设置特定于平台的变量
13. if(WIN32)
14.     set(CPACK_GENERATOR "NSIS")
15.     set(CPACK_NSIS_MUI_ICON "${CMAKE_SOURCE_DIR}/windows/app.ico")
16.     set(CPACK_NSIS_MUI_UNIICON "${CMAKE_SOURCE_DIR}/windows/app.ico")
17. elseif(APPLE)
18.     set(CPACK_GENERATOR "DragNDrop")
19. else()
20.     set(CPACK_GENERATOR "DEB;RPM")
21.     set(CPACK_DEBIAN_PACKAGE_MAINTAINER "maintainer@example.com")
22.     set(CPACK_RPM_PACKAGE_MAINTAINER "maintainer@example.com")
23. endif()

复制代码

最佳实践

项目结构建议

良好的项目结构可以提高可维护性和可扩展性。以下是一个推荐的Qt项目结构：

2. my_qt_project/
3. ├── CMakeLists.txt              # 主CMakeLists.txt
4. ├── cmake/                      # CMake辅助文件
5. │   ├── FindSomeLib.cmake       # 自定义查找模块
6. │   └── generate_version.cmake  # 版本生成脚本
7. ├── src/                        # 源代码
8. │   ├── CMakeLists.txt          # src子目录的CMakeLists.txt
9. │   ├── main.cpp
10. │   ├── mainwindow.cpp
11. │   └── mainwindow.h
12. ├── include/                    # 公共头文件
13. │   └── my_app/
14. │       └── mainwindow.h
15. ├── resources/                  # 资源文件
16. │   ├── CMakeLists.txt
17. │   └── icons.qrc
18. ├── tests/                      # 测试
19. │   ├── CMakeLists.txt
20. │   └── test_main.cpp
21. ├── examples/                   # 示例
22. │   ├── CMakeLists.txt
23. │   └── simple_example/
24. ├── docs/                       # 文档
25. ├── packaging/                  # 打包文件
26. │   ├── windows/
27. │   ├── macos/
28. │   └── linux/
29. └── third_party/                # 第三方库
30.     └── somelib/

复制代码

主CMakeLists.txt文件应该简洁明了，主要包含项目设置和全局配置：

2. # 设置CMake最低版本要求
3. cmake_minimum_required(VERSION 3.15)
5. # 项目名称
6. project(MyQtApp VERSION 1.0.0 LANGUAGES CXX)
8. # 设置C++标准
9. set(CMAKE_CXX_STANDARD 17)
10. set(CMAKE_CXX_STANDARD_REQUIRED ON)
12. # 设置输出目录
13. set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
14. set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
15. set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
17. # 添加cmake模块路径
18. list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake)
20. # 选项
21. option(ENABLE_TESTS "Build tests" ON)
22. option(ENABLE_EXAMPLES "Build examples" ON)
23. option(ENABLE_INSTALL "Enable installation targets" ON)
25. # 查找依赖
26. find_package(Qt6 REQUIRED COMPONENTS Core Widgets)
28. # 设置Qt自动化工具
29. set(CMAKE_AUTOMOC ON)
30. set(CMAKE_AUTORCC ON)
31. set(CMAKE_AUTOUIC ON)
33. # 添加子目录
34. add_subdirectory(src)
35. add_subdirectory(resources)
37. if(ENABLE_TESTS)
38.     enable_testing()
39.     add_subdirectory(tests)
40. endif()
42. if(ENABLE_EXAMPLES)
43.     add_subdirectory(examples)
44. endif()
46. if(ENABLE_INSTALL)
47.     include(InstallRequiredSystemLibraries)
48.     include(CPack)
49. endif()

复制代码

可维护性技巧

以下是一些提高CMakeLists.txt文件可维护性的技巧：

1. 使用变量：定义变量来存储常用路径和设置：

2. # 定义项目变量
3. set(MY_APP_NAME "MyQtApp")
4. set(MY_APP_VERSION ${PROJECT_VERSION})
5. set(MY_APP_SOURCES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src)
6. set(MY_APP_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include)
7. set(MY_APP_RESOURCES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/resources)

复制代码

1. 使用函数和宏：封装重复的操作：

2. # 定义函数以添加Qt应用程序
3. function(add_qt_app target_name)
4.     cmake_parse_arguments(ARG "" "" "SOURCES;LIBRARIES" ${ARGN})
6.     # 创建可执行文件
7.     add_executable(${target_name} ${ARG_SOURCES})
9.     # 链接Qt库
10.     target_link_libraries(${target_name} PRIVATE Qt6::Core Qt6::Widgets ${ARG_LIBRARIES})
12.     # 设置属性
13.     set_target_properties(${target_name} PROPERTIES
14.         CXX_STANDARD 17
15.         CXX_STANDARD_REQUIRED ON
16.         AUTOMOC ON
17.         AUTORCC ON
18.         AUTOUIC ON
19.     )
20. endfunction()
22. # 使用函数
23. add_qt_app(my_app
24.     SOURCES
25.         src/main.cpp
26.         src/mainwindow.cpp
27.         src/mainwindow.h
28.         resources/icons.qrc
29.     LIBRARIES
30.         SomeLib::SomeLib
31. )

复制代码

1. 使用目标属性：使用现代CMake的目标属性而不是全局设置：

2. # 不推荐（全局设置）
3. include_directories(include)
4. link_libraries(some_lib)
6. # 推荐（目标特定设置）
7. target_include_directories(my_app PRIVATE include)
8. target_link_libraries(my_app PRIVATE some_lib)

复制代码

1. 使用生成器表达式：使用生成器表达式进行条件设置：

2. # 使用生成器表达式设置条件定义
3. target_compile_definitions(my_app PRIVATE
4.     $<$<PLATFORM_ID:Windows>:WINDOWS_PLATFORM>
5.     $<$<PLATFORM_ID:Linux>:LINUX_PLATFORM>
6.     $<$<PLATFORM_ID:Darwin>:MACOS_PLATFORM>
7.     $<$<CONFIG:Debug>:DEBUG_BUILD>
8.     $<$<CONFIG:Release>:NDEBUG>
9. )

复制代码

性能优化

以下是一些优化CMake构建性能的技巧：

1. 使用CMAKE_DISABLE_SOURCE_CHANGES：防止在源目录中构建：

2. # 检查是否在源目录中构建
3. if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR})
4.     message(FATAL_ERROR "In-source builds are not allowed. Please create a separate build directory.")
5. endif()

复制代码

1. 使用CMAKE_BUILD_PARALLEL_LEVEL：控制并行构建级别：

2. # 设置默认并行级别
3. if(NOT DEFINED CMAKE_BUILD_PARALLEL_LEVEL)
4.     set(CMAKE_BUILD_PARALLEL_LEVEL 4)
5. endif()

复制代码

1. 使用CMAKE_CXX_COMPILER_LAUNCHER：使用编译器启动器（如ccache）加速编译：

2. # 查找ccache
3. find_program(CCACHE_PROGRAM ccache)
4. if(CCACHE_PROGRAM)
5.     message(STATUS "Using ccache: ${CCACHE_PROGRAM}")
6.     set(CMAKE_CXX_COMPILER_LAUNCHER ${CCACHE_PROGRAM})
7. endif()

复制代码

1. 使用预编译头：对于大型项目，使用预编译头可以显著减少编译时间：

2. # 启用预编译头
3. target_precompile_headers(my_app PRIVATE
4.     <algorithm>
5.     <memory>
6.     <string>
7.     <vector>
8.     <QApplication>
9.     <QMainWindow>
10. )

复制代码

总结

CMake和Qt的结合为跨平台开发提供了强大的工具集。通过本文，我们了解了如何使用CMake构建Qt项目，从基础概念到高级技巧，包括跨平台开发、依赖管理和构建配置的解决方案。

关键要点包括：

1. 使用现代CMake实践，如目标属性和生成器表达式，而不是全局设置。
2. 合理组织项目结构，使项目易于维护和扩展。
3. 使用CMake的依赖管理功能，如find_package、ExternalProject和FetchContent。
4. 处理跨平台差异，确保应用程序在不同操作系统上正常工作。
5. 使用CMake的安装和打包功能，简化应用程序的分发。

通过掌握这些技巧，您可以更高效地开发跨平台Qt应用程序，减少构建和配置问题，并提高项目的可维护性。

随着CMake和Qt的不断发展，保持对最新功能和最佳实践的了解也很重要。定期查看官方文档和社区资源，可以帮助您充分利用这些强大的工具。