基于Qt C++的系统资源监控工具开发实战：从原理到实现

在实际 C++ 课程设计或毕业设计中，开发一个具备实用价值的桌面应用程序是检验综合能力的重要方式。一个系统资源监控工具，不仅能够直观展示 CPU、内存、磁盘和网络等核心硬件资源的使用情况，还能深入涉及多线程编程、GUI 设计、系统 API 调用以及数据可视化等多个关键技术点。对于学习 Qt 和 C++ 的同学而言，这是一个综合性极强、代码结构清晰且最终成果可视化的优秀选题。本文将带你从零开始，使用 Qt C++ 框架，构建一个功能完整的系统资源监控工具。你将学习到如何获取系统性能数据、如何设计实时更新的图表界面、如何处理多线程以避免界面卡顿，以及如何打包发布你的应用程序。完成后的项目可直接用于课程设计或大作业提交，并具备进一步扩展为更专业工具的基础。

1. 理解系统资源监控的核心机制与 Qt 的角色

在动手编码之前，必须理清两个核心问题：一是应用程序如何获取操作系统的资源使用数据；二是 Qt 框架在其中扮演什么角色，如何将数据转化为可视化的界面。

1.1 操作系统资源数据的获取途径

系统资源数据，如 CPU 使用率、内存占用、磁盘 I/O、网络流量等，通常由操作系统内核维护。在 Windows 和 Linux 上，获取这些数据的底层 API 完全不同。

• Windows 平台：主要依靠 Windows Management Instrumentation (WMI) 或 Performance Data Helper (PDH) API。WMI 功能强大但接口复杂；PDH 相对直接，是性能监视器的底层接口。对于 C++ 项目，可以直接调用这些原生 API，但更常见的做法是使用Windows.h头文件中的特定函数，或解析系统命令（如wmic、typeperf）的输出。在 Qt 项目中，我们通常使用QProcess来执行这些命令并解析结果，这种方式跨版本兼容性较好，但效率略低。
• Linux 平台：数据主要来源于/proc虚拟文件系统。这是一个内核信息的映射，以文本文件形式存在。例如：
  • CPU 信息：/proc/stat
  • 内存信息：/proc/meminfo
  • 进程信息：/proc/[pid]/stat
  • 网络信息：/proc/net/dev通过定时读取并解析这些文件，即可计算出各项资源的使用率。这种方法高效且直接。

因此，一个跨平台的资源监控工具，需要为不同操作系统编写特定的数据获取模块。在本项目中，为了简化并专注于 Qt 和核心逻辑，我们将主要实现Linux平台的功能，并在关键部分指出 Windows 实现的差异点。你可以将此作为练习，后续自行补充 Windows 版本。

1.2 Qt 框架在项目中的分工

Qt 不仅仅是一个 GUI 库。在本项目中，它将承担以下关键角色：

1. 图形用户界面 (GUI)：使用QWidgets或QML创建窗口、标签、进度条和图表。我们将使用QChart模块来绘制动态更新的折线图或饼图，直观展示资源使用历史趋势。
2. 定时器与事件循环：使用QTimer定期触发数据采集和界面更新，这是实现“实时监控”的核心。
3. 多线程：数据采集（尤其是涉及文件 I/O 或命令执行）是阻塞操作。如果放在主线程（GUI 线程）中执行，会导致界面冻结。必须使用QThread或QtConcurrent将耗时的数据采集工作放在后台线程。
4. 信号与槽机制：这是 Qt 的核心通信机制。后台线程获取到数据后，通过发射信号，将数据安全地传递到主线程，主线程的槽函数接收到信号后更新 UI。这保证了线程安全。
5. 文件与进程操作：使用QFile和QTextStream读取 Linux 的/proc文件；使用QProcess执行系统命令（在 Windows 方案或获取特定信息时使用）。

理解了这些，我们就明确了项目的技术栈：C++ 用于核心逻辑和系统 API 调用，Qt 用于构建响应式、可视化的应用程序框架。

2. 环境准备与项目创建

在开始编码前，需要搭建一个可用的 Qt C++ 开发环境。

2.1 安装 Qt 开发环境

