活动公告

系统通知
通知：微软邮箱更换提醒
06-14 00:00
系统通知
通知：本站资源由网友上传分享，如有违规等问题请到版务模块进行投诉，资源失效请在帖子内回复要求补档，会尽快处理！
10-23 09:31
>社区 > 科技 > 经验交流 >帖子
本版发帖返回

从零开始构建Qt CMake项目完整指南掌握跨平台应用开发核心技巧与最佳实践解决常见配置问题提升开发效率

这是个蓝孩子 当前离线 威震华夏关云长
SunJu_FaceMall

3万

主题

3070

科技点

3万

积分

执行版主

碾压王

积分
32876

塔罗立华奏
执行版主 发表于 2025-10-2 13:10:00 | 显示全部楼层 |阅读模式

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

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

x
1. 引言：Qt与CMake的强大组合

Qt是一个功能强大的跨平台应用程序开发框架，而CMake是一个广泛使用的构建系统生成工具。将两者结合使用，可以为开发者提供一个强大、灵活且跨平台的开发环境。本指南将从零开始，详细介绍如何构建Qt CMake项目，掌握核心技巧与最佳实践，解决常见配置问题，并提升开发效率。

2. 环境准备

2.1 安装Qt

在开始之前，我们需要安装Qt框架。可以从Qt官方网站下载安装程序。

Windows系统：

1. 下载Qt在线安装程序
2. 运行安装程序并选择需要的Qt版本（例如Qt 6.2）
3. 确保选择Qt的对应编译器版本（如MSVC 2019 64-bit）
4. 安装Qt Creator（可选但推荐）

Linux系统（以Ubuntu为例）：
  2. # 添加Qt仓库
  3. sudo add-apt-repository ppa:beineri/opt-qt-6.2-focal
  4. sudo apt update
  6. # 安装Qt 6.2和所需工具
  7. sudo apt install qt6-base-dev qt6-tools-dev cmake build-essential
复制代码

macOS系统：
  2. # 使用Homebrew安装
  3. brew install qt cmake
复制代码

2.2 安装CMake

CMake可以在CMake官方网站下载。

Windows系统：下载安装程序并按照向导完成安装。确保将CMake添加到系统PATH中。

Linux系统：
  2. sudo apt install cmake
复制代码

macOS系统：
  2. brew install cmake
复制代码

2.3 验证安装

打开终端或命令提示符，运行以下命令验证安装：
  2. # 检查Qt版本
  3. qmake --version
  4. # 或
  5. qmake6 --version
  7. # 检查CMake版本
  8. cmake --version
复制代码

3. 创建基本的Qt CMake项目

3.1 项目结构

一个基本的Qt CMake项目通常具有以下结构：
  2. my_qt_app/
  3. ├── CMakeLists.txt
  4. ├── src/
  5. │   ├── main.cpp
  6. │   ├── mainwindow.cpp
  7. │   └── mainwindow.h
  8. └── resources/
  9.     └── my_qt_app.qrc
复制代码

3.2 主CMakeLists.txt文件

创建项目根目录下的CMakeLists.txt文件：
  2. cmake_minimum_required(VERSION 3.16)
  4. # 项目名称
  5. project(MyQtApp VERSION 1.0.0 LANGUAGES CXX)
  7. # 设置C++标准
  8. set(CMAKE_CXX_STANDARD 17)
  9. set(CMAKE_CXX_STANDARD_REQUIRED ON)
  11. # 查找Qt包
  12. find_package(Qt6 REQUIRED COMPONENTS Core Widgets)
  14. # 自动开启Qt的moc、uic和rcc
  15. set(CMAKE_AUTOMOC ON)
  16. set(CMAKE_AUTOUIC ON)
  17. set(CMAKE_AUTORCC ON)
  19. # 添加可执行文件
  20. add_executable(my_qt_app
  21.     src/main.cpp
  22.     src/mainwindow.cpp
  23.     src/mainwindow.h
  24.     resources/my_qt_app.qrc
  25. )
  27. # 链接Qt库
  28. target_link_libraries(my_qt_app PRIVATE Qt6::Core Qt6::Widgets)
复制代码

3.3 主程序文件

创建src/main.cpp文件：
  2. #include <QApplication>
  3. #include "mainwindow.h"
  5. int main(int argc, char *argv[])
  6. {
  7.     QApplication app(argc, argv);
  8.    
  9.     MainWindow window;
  10.     window.show();
  11.    
  12.     return app.exec();
  13. }
复制代码

3.4 主窗口文件

创建src/mainwindow.h文件：
  2. #ifndef MAINWINDOW_H
  3. #define MAINWINDOW_H
  5. #include <QMainWindow>
  7. class MainWindow : public QMainWindow
  8. {
  9.     Q_OBJECT
  11. public:
  12.     MainWindow(QWidget *parent = nullptr);
  13.     ~MainWindow();
  14. };
  16. #endif // MAINWINDOW_H
复制代码

创建src/mainwindow.cpp文件：
  2. #include "mainwindow.h"
  4. MainWindow::MainWindow(QWidget *parent)
  5.     : QMainWindow(parent)
  6. {
  7.     setWindowTitle("My Qt App");
  8.     resize(800, 600);
  9. }
  11. MainWindow::~MainWindow()
  12. {
  13. }
复制代码

3.5 资源文件

创建resources/my_qt_app.qrc文件：
  2. <!DOCTYPE RCC>
  3. <RCC version="1.0">
  4.     <qresource prefix="/">
  5.         <file>images/icon.png</file>
  6.     </qresource>
  7. </RCC>
复制代码

4. 构建和运行项目

4.1 使用命令行构建

创建构建目录并生成构建系统：
  2. mkdir build
  3. cd build
  4. cmake ..
复制代码

构建项目：
  2. # Linux/macOS
  3. make
  5. # Windows
  6. cmake --build . --config Release
复制代码

运行项目：
  2. # Linux/macOS
  3. ./my_qt_app
  5. # Windows
  6. Release/my_qt_app.exe
复制代码

4.2 使用Qt Creator构建

1. 打开Qt Creator
2. 选择”文件” > “打开文件或项目”
3. 选择项目根目录下的CMakeLists.txt文件
4. 配置构建套件（Kit）
5. 点击”构建项目”按钮，然后点击”运行”按钮

5. 高级CMake配置

5.1 设置Qt版本

有时需要指定特定的Qt版本，可以在CMakeLists.txt中添加：
  2. # 设置Qt版本（如果需要）
  3. set(Qt6_DIR "C:/Qt/6.2.4/msvc2019_64/lib/cmake/Qt6")
复制代码

5.2 添加更多Qt模块

如果项目需要其他Qt模块，可以在find_package命令中添加：
  2. find_package(Qt6 REQUIRED COMPONENTS
  3.     Core
  4.     Widgets
  5.     Network
  6.     Sql
  7.     Xml
  8. )
复制代码

然后在target_link_libraries中添加相应的库：
  2. target_link_libraries(my_qt_app PRIVATE
  3.     Qt6::Core
  4.     Qt6::Widgets
  5.     Qt6::Network
  6.     Qt6::Sql
  7.     Qt6::Xml
  8. )
复制代码

5.3 条件编译和平台特定设置

跨平台开发通常需要处理平台差异，CMake提供了条件编译的机制：
  2. # 平台特定设置
  3. if(WIN32)
  4.     # Windows特定设置
  5.     add_definitions(-DUNICODE -D_UNICODE)
  6.     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3")
  7. elseif(UNIX AND NOT APPLE)
  8.     # Linux特定设置
  9.     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
  10. elseif(APPLE)
  11.     # macOS特定设置
  12.     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
  13. endif()
复制代码

5.4 设置应用程序图标

为不同平台设置应用程序图标：
  2. # 设置Windows图标
  3. if(WIN32)
  4.     set(APP_ICON "${CMAKE_SOURCE_DIR}/resources/images/icon.ico")
  5.     set_target_properties(my_qt_app PROPERTIES
  6.         WIN32_EXECUTABLE TRUE
  7.         MACOSX_BUNDLE TRUE
  8.     )
  9. endif()
  11. # 设置macOS图标
  12. if(APPLE)
  13.     set(MACOSX_BUNDLE_ICON_FILE "icon.icns")
  14.     set(APP_ICON "${CMAKE_SOURCE_DIR}/resources/images/icon.icns")
  15.     set_source_files_properties(${APP_ICON} PROPERTIES
  16.         MACOSX_PACKAGE_LOCATION "Resources"
  17.     )
  18. endif()
  20. # 添加图标到可执行文件
  21. if(APP_ICON)
  22.     target_sources(my_qt_app PRIVATE ${APP_ICON})
  23. endif()
复制代码

6. 项目组织最佳实践

6.1 模块化项目结构

对于大型项目，推荐使用模块化的结构：
  2. my_large_qt_app/
  3. ├── CMakeLists.txt
  4. ├── cmake/
  5. │   └── FindSomeDependency.cmake
  6. ├── include/
  7. │   └── myapp/
  8. │       ├── core/
  9. │       ├── gui/
  10. │       └── utils/
  11. ├── src/
  12. │   ├── core/
  13. │   ├── gui/
  14. │   └── utils/
  15. ├── tests/
  16. │   ├── CMakeLists.txt
  17. │   └── test_core/
  18. ├── resources/
  19. │   ├── images/
  20. │   ├── translations/
  21. │   └── styles/
  22. └── third_party/
  23.     └── some_library/
复制代码

6.2 使用CMake子目录

对于模块化项目，可以使用add_subdirectory()命令：
  2. # 主CMakeLists.txt
  3. cmake_minimum_required(VERSION 3.16)
  4. project(MyLargeQtApp VERSION 1.0.0 LANGUAGES CXX)
  6. set(CMAKE_CXX_STANDARD 17)
  7. set(CMAKE_CXX_STANDARD_REQUIRED ON)
  9. # 添加子目录
  10. add_subdirectory(src)
  11. add_subdirectory(tests)
复制代码

然后为每个子模块创建单独的CMakeLists.txt：
  2. # src/CMakeLists.txt
  3. find_package(Qt6 REQUIRED COMPONENTS Core Widgets)
  5. set(CMAKE_AUTOMOC ON)
  6. set(CMAKE_AUTOUIC ON)
  7. set(CMAKE_AUTORCC ON)
  9. # 核心模块
  10. add_subdirectory(core)
  12. # GUI模块
  13. add_subdirectory(gui)
  15. # 工具模块
  16. add_subdirectory(utils)
  18. # 主应用程序
  19. add_executable(my_large_qt_app
  20.     main.cpp
  21. )
  23. target_link_libraries(my_large_qt_app PRIVATE
  24.     core_lib
  25.     gui_lib
  26.     utils_lib
  27.     Qt6::Core
  28.     Qt6::Widgets
  29. )
复制代码

6.3 创建和使用CMake函数和宏

为减少重复代码，可以创建CMake函数和宏：
  2. # 在CMakeLists.txt中定义一个函数来创建Qt应用程序
  3. function(create_qt_app APP_NAME)
  4.     set(options)
  5.     set(oneValueArgs VERSION DESCRIPTION)
  6.     set(multiValueArgs SOURCES RESOURCES LIBS)
  7.     cmake_parse_arguments(CREATE_QT_APP "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
  9.     # 创建可执行文件
  10.     add_executable(${APP_NAME}
  11.         ${CREATE_QT_APP_SOURCES}
  12.         ${CREATE_QT_APP_RESOURCES}
  13.     )
  15.     # 设置版本和描述
  16.     if(CREATE_QT_APP_VERSION)
  17.         set_target_properties(${APP_NAME} PROPERTIES
  18.             VERSION ${CREATE_QT_APP_VERSION}
  19.         )
  20.     endif()
  22.     if(CREATE_QT_APP_DESCRIPTION)
  23.         set_target_properties(${APP_NAME} PROPERTIES
  24.             DESCRIPTION ${CREATE_QT_APP_DESCRIPTION}
  25.         )
  26.     endif()
  28.     # 链接库
  29.     target_link_libraries(${APP_NAME} PRIVATE
  30.         ${CREATE_QT_APP_LIBS}
  31.     )
  32. endfunction()
  34. # 使用函数创建应用程序
  35. create_qt_app(my_qt_app
  36.     VERSION "1.0.0"
  37.     DESCRIPTION "My Qt Application"
  38.     SOURCES
  39.         src/main.cpp
  40.         src/mainwindow.cpp
  41.         src/mainwindow.h
  42.     RESOURCES
  43.         resources/my_qt_app.qrc
  44.     LIBS
  45.         Qt6::Core
  46.         Qt6::Widgets
  47. )
复制代码

7. 跨平台开发技巧

7.1 处理路径差异

不同平台使用不同的路径分隔符，Qt提供了QDir和QFile类来处理这些差异：
  2. #include <QDir>
  3. #include <QFile>
  5. // 跨平台路径拼接
  6. QString configPath = QDir::homePath() + QDir::separator() + ".myapp" + QDir::separator() + "config.ini";
  8. // 使用QFile处理文件
  9. QFile configFile(configPath);
  10. if (configFile.exists()) {
  11.     // 文件存在，读取配置
  12. } else {
  13.     // 文件不存在，创建默认配置
  14. }
复制代码

7.2 处理文件系统差异

不同平台对文件系统的处理也有所不同：
  2. #include <QStandardPaths>
  4. // 获取跨平台标准路径
  5. QString appDataPath = QStandardPaths::writableLocation(QStandardPaths::AppDataLocation);
  7. // 确保目录存在
  8. QDir dir(appDataPath);
  9. if (!dir.exists()) {
  10.     dir.mkpath(".");
  11. }
复制代码

7.3 处理UI差异

不同平台的UI风格和习惯不同，可以使用Qt的样式表和布局来适应：
  2. // 设置跨平台样式
  3. #ifdef Q_OS_WIN
  4.     QApplication::setStyle("Fusion");
  5. #endif
  7. // 使用布局而不是固定位置
  8. QVBoxLayout *layout = new QVBoxLayout;
  9. layout->addWidget(button1);
  10. layout->addWidget(button2);
  11. setLayout(layout);
复制代码

8. 常见配置问题及解决方案

8.1 Qt版本不匹配问题

问题：系统中安装了多个Qt版本，CMake找到了错误的版本。

解决方案：明确指定Qt路径：
  2. # 在CMakeLists.txt中明确指定Qt路径
  3. set(Qt6_DIR "C:/Qt/6.2.4/msvc2019_64/lib/cmake/Qt6")
复制代码

或者在命令行中指定：
  2. cmake -DQt6_DIR="C:/Qt/6.2.4/msvc2019_64/lib/cmake/Qt6" ..
复制代码

8.2 找不到Qt模块问题

问题：CMake报告找不到所需的Qt模块。

解决方案：确保在find_package中列出了所有需要的组件：
  2. find_package(Qt6 REQUIRED COMPONENTS Core Widgets Network Sql Xml)
复制代码

如果仍然找不到，可能需要安装相应的Qt模块。

8.3 编译器不匹配问题

问题：Qt和项目使用不同的编译器编译。

解决方案：确保使用与Qt版本匹配的编译器：
  2. # 指定编译器
  3. set(CMAKE_CXX_COMPILER "cl.exe")  # Windows MSVC
  4. # 或
  5. set(CMAKE_CXX_COMPILER "g++")     # GCC
  6. # 或
  7. set(CMAKE_CXX_COMPILER "clang++") # Clang
复制代码

8.4 链接错误问题

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

解决方案：确保所有需要的库都已正确链接：
  2. target_link_libraries(my_qt_app PRIVATE
  3.     Qt6::Core
  4.     Qt6::Widgets
  5.     # 添加其他需要的库
  6. )
复制代码

8.5 资源文件问题

问题：资源文件（如图像、翻译等）未正确包含在可执行文件中。

解决方案：确保资源文件已添加到项目中，并且.qrc文件已正确配置：
  2. # 确保AUTORCC已开启
  3. set(CMAKE_AUTORCC ON)
  5. # 添加资源文件
  6. add_executable(my_qt_app
  7.     main.cpp
  8.     mainwindow.cpp
  9.     mainwindow.h
  10.     resources/my_qt_app.qrc  # 确保包含.qrc文件
  11. )
复制代码

9. 提升开发效率的技巧

9.1 使用CMake预设

CMake 3.20+支持预设文件（CMakePresets.json），可以简化构建配置：
  2. {
  3.   "version": 2,
  4.   "configurePresets": [
  5.     {
  6.       "name": "windows-debug",
  7.       "displayName": "Windows Debug",
  8.       "generator": "Ninja",
  9.       "binaryDir": "${sourceDir}/build/debug",
  10.       "cacheVariables": {
  11.         "CMAKE_BUILD_TYPE": "Debug",
  12.         "CMAKE_PREFIX_PATH": "C:/Qt/6.2.4/msvc2019_64"
  13.       }
  14.     },
  15.     {
  16.       "name": "windows-release",
  17.       "displayName": "Windows Release",
  18.       "generator": "Ninja",
  19.       "binaryDir": "${sourceDir}/build/release",
  20.       "cacheVariables": {
  21.         "CMAKE_BUILD_TYPE": "Release",
  22.         "CMAKE_PREFIX_PATH": "C:/Qt/6.2.4/msvc2019_64"
  23.       }
  24.     }
  25.   ]
  26. }
复制代码

使用预设配置项目：
  2. cmake --preset windows-debug
  3. cmake --build --preset windows-debug
复制代码

9.2 使用CMake工具文件

CMake工具文件（Toolchain files）可以简化跨平台编译：
  2. # windows-msvc.cmake
  3. set(CMAKE_C_COMPILER cl.exe)
  4. set(CMAKE_CXX_COMPILER cl.exe)
  5. set(CMAKE_PREFIX_PATH "C:/Qt/6.2.4/msvc2019_64")
复制代码

使用工具文件配置项目：
  2. cmake -DCMAKE_TOOLCHAIN_FILE=windows-msvc.cmake ..
复制代码

9.3 使用CMake的包管理功能

CMake 3.11+引入了FetchContent模块，可以直接从Git仓库获取依赖：
  2. include(FetchContent)
  4. FetchContent_Declare(
  5.     some_dependency
  6.     GIT_REPOSITORY https://github.com/user/some_dependency.git
  7.     GIT_TAG v1.0.0
  8. )
  10. FetchContent_MakeAvailable(some_dependency)
  12. target_link_libraries(my_qt_app PRIVATE some_dependency)
复制代码

9.4 使用C++20模块（如果编译器支持）

如果你的编译器支持C++20模块，可以使用它们来加速编译：
  2. // mymodule.ixx
  3. export module mymodule;
  5. import <QtWidgets/QWidget>;
  7. export class MyWidget : public QWidget {
  8.     Q_OBJECT
  9. public:
  10.     MyWidget(QWidget *parent = nullptr);
  11. };
复制代码

然后在CMake中启用C++20模块：
  2. set(CMAKE_CXX_STANDARD 20)
  3. set(CMAKE_CXX_STANDARD_REQUIRED ON)
  4. set(CMAKE_CXX_EXTENSIONS OFF)
  6. # 启用C++模块实验性支持
  7. if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
  8.     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fmodules-ts")
  9. endif()
复制代码

9.5 使用预编译头

对于大型项目，使用预编译头可以显著减少编译时间：
  2. # 创建预编译头
  3. target_precompile_headers(my_qt_app PRIVATE
  4.     <QtWidgets/QApplication>
  5.     <QtWidgets/QMainWindow>
  6.     "src/pch.h"
  7. )
复制代码

创建src/pch.h文件：
  2. #ifndef PCH_H
  3. #define PCH_H
  5. // 常用Qt头文件
  6. #include <QtWidgets/QApplication>
  7. #include <QtWidgets/QMainWindow>
  8. #include <QtWidgets/QWidget>
  9. #include <QtWidgets/QPushButton>
  10. #include <QtWidgets/QVBoxLayout>
  11. #include <QtWidgets/QHBoxLayout>
  13. // 标准库头文件
  14. #include <memory>
  15. #include <vector>
  16. #include <string>
  18. #endif // PCH_H
复制代码

10. 部署和分发

10.1 Windows部署

在Windows上，可以使用windeployqt工具来收集Qt依赖：
  2. # 添加自定义目标来运行windeployqt
  3. add_custom_command(TARGET my_qt_app POST_BUILD
  4.     COMMAND ${CMAKE_COMMAND} -E copy_if_different
  5.         $<TARGET_FILE:my_qt_app>
  6.         ${CMAKE_BINARY_DIR}/package/$<TARGET_FILE_NAME:my_qt_app>
  7. )
  9. add_custom_target(deploy
  10.     COMMAND ${Qt6_DIR}/../../../bin/windeployqt.exe
  11.         ${CMAKE_BINARY_DIR}/package/$<TARGET_FILE_NAME:my_qt_app>
  12.     DEPENDS my_qt_app
  13.     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/package
  14. )
复制代码

10.2 Linux部署

在Linux上，可以使用LinuxDeployQt或AppImage：
  2. # 添加自定义目标来创建AppImage
  3. add_custom_target(package
  4.     COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_BINARY_DIR}/AppImage/usr/bin
  5.     COMMAND ${CMAKE_COMMAND} -E copy_if_different
  6.         $<TARGET_FILE:my_qt_app>
  7.         ${CMAKE_BINARY_DIR}/AppImage/usr/bin/
  8.     COMMAND linuxdeployqt
  9.         ${CMAKE_BINARY_DIR}/AppImage/usr/bin/my_qt_app
  10.         -appimage
  11.     DEPENDS my_qt_app
  12.     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
  13. )
复制代码

10.3 macOS部署

在macOS上，可以创建应用程序包：
  2. # 设置macOS应用程序包属性
  3. set_target_properties(my_qt_app PROPERTIES
  4.     MACOSX_BUNDLE TRUE
  5.     MACOSX_BUNDLE_INFO_PLIST ${CMAKE_SOURCE_DIR}/cmake/Info.plist.in
  6.     MACOSX_BUNDLE_GUI_IDENTIFIER "com.mycompany.myapp"
  7.     MACOSX_BUNDLE_BUNDLE_VERSION ${PROJECT_VERSION}
  8.     MACOSX_BUNDLE_SHORT_VERSION_STRING ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}
  9.     MACOSX_BUNDLE_COPYRIGHT "Copyright © 2023 My Company. All rights reserved."
  10. )
  12. # 添加自定义目标来运行macdeployqt
  13. add_custom_target(deploy
  14.     COMMAND ${Qt6_DIR}/../../../bin/macdeployqt
  15.         ${CMAKE_BINARY_DIR}/my_qt_app.app
  16.         -dmg
  17.     DEPENDS my_qt_app
  18.     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
  19. )
复制代码

11. 持续集成/持续部署（CI/CD）

11.1 GitHub Actions示例

创建.github/workflows/build.yml文件：
  2. name: Build
  4. on: [push, pull_request]
  6. jobs:
  7.   build:
  8.     strategy:
  9.       matrix:
  10.         os: [ubuntu-latest, windows-latest, macos-latest]
  11.         qt-version: [6.2.4]
  12.         include:
  13.           - os: ubuntu-latest
  14.             qt-arch: gcc_64
  15.           - os: windows-latest
  16.             qt-arch: win64_msvc2019_64
  17.           - os: macos-latest
  18.             qt-arch: clang_64
  20.     runs-on: ${{ matrix.os }}
  22.     steps:
  23.     - uses: actions/checkout@v2
  25.     - name: Install Qt
  26.       uses: jurplel/install-qt-action@v2
  27.       with:
  28.         version: ${{ matrix.qt-version }}
  29.         arch: ${{ matrix.qt-arch }}
  31.     - name: Configure (Windows)
  32.       if: runner.os == 'Windows'
  33.       run: cmake -B build -G "Visual Studio 16 2019" -A x64
  35.     - name: Configure (Unix)
  36.       if: runner.os != 'Windows'
  37.       run: cmake -B build
  39.     - name: Build
  40.       run: cmake --build build --config Release
  42.     - name: Test
  43.       run: cd build && ctest -C Release
  45.     - name: Package
  46.       run: cmake --build build --target deploy
复制代码

11.2 GitLab CI示例

创建.gitlab-ci.yml文件：
  2. stages:
  3.   - build
  4.   - test
  5.   - deploy
  7. variables:
  8.   QT_VERSION: "6.2.4"
  10. build:windows:
  11.   stage: build
  12.   tags:
  13.     - windows
  14.   script:
  15.     - cmake -B build -G "Visual Studio 16 2019" -A x64
  16.     - cmake --build build --config Release
  17.   artifacts:
  18.     paths:
  19.       - build/
  21. build:linux:
  22.   stage: build
  23.   tags:
  24.     - linux
  25.   script:
  26.     - cmake -B build
  27.     - cmake --build build --config Release
  28.   artifacts:
  29.     paths:
  30.       - build/
  32. build:macos:
  33.   stage: build
  34.   tags:
  35.     - macos
  36.   script:
  37.     - cmake -B build
  38.     - cmake --build build --config Release
  39.   artifacts:
  40.     paths:
  41.       - build/
  43. test:
  44.   stage: test
  45.   script:
  46.     - cd build
  47.     - ctest -C Release
  48.   dependencies:
  49.     - build:windows
  50.     - build:linux
  51.     - build:macos
  53. deploy:
  54.   stage: deploy
  55.   script:
  56.     - cmake --build build --target deploy
  57.   artifacts:
  58.     paths:
  59.       - build/package/
  60.   only:
  61.     - main
复制代码

12. 总结

本指南详细介绍了如何从零开始构建Qt CMake项目，包括环境设置、基本项目创建、高级配置、跨平台开发技巧、常见问题解决方案以及效率提升技巧。通过掌握这些核心技巧和最佳实践，你可以更高效地开发跨平台Qt应用程序。

记住，良好的项目结构和构建系统是成功项目的基石。使用CMake管理Qt项目不仅提供了跨平台兼容性，还简化了依赖管理和构建过程，使你能够专注于应用程序的核心功能开发。

随着项目的增长，不断优化和调整你的构建系统，采用自动化测试和部署流程，这将大大提高开发效率和软件质量。希望本指南能帮助你在Qt CMake开发的道路上取得成功！
跨平台
「七転び八起き（ななころびやおき）」
回复

使用道具 举报

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

本版积分规则