当前位置： 首页 > article >正文

Qt 项目优化实践方向

article 2024/9/29 14:01:53

目录

      • 1. 使用智能指针
      • 2. 避免在全局或静态作用域中使用裸指针
      • 3. 利用Qt的对象树进行资源管理
      • 4. 延迟加载和按需加载资源
      • 5. 合理使用Qt的资源文件（qrc）
      • 6. 监控和调试内存使用
      • 7. 优化数据结构
      • 8. 减少不必要的资源复制
      • 9. 使用缓存机制
      • 10. 遵循RAII原则

以下是我在项目优化过程中通过 AI 搜索后整理出来的信息，仅供参考

目的

提升应用程序的性能、减少内存泄漏、提高响应速度，并增强用户体验。
以下是一些 Qt 中项目优化实践方向：

1. 使用智能指针

解释：
智能指针是C++11及以后版本中引入的一种自动管理内存的机制。它们封装了裸指针，通过自动释放所指向的对象来减少内存泄漏和悬空指针等问题的发生。Qt中的智能指针主要包括以下几种：

  1. QSharedPointer：

    • 这是一个可共享的智能指针，使用引用计数来管理对象的生命周期。
    • 多个QSharedPointer实例可以指向同一个对象，对象会在最后一个引用被销毁时被删除。
    • 它类似于C++11标准库中的std::shared_ptr。

  2. QWeakPointer：

    • 这是一个不拥有对象的智能指针，它通常与QSharedPointer一起使用。
    • QWeakPointer持有对QSharedPointer的弱引用，不会阻止对象被销毁，当对象被销毁后，它会自动重置为nullptr。
    • 它类似于C++11标准库中的std::weak_ptr。

  3. QScopedPointer：

    • 这是一个自动删除所指对象的指针，当QScopedPointer离开其作用域时，它会自动删除所指向的对象。
    • 它类似于C++11标准库中的std::unique_ptr，实现了RAII（资源获取即初始化）语义。

  4. QPointer：

    • 这是一个专门用于管理继承自QObject的对象的智能指针。
    • 当被指向的QObject对象被销毁时，QPointer会自动设置为nullptr，从而避免悬空指针的问题。

  5. 其他智能指针（虽然不常用，但Qt也提供了）：

    • QSharedDataPointer 和 QExplicitlySharedDataPointer：这两个智能指针用于实现隐式或显式的数据共享机制，允许多个对象共享同一份数据，直到数据被某个对象修改时，才会复制数据并分配给修改者。
    • QScopedArrayPointer：这是QScopedPointer的一个特化版本，专门用于管理动态分配的数组。

示例：
以下是一个示例代码，它结合了Qt框架中的四种智能指针（QSharedPointer、QWeakPointer、QScopedPointer 和 QPointer）来展示它们各自的使用场景和特性。请注意，由于QPointer通常用于观察QObject及其子类的生命周期，所以在示例中我将MyClass继承自QObject以展示QPointer的使用。

#include <QCoreApplication>
#include <QSharedPointer>
#include <QWeakPointer>
#include <QScopedPointer>
#include <QPointer>
#include <QDebug>

class MyClass : public QObject {
    Q_OBJECT
public:
    explicit MyClass(int value, QObject *parent = nullptr) : QObject(parent), m_value(value) {
        qDebug() << "MyClass 构造函数，数值为" << m_value;
    }
    ~MyClass() {
        qDebug() << "MyClass 析构函数，数值为" << m_value;
    }

    void setValue(int value) { m_value = value; }
    int getValue() const { return m_value; }

private:
    int m_value;
};

int main(int argc, char *argv[]) {
    QCoreApplication a(argc, argv);

    // QSharedPointer 示例
    {
        QSharedPointer<MyClass> sharedPtr(new MyClass(10));
        qDebug() << "QSharedPointer 指向的对象值：" << sharedPtr->getValue();
        
        // 创建一个 QWeakPointer，与 QSharedPointer 共享同一个对象
        QWeakPointer<MyClass> weakPtr = sharedPtr;
        if (!weakPtr.isNull()) {
            qDebug() << "QWeakPointer 指向的对象值：" << weakPtr.data()->getValue();
        }        
        // 当 QSharedPointer 离开作用域时，对象通常不会被删除（除非有其他 QSharedPointer 引用它）
        // 但在这个例子中，没有其他 QSharedPointer 引用，所以对象会被删除
    }

    // QScopedPointer 示例
    {
        QScopedPointer<MyClass> scopedPtr(new MyClass(20));
        qDebug() << "QScopedPointer 指向的对象值：" << scopedPtr->getValue();
        
        // 当 QScopedPointer 离开作用域时，对象会被自动删除
    }

    // QPointer 示例
    {
        QPointer<MyClass> ptr(new MyClass(30));
        qDebug() << "QPointer 指向的对象值：" << ptr->getValue();
        
        // 假设在某个时刻，QObject（在这个例子中是 MyClass）对象被删除了（这里我们不会显式删除它，只是说明概念）
        // 在实际情况中，这可能是由于父对象被删除，或者调用了 delete
        // 如果对象被删除，QPointer 会自动变为 nullptr

        // 示例：手动将 ptr 设置为 nullptr（模拟对象被删除）
        ptr = nullptr;

        if (ptr.isNull()) {
            qDebug() << "QPointer 现在为 nullptr，对象已被删除或设置为 nullptr";
        }
    }

    // 注意：在这个例子中，我们没有真正删除 MyClass 的实例，因为 QCoreApplication 还没有结束，
    // 并且我们没有为 QSharedPointer 和 QPointer 创建任何持久的引用。在实际应用中，
    // 对象的生命周期管理会更加复杂，并且你需要确保在不再需要对象时释放它们。

    return a.exec();
}

// 注意：由于示例的简洁性，我们没有在 QSharedPointer 和 QPointer 的例子中显式地删除对象。
// 在实际应用中，你可能需要管理这些对象的生命周期，以确保它们在适当的时候被删除。
// 对于 QSharedPointer，当最后一个 QSharedPointer 被销毁或重置时，对象会被自动删除。
// 对于 QPointer，它观察 QObject 的生命周期，当 QObject 被删除时，QPointer 会自动变为 nullptr。
// QScopedPointer 则在离开其作用域时自动删除其所指向的对象。

输出结果：

MyClass 构造函数，数值为 10  
QSharedPointer 指向的对象值：10  
QWeakPointer 指向的对象值：10  
MyClass 析构函数，数值为 10  // 当 QSharedPointer 离开作用域时，对象被删除  
  
MyClass 构造函数，数值为 20  
QScopedPointer 指向的对象值：20  
MyClass 析构函数，数值为 20  // 当 QScopedPointer 离开作用域时，对象被删除  
  
MyClass 构造函数，数值为 30  
QPointer 指向的对象值：30  
QPointer 现在为 nullptr，对象已被删除或设置为 nullptr  /* 注意：这里我们手动将 ptr 设置为 nullptr，实际上 MyClass 对象并没有被删除。
但是，如果 MyClass 对象是通过某种方式（如父对象删除或显式 delete）被删除的，QPointer 会自动检测到这一点。
由于我们没有这样做，所以这里的“删除”是误导性的，只是展示了如何检查 QPointer 是否为 nullptr.
实际上，由于 QCoreApplication 的存在，程序不会立即退出，但 MyClass 对象的生命周期已经结束 */

在这个示例中，使用了花括号 {} 来创建局部作用域，以便在示例结束时自动销毁智能指针并（可能地）删除它们所指向的对象。请注意，由于QCoreApplication的存在，程序实际上并没有在main函数的末尾立即退出，但在这个例子中，智能指针的作用域限制足以展示它们的基本用法。

另外，请注意，在实际应用中，你可能不会在main函数中直接使用这些智能指针来管理GUI组件的生命周期，而是会在更复杂的类中，或者作为类的成员变量来使用它们。此外，QPointer通常与信号和槽机制一起使用，以处理对象生命周期中的变化。

2. 避免在全局或静态作用域中使用裸指针

解释：
全局或静态作用域中的裸指针可能导致内存泄漏，因为它们的生命周期与程序的生命周期相同，且往往没有明确的释放时机。如果程序在结束前没有显式释放这些指针所指向的内存，就会发生内存泄漏。

建议：
使用智能指针或Qt的对象树机制来管理这些资源，确保在不再需要时能够自动释放。

3. 利用Qt的对象树进行资源管理

解释：
Qt的对象树是一种通过父子关系自动管理对象生命周期的机制。当一个QObject对象被创建时，可以指定其父对象。当父对象被销毁时，它会自动销毁其所有子对象。

示例：

QWidget *parentWidget = new QWidget();
QPushButton *button = new QPushButton("Click me", parentWidget);
// 当parentWidget被销毁时，button也会被自动销毁

4. 延迟加载和按需加载资源

解释：
对于大型资源或用户不一定会立即使用的资源，可以在需要时才加载它们。这可以减少应用程序的启动时间和内存占用。

示例：
在需要显示某个大型图像时，才从磁盘加载该图像，而不是在应用程序启动时一次性加载所有图像。

5. 合理使用Qt的资源文件（qrc）

解释：
Qt的资源文件（qrc）允许将资源编译到应用程序的可执行文件中，从而简化了资源的部署和管理。但是，过大的资源文件会增加程序的体积和内存消耗。

建议：

  • 只将必要的资源编译到qrc文件中。
  • 对于大型资源，考虑使用外部文件并在需要时动态加载。

6. 监控和调试内存使用

解释：
使用Qt Creator内置的性能分析工具（如Valgrind、QProfiler等）来监控和调试内存使用情况。这些工具可以帮助发现内存泄漏、无效的内存访问等问题。

操作：

  • 在Qt Creator中运行应用程序，并使用性能分析工具进行监控。
  • 分析结果，查找并修复内存问题。

7. 优化数据结构

解释：
选择合适的数据结构可以显著提高数据访问和处理的效率。Qt提供了一系列高效的数据结构，如QVector、QMap等。

建议：

  • 根据数据的特性和访问模式选择合适的数据结构。

    Qt常见容器介绍：
    QList：适合存储元素数量较少且需要频繁随机访问的场景。它基于数组实现，提供了快速的随机访问能力。
    QVector：与 QList 类似，但更适合存储大量数据，因为它在内部使用连续的内存分配，可以更快地访问和修改元素。
    QLinkedList：适合元素数量非常多且需要频繁插入和删除操作的场景。它基于链表实现，插入和删除操作的时间复杂度为O(1)。
    QMap 和 QHash：用于存储键值对。QMap按键排序，适合需要按键顺序遍历的场景；QHash则提供了更快的查找速度，但不保证键的顺序。
    QSet：用于存储不重复的元素，基于QHash实现，提供了快速的查找、插入和删除操作。

  • 算法优化。

    选择合适的算法来解决问题。
    例如，使用二分查找而不是线性查找来在有序数组中查找元素。
    尽量避免使用复杂的递归算法，特别是当递归深度很大时。
    对于需要频繁执行的操作，考虑使用查找表、哈希表等数据结构来加速查找过程，等等。

8. 减少不必要的资源复制

解释：
在Qt中，尽量避免不必要的资源复制。大型对象的复制会消耗大量的内存和CPU资源。

建议：

  • 使用引用或指针来传递大型对象或数据结构。

  • 如果需要复制对象，考虑使用移动语义（C++11及以后版本支持）来优化性能。

  • 对象池化

    对象池是一种设计模式，用于管理和重用已经创建的对象，而不是每次需要时都创建新对象。这可以显著减少内存分配和复制的开销。

对象池化示例：

下面将给出一个简单的Qt对象池用法的例子，这个对象池将用于管理QWidget对象的重用。

请注意，这个例子主要是为了演示对象池的概念，而QWidget通常不建议在对象池中重用，因为它们的生命周期和父子关系管理比较复杂。但在实际应用中，你可以将QWidget替换为任何适合重用的自定义对象。

首先，我们定义一个简单的对象池类ObjectPool，它管理一个特定类型对象的集合：

#include <QObject>
#include <QList>
#include <QMutex>
#include <QMutexLocker>

template<typename T>
class ObjectPool : public QObject {
    Q_OBJECT
public:
    ObjectPool(QObject *parent = nullptr) : QObject(parent) {}

    // 从池中获取一个对象，如果池为空则创建新对象
    T* getObject() {
        QMutexLocker locker(&mutex);
        if (!pool.isEmpty()) {
            return pool.takeFirst();
        }
        return new T(); // 注意：这里简单地创建了新对象，实际应用中可能需要更复杂的初始化
    }

    // 将对象放回池中
    void releaseObject(T* object) {
        QMutexLocker locker(&mutex);
        // 在将对象放回池中之前，可能需要重置其状态
        // object->reset(); // 假设T有reset方法
        pool.append(object);
    }

private:
    QList<T*> pool; // 存储对象的列表
    QMutex mutex; // 线程安全
};

// 假设我们有一个简单的可重用对象类
class ReusableObject : public QObject {
    Q_OBJECT
public:
    ReusableObject(QObject *parent = nullptr) : QObject(parent) {
        // 初始化代码
    }

    // 重置对象状态的方法（示例）
    void reset() {
        // 清除或重置对象的内部状态
    }

    // 其他成员...
};

// 使用示例
int main(int argc, char *argv[]) {
    QApplication app(argc, argv);

    // 创建对象池
    ObjectPool<ReusableObject> pool;

    // 从池中获取对象
    ReusableObject* obj1 = pool.getObject();
    ReusableObject* obj2 = pool.getObject();

    // 使用对象...

    // 将对象放回池中
    pool.releaseObject(obj1);
    pool.releaseObject(obj2);

    // 再次从池中获取对象时，可能会重用之前放回的对象
    ReusableObject* obj3 = pool.getObject(); // 可能是obj1或obj2

    return app.exec();
}

请注意，这个例子中的ReusableObject类只是一个简单的QObject子类，用于演示目的。在实际应用中，你可能需要定义一个包含更复杂状态和行为的类。

此外，这个对象池实现是线程安全的，因为它使用了QMutex来保护对对象池的访问。然而，如果你不打算在多线程环境中使用对象池，那么可以移除与线程安全相关的代码。

最后，请注意，在将对象放回池中之前，通常需要调用一个重置方法（如reset()）来清除或重置对象的内部状态，以确保下次从池中获取该对象时它是干净的。在这个例子中，我提供了一个reset()方法的占位符，但你需要根据你的具体需求来实现它。

9. 使用缓存机制

解释：
对于频繁访问或计算量大的资源或数据，可以使用缓存机制来减少访问次数和计算量。

示例：

  • 使用QCache或自定义缓存策略来存储频繁访问的数据。
  • 在数据发生变化时更新缓存，以确保缓存数据的有效性。

10. 遵循RAII原则

解释：
RAII（Resource Acquisition Is Initialization）是一种在C++中管理资源的惯用法。它将资源的获取（如分配内存）放在对象的构造函数中，并将资源的释放（如释放内存）放在对象的析构函数中。

建议：

  • 在自己的类中遵循RAII原则来管理资源。

示例：

#include <iostream>

class MyClass {
public:
    // 构造函数：分配资源
    MyClass(size_t size) {
        data = new int[size];
        std::cout << "Memory allocated." << std::endl;
    }

    // 析构函数：释放资源
    ~MyClass() {
        delete[] data;
        std::cout << "Memory deallocated." << std::endl;
    }

    // 其他成员函数...

private:
    int* data; // 指向动态分配内存的指针
};

int main() {
    {
        MyClass obj(10); // 创建对象，分配资源
        // 使用对象...
    } // 对象离开作用域，自动调用析构函数，释放资源

    return 0;
}

通过以上这些最佳实践，可以更有效地管理Qt应用程序中的资源，从而提升程序的性能和用户体验。


http://www.kler.cn/news/324681.html

相关文章：

  • LeetCode题练习与总结：为运算表达式设计优先级--241
  • Kafka 的重平衡问题详解及解决方案
  • 【Linux】 tcp | 解除服务器对tcp连接的限制 | 物联网项目配置
  • （十七）、Mac 安装k8s
  • Redis桌面工具:Tiny RDM
  • py-mmcif包解析蛋白质结构的装配信息
  • 【NodeJS】npm、yarn、pnpm当前项目设置国内镜像源
  • 别人做谷歌seo凭什么比你好？
  • lua基础语法
  • 【可测试性实践】C++ 单元测试代码覆盖率统计入门
  • 探索 LangChain: 架构、组件和应用
  • 【CSS in Depth 2 精译_039】6.3 CSS 定位技术之：相对定位（上）
  • WPF一个控件根据另一个控件的某种状态的改变从而改变自身某种状态
  • 机械键盘驱动调光DIY--【DAREU】
  • Makefile编程：4种赋值差异
  • Python爬虫lxml模块安装导入和xpath基本语法
  • 计算机毕业设计 校运会管理系统的设计与实现 Java实战项目 附源码+文档+视频讲解
  • ssm模糊知识点整合
  • Java | Leetcode Java题解之第442题数组中重复的数据
  • 滚雪球学MySQL[3.1讲]： 高级SQL查询
  • leetcode_015_三数之和解析
  • Python集成测试详解
  • 工业边缘计算网关和普通网关的区别-天拓四方
  • python基础语法--顺序结构
  • SpringCloud源码：客户端分析（一）- SpringBootApplication注解类加载流程
  • 工业缺陷检测——Windows 10本地部署AnomalyGPT工业缺陷检测大模型
  • naocs注册中心，配置管理，openfeign在idea中实现模块间的调用，getway的使用
  • Python爬虫bs4的基本使用
  • Android平台如何获取CPU占用率和电池电量信息
  • Unity 与虚幻引擎对比：两大游戏开发引擎的优劣分析