1. 下载 Qt：访问 Qt 官网，下载 Qt Online Installer。建议选择Qt 5.15 LTS或更高版本，因为 LTS 版本长期支持，社区资源丰富。安装时，请确保勾选以下组件：

   • Qt 5.15.x(或你选择的版本) 下的Desktop gcc 64-bit(Linux) 或MSVC 2019 64-bit(Windows)。
   • Qt Charts：这是绘制图表所必需的模块。
   • Qt Creator：这是 Qt 官方的集成开发环境 (IDE)，对 Qt 项目支持最好。

2. 配置编译器：

   • Linux (Ubuntu/Debian)：确保已安装 GCC/G++ 和构建工具。

     sudo apt update sudo apt install build-essential

   • Windows：如果你选择了 MSVC 组件，通常需要对应版本的 Visual Studio Build Tools 或 Visual Studio IDE。如果遇到错误error: microsoft visual c++ 14.0 or greater is required，你需要安装对应版本的 Visual C++ Redistributable 和 Build Tools。一个更简单的选择是在安装 Qt 时选择MinGW套件，它自带了 GCC 编译器。

3. 验证安装：打开 Qt Creator，创建一个新的Qt Widgets Application项目，编译并运行默认的空白窗口程序。如果能成功运行，说明环境配置正确。

2.2 创建项目并配置依赖

1. 新建项目：在 Qt Creator 中，选择File->New File or Project->Application->Qt Widgets Application。为项目命名，例如SystemMonitor。
2. 配置项目文件 (.pro)：Qt 使用.pro文件管理项目配置。打开项目根目录下的.pro文件，我们需要添加charts模块。

   # SystemMonitor.pro QT += core gui charts # 添加 charts 模块 greaterThan(QT_MAJOR_VERSION, 4): QT += widgets CONFIG += c++17 # ... 其他默认配置

   添加charts后，才能在代码中使用QChart,QChartView,QSplineSeries等类。
3. 项目结构规划：一个清晰的项目结构有助于管理代码。建议创建如下目录和文件：

   SystemMonitor/ ├── SystemMonitor.pro # 项目配置文件 ├── main.cpp # 程序入口 ├── mainwindow.h # 主窗口头文件 ├── mainwindow.cpp # 主窗口实现文件 ├── resourcemonitor.h # 资源监控器头文件（核心数据获取类） ├── resourcemonitor.cpp # 资源监控器实现文件 ├── chartwidget.h # 自定义图表控件头文件 └── chartwidget.cpp # 自定义图表控件实现文件

3. 实现系统资源数据采集模块

这是项目的核心引擎，负责与操作系统交互，获取原始数据并计算出我们需要的指标。

3.1 设计 ResourceMonitor 类

我们创建一个ResourceMonitor类，它继承自QObject，以便能够使用信号与槽。这个类将运行在独立的线程中。

resourcemonitor.h

#ifndef RESOURCEMONITOR_H #define RESOURCEMONITOR_H #include <QObject> #include <QTimer> // 定义一个结构体来封装一次采集的所有资源数据 struct SystemUsage { double cpuPercent; // CPU总使用率 (%) double memoryPercent; // 内存使用率 (%) qint64 memoryUsed; // 已用内存 (KB) qint64 memoryTotal; // 总内存 (KB) // 可以后续扩展：磁盘读写、网络流量等 }; class ResourceMonitor : public QObject { Q_OBJECT public: explicit ResourceMonitor(QObject *parent = nullptr); ~ResourceMonitor(); void startMonitoring(int intervalMs = 1000); // 开始监控，指定采样间隔 void stopMonitoring(); // 停止监控 signals: // 定义一个信号，每次采集到新数据时就发射，携带SystemUsage数据 void dataUpdated(const SystemUsage &usage); private slots: void updateData(); // 定时触发的数据更新槽函数 private: // 具体的资源获取函数（针对Linux /proc实现） double getCpuUsage(); SystemUsage getMemoryUsage(); // 辅助函数：解析/proc/stat和/proc/meminfo void parseProcStat(QVector<unsigned long long> &cpuTimes); unsigned long long getMemInfoValue(const QString &key); QTimer *m_timer; QVector<unsigned long long> m_prevCpuTimes; // 保存上一次CPU时间，用于计算使用率 bool m_isRunning; }; #endif // RESOURCEMONITOR_H

3.2 实现 Linux 下的数据采集逻辑

resourcemonitor.cpp(关键部分)

#include "resourcemonitor.h" #include <QFile> #include <QTextStream> #include <QDebug> #include <QThread> ResourceMonitor::ResourceMonitor(QObject *parent) : QObject(parent), m_isRunning(false) { m_timer = new QTimer(this); connect(m_timer, &QTimer::timeout, this, &ResourceMonitor::updateData); // 初始化CPU时间 m_prevCpuTimes.resize(10); // 通常/proc/stat cpu行有10个字段 parseProcStat(m_prevCpuTimes); } void ResourceMonitor::startMonitoring(int intervalMs) { if (m_isRunning) return; m_timer->start(intervalMs); m_isRunning = true; qDebug() << "Resource monitoring started with interval" << intervalMs << "ms"; } void ResourceMonitor::stopMonitoring() { m_timer->stop(); m_isRunning = false; } void ResourceMonitor::updateData() { SystemUsage usage; usage.cpuPercent = getCpuUsage(); SystemUsage memUsage = getMemoryUsage(); usage.memoryPercent = memUsage.memoryPercent; usage.memoryUsed = memUsage.memoryUsed; usage.memoryTotal = memUsage.memoryTotal; // 发射信号，通知主界面数据已更新 emit dataUpdated(usage); } // 核心：计算CPU总使用率 double ResourceMonitor::getCpuUsage() { QVector<unsigned long long> currentCpuTimes(10); parseProcStat(currentCpuTimes); // 计算总时间差和空闲时间差（注意：不同内核版本/proc/stat字段顺序可能不同，此处是常见顺序） // 字段含义：user, nice, system, idle, iowait, irq, softirq, steal, guest, guest_nice unsigned long long prevIdle = m_prevCpuTimes[3] + m_prevCpuTimes[4]; // idle + iowait unsigned long long currentIdle = currentCpuTimes[3] + currentCpuTimes[4]; unsigned long long prevTotal = 0; unsigned long long currentTotal = 0; for (int i = 0; i < 10; ++i) { prevTotal += m_prevCpuTimes[i]; currentTotal += currentCpuTimes[i]; } unsigned long long totalDiff = currentTotal - prevTotal; unsigned long long idleDiff = currentIdle - prevIdle; m_prevCpuTimes = currentCpuTimes; // 更新历史数据 if (totalDiff == 0) return 0.0; // CPU使用率 = (总时间 - 空闲时间) / 总时间 * 100% return ((totalDiff - idleDiff) * 100.0) / totalDiff; } // 解析 /proc/stat 文件，获取CPU时间信息 void ResourceMonitor::parseProcStat(QVector<unsigned long long> &cpuTimes) { QFile file("/proc/stat"); if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) { qWarning() << "Failed to open /proc/stat"; return; } QTextStream in(&file); QString line = in.readLine(); // 读取第一行，即总的cpu信息 QStringList list = line.split(' ', Qt::SkipEmptyParts); if (list[0] != "cpu") { qWarning() << "Unexpected format in /proc/stat"; file.close(); return; } // 从第1个字段开始（跳过"cpu"），读取10个时间值 for (int i = 1; i <= 10 && i < list.size(); ++i) { cpuTimes[i-1] = list[i].toULongLong(); } file.close(); } // 获取内存使用信息 SystemUsage ResourceMonitor::getMemoryUsage() { SystemUsage usage; usage.memoryTotal = getMemInfoValue("MemTotal"); usage.memoryUsed = usage.memoryTotal - getMemInfoValue("MemAvailable"); // MemAvailable更准确反映可用内存（Linux 3.14+） // 如果MemAvailable不存在（旧内核），则使用 MemFree + Buffers + Cached 估算 if (usage.memoryUsed < 0) { unsigned long long memFree = getMemInfoValue("MemFree"); unsigned long long buffers = getMemInfoValue("Buffers"); unsigned long long cached = getMemInfoValue("Cached"); usage.memoryUsed = usage.memoryTotal - (memFree + buffers + cached); } if (usage.memoryTotal > 0) { usage.memoryPercent = (usage.memoryUsed * 100.0) / usage.memoryTotal; } else { usage.memoryPercent = 0.0; } return usage; } // 辅助函数：从 /proc/meminfo 中根据关键字提取数值（单位KB） unsigned long long ResourceMonitor::getMemInfoValue(const QString &key) { QFile file("/proc/meminfo"); if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) { qWarning() << "Failed to open /proc/meminfo"; return 0; } QTextStream in(&file); while (!in.atEnd()) { QString line = in.readLine(); if (line.startsWith(key)) { QStringList list = line.split(' ', Qt::SkipEmptyParts); if (list.size() >= 2) { file.close(); return list[1].toULongLong(); } } } file.close(); return 0; }

注意：/proc文件系统的解析依赖于内核版本和具体字段顺序。上述代码在大多数现代 Linux 发行版（如 Ubuntu 20.04+， CentOS 7+）上应能正常工作。在生产环境中，需要增加更健壮的异常处理和格式校验。

4. 构建实时数据可视化界面

数据获取是后台工作，我们需要一个美观的前台界面来展示它。我们将使用QChart来绘制动态曲线图，并用QLabel和QProgressBar显示实时数值。

4.1 设计主窗口布局

mainwindow.h

#ifndef MAINWINDOW_H #define MAINWINDOW_H #include <QMainWindow> #include <QChartView> #include <QSplineSeries> #include <QValueAxis> #include <QTimer> #include <QLabel> #include <QProgressBar> QT_CHARTS_USE_NAMESPACE // 使用Qt Charts命名空间 // 前向声明，避免头文件相互包含 class ResourceMonitor; class QThread; class MainWindow : public QMainWindow { Q_OBJECT public: MainWindow(QWidget *parent = nullptr); ~MainWindow(); private slots: void onDataUpdated(double cpuUsage, double memUsage, qint64 memUsed, qint64 memTotal); void updateCharts(); private: void setupUI(); void setupCharts(); // 监控器与线程 ResourceMonitor *m_monitor; QThread *m_workerThread; // UI 组件 QLabel *m_labelCpu; QLabel *m_labelMem; QProgressBar *m_progressCpu; QProgressBar *m_progressMem; QChartView *m_chartViewCpu; QChartView *m_chartViewMem; // 图表相关 QChart *m_chartCpu; QChart *m_chartMem; QSplineSeries *m_seriesCpu; QSplineSeries *m_seriesMem; QValueAxis *m_axisX; QValueAxis *m_axisYCpu; QValueAxis *m_axisYMem; // 数据记录 QVector<QPointF> m_cpuData; QVector<QPointF> m_memData; int m_dataMaxPoints; // 图表上最多显示的数据点数 int m_pointCounter; }; #endif // MAINWINDOW_H

4.2 实现主窗口逻辑与图表更新

mainwindow.cpp(核心部分)

#include "mainwindow.h" #include "resourcemonitor.h" #include <QVBoxLayout> #include <QHBoxLayout> #include <QGroupBox> #include <QFormLayout> #include <QDebug> MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), m_pointCounter(0), m_dataMaxPoints(60) { // 默认显示60个点（1分钟数据，每秒1点） setupUI(); setupCharts(); // 创建监控器和工作线程 m_monitor = new ResourceMonitor(); m_workerThread = new QThread(this); m_monitor->moveToThread(m_workerThread); // 将监控器对象移到新线程 // 连接信号与槽 // 注意：ResourceMonitor的dataUpdated信号参数是SystemUsage结构体，需要适配 // 这里使用lambda表达式进行转换 connect(m_monitor, &ResourceMonitor::dataUpdated, this, [this](const SystemUsage &usage){ onDataUpdated(usage.cpuPercent, usage.memoryPercent, usage.memoryUsed, usage.memoryTotal); }); // 启动工作线程 m_workerThread->start(); // 在线程中启动监控（通过QueuedConnection确保在正确线程调用） QMetaObject::invokeMethod(m_monitor, [this](){ m_monitor->startMonitoring(1000); // 每秒采样一次 }, Qt::QueuedConnection); // 设置一个更快的定时器用于平滑更新图表（例如每200ms） QTimer *chartUpdateTimer = new QTimer(this); connect(chartUpdateTimer, &QTimer::timeout, this, &MainWindow::updateCharts); chartUpdateTimer->start(200); // UI刷新可以比数据采样更快，使曲线更平滑 } MainWindow::~MainWindow() { m_monitor->stopMonitoring(); m_workerThread->quit(); m_workerThread->wait(); // 等待线程结束 delete m_monitor; } void MainWindow::setupUI() { QWidget *centralWidget = new QWidget(this); setCentralWidget(centralWidget); QVBoxLayout *mainLayout = new QVBoxLayout(centralWidget); // 上半部分：实时数值显示 QGroupBox *infoGroup = new QGroupBox("实时资源使用率", this); QFormLayout *formLayout = new QFormLayout(infoGroup); m_labelCpu = new QLabel("0.0%", this); m_progressCpu = new QProgressBar(this); m_progressCpu->setRange(0, 100); m_progressCpu->setTextVisible(true); formLayout->addRow("CPU 使用率:", m_labelCpu); formLayout->addRow(m_progressCpu); m_labelMem = new QLabel("0.0% (0K / 0K)", this); m_progressMem = new QProgressBar(this); m_progressMem->setRange(0, 100); m_progressMem->setTextVisible(true); formLayout->addRow("内存 使用率:", m_labelMem); formLayout->addRow(m_progressMem); mainLayout->addWidget(infoGroup); // 下半部分：图表显示 QGroupBox *chartGroup = new QGroupBox("历史趋势", this); QVBoxLayout *chartLayout = new QVBoxLayout(chartGroup); m_chartViewCpu = new QChartView(this); m_chartViewMem = new QChartView(this); chartLayout->addWidget(m_chartViewCpu); chartLayout->addWidget(m_chartViewMem); mainLayout->addWidget(chartGroup); resize(800, 600); } void MainWindow::setupCharts() { // CPU 图表 m_chartCpu = new QChart(); m_seriesCpu = new QSplineSeries(); m_seriesCpu->setName("CPU Usage (%)"); m_chartCpu->addSeries(m_seriesCpu); m_chartCpu->setTitle("CPU 使用率历史"); m_chartCpu->createDefaultAxes(); m_axisX = qobject_cast<QValueAxis*>(m_chartCpu->axes(Qt::Horizontal).first()); m_axisYCpu = qobject_cast<QValueAxis*>(m_chartCpu->axes(Qt::Vertical).first()); m_axisYCpu->setRange(0, 100); m_axisYCpu->setTitleText("百分比 (%)"); m_chartCpu->legend()->setVisible(true); m_chartCpu->legend()->setAlignment(Qt::AlignBottom); m_chartViewCpu->setChart(m_chartCpu); m_chartViewCpu->setRenderHint(QPainter::Antialiasing); // 内存图表 m_chartMem = new QChart(); m_seriesMem = new QSplineSeries(); m_seriesMem->setName("Memory Usage (%)"); m_chartMem->addSeries(m_seriesMem); m_chartMem->setTitle("内存 使用率历史"); m_chartMem->createDefaultAxes(); m_axisYMem = qobject_cast<QValueAxis*>(m_chartMem->axes(Qt::Vertical).first()); m_axisYMem->setRange(0, 100); m_axisYMem->setTitleText("百分比 (%)"); m_chartMem->legend()->setVisible(true); m_chartMem->legend()->setAlignment(Qt::AlignBottom); m_chartViewMem->setChart(m_chartMem); m_chartViewMem->setRenderHint(QPainter::Antialiasing); } // 槽函数：接收来自ResourceMonitor的更新数据 void MainWindow::onDataUpdated(double cpuUsage, double memUsage, qint64 memUsed, qint64 memTotal) { // 更新标签和进度条 m_labelCpu->setText(QString::asprintf("%.1f%%", cpuUsage)); m_progressCpu->setValue(static_cast<int>(cpuUsage)); QString memText = QString::asprintf("%.1f%% (%1Ld MB / %2Ld MB)", memUsage, memUsed / 1024, // KB -> MB memTotal / 1024); m_labelMem->setText(memText); m_progressMem->setValue(static_cast<int>(memUsage)); // 记录数据点 m_cpuData.append(QPointF(m_pointCounter, cpuUsage)); m_memData.append(QPointF(m_pointCounter, memUsage)); m_pointCounter++; // 限制数据点数量，保持图表清晰 if (m_cpuData.size() > m_dataMaxPoints) { m_cpuData.removeFirst(); m_memData.removeFirst(); // 需要更新X轴范围，实现滚动效果 if (m_axisX) { m_axisX->setRange(m_pointCounter - m_dataMaxPoints, m_pointCounter); } } } // 定时更新图表曲线（在主线程中安全执行） void MainWindow::updateCharts() { if (m_cpuData.isEmpty()) return; m_seriesCpu->replace(m_cpuData); m_seriesMem->replace(m_memData); }

main.cpp保持默认即可：

#include "mainwindow.h" #include <QApplication> int main(int argc, char *argv[]) { QApplication a(argc, argv); MainWindow w; w.show(); return a.exec(); }

5. 编译、运行与功能验证

5.1 编译项目

1. 在 Qt Creator 中，确保构建套件 (Kit) 选择正确（例如 Desktop Qt 5.15.2 GCC 64bit）。
2. 点击左下角的锤子图标或按Ctrl+B进行构建。首次构建可能会因为添加了charts模块而需要重新运行qmake，Qt Creator 通常会提示。
3. 构建成功后，输出窗口会显示生成的可执行文件路径。

5.2 运行与验证

1. 点击 Qt Creator 左下角的绿色运行箭头。
2. 程序启动后，你应该能看到一个窗口，上半部分显示 CPU 和内存的实时百分比及进度条，下半部分显示两条空白的曲线图。
3. 等待几秒钟，图表上应该开始绘制出 CPU 和内存使用率的波动曲线。
4. 你可以打开系统自带的资源监视器（如htop或gnome-system-monitor）进行对比，确认本工具显示的数据基本准确。

5.3 预期效果与检查点

• 界面：窗口布局清晰，组件齐全。
• 数据：CPU 和内存百分比数值应不断变化，与系统负载相符。
• 图表：曲线应平滑滚动，实时反映数据变化。
• 响应：在数据刷新时，界面不应出现卡顿或冻结，这证明了多线程设计的有效性。

6. 常见问题排查与解决方案

在开发过程中，你可能会遇到以下典型问题：

7. 功能扩展与最佳实践建议

一个基础的监控工具已经完成，但作为课程设计或大作业，你可以从以下方向进行扩展，以展示更全面的能力：

7.1 功能扩展建议

1. 监控更多指标：
   • 磁盘 I/O：读取/proc/diskstats计算各磁盘的读写速率。
   • 网络流量：读取/proc/net/dev计算各网卡的上传/下载速度。
   • 单个进程资源：遍历/proc/[pid]/stat和/proc/[pid]/status，实现进程列表和详情查看功能。
2. 增强可视化：
   • 仪表盘：使用QDial或自定义绘制实现仪表盘式显示。
   • 颜色预警：当 CPU 或内存使用率超过阈值（如 80%）时，进度条或数值标签变为红色。
   • 数据持久化与回看：将历史数据保存到 SQLite 数据库或文件中，并提供时间选择器查看过去任意时段的数据。
3. 改善交互与配置：
   • 可配置采样间隔：在界面添加一个下拉框或滑块，让用户调整数据刷新频率。
   • 图表控制：添加暂停、清空、缩放、导出图片等功能。
   • 系统托盘：实现最小化到系统托盘，后台运行。

7.2 工程化与最佳实践

1. 错误处理：在所有文件操作 (QFile::open)、数据解析处添加更完善的错误处理和日志记录，避免程序因意外数据格式而崩溃。
2. 资源管理：
   • 在ResourceMonitor和MainWindow的析构函数中，确保正确停止定时器、退出工作线程并等待其结束，防止内存泄漏和线程残留。
   • 对于动态创建的大量QPointF数据点，注意及时清理过期数据。
3. 性能优化：
   • 图表数据点不宜过多，m_dataMaxPoints可设置为一个合理值（如 300），实现固定长度的滚动窗口。
   • QChart在数据点很多时性能会下降，对于长时间监控，可以考虑对数据进行降采样后再绘制。
4. 跨平台考虑：
   • 使用 Qt 的预定义宏Q_OS_LINUX,Q_OS_WIN,Q_OS_MAC来隔离平台相关代码。
   • 为不同平台编写独立的PlatformResourceMonitor实现类，通过工厂模式或条件编译在运行时选择。
5. 代码结构与文档：
   • 将数据获取、数据处理、UI 展示进一步解耦，遵循单一职责原则。
   • 在关键类和方法前添加清晰的注释，说明其功能和参数。
   • 编写一个简单的README.md，说明项目功能、编译方法和运行环境。

通过完成这个项目，你不仅掌握了 Qt C++ 开发一个桌面应用的全流程，更深入理解了多线程编程、系统编程、数据可视化和软件设计模式的实际应用。这个项目框架扎实，扩展性强，足以作为一份高质量的课程设计或毕业设计作品。