Qt Essential Classes

目录

QVariant

QFlags

QRandomGenerator

经典的Qt容器

QVector

QList

QMap

QMultiMap

QSet

QHash

QVariant

同std::variant是一样的，他是一个更加高级的union。在一个时间下，它虽然实际上只能是一种类型，但是一个variant可以hold住所有的types（因为本质上都是内存块塞0和1，理解这一点的同志们直接看API就完事了），这样，我们直接就可以存储一个通用的类型，对于不同的场景做对应的转换就好了！我的另一个意思是：提供了一个统一的接口来处理各种数据类型。QVariant 可以存储简单的数据类型（如整型、浮点型、字符串等）以及复杂的数据类型（如自定义类、列表等）。

试一手：

#include <QVariant>
#include <QString>
#include <QDebug>
​
int main() {
    QVariant variant;
​
    // 存储整数
    variant = 42;
    qDebug() << "Stored integer:" << variant.toInt();
​
    // 存储字符串
    variant = QString("Hello, QVariant!");
    qDebug() << "Stored string:" << variant.toString();
​
    // 检查类型
    if (variant.type() == QVariant::String) {
        qDebug() << "Variant holds a string.";
    }
​
    // 使用 fromValue 和 toVariant
    QVariant doubleVariant = QVariant::fromValue(3.14);
    double value = doubleVariant.value<double>();
    qDebug() << "Stored double:" << value;
​
    return 0;
}

QFlags

这个笔者感悟比较深：他在你设置一些对象的属性的时候很管用：它通过位运算提供了一种简单而高效的方式来组合多个标志。QFlags 主要用于处理枚举类型的标志组合，使得代码更加清晰和易于维护。

笔者建议你按照std::bitset的一个高级抽象来理解。我们实际上就是使用比特表达信息！完事！

#include <QCoreApplication>
#include <QFlags>
#include <QDebug>
​
enum MyFlags {
    FlagA = 0x1, // 0001
    FlagB = 0x2, // 0010
    FlagC = 0x4  // 0100
};
​
Q_DECLARE_FLAGS(MyFlagSet, MyFlags)
​
int main(int argc, char *argv[]) {
    QCoreApplication a(argc, argv);
​
    // 创建标志
    MyFlagSet flags;
    flags |= FlagA;  // 添加 FlagA
    flags |= FlagB;  // 添加 FlagB
​
    // 检查标志
    if (flags.testFlag(FlagA)) {
        qDebug() << "FlagA is set.";
    }
​
    if (flags.testFlag(FlagB)) {
        qDebug() << "FlagB is set.";
    }
​
    // 组合标志
    MyFlagSet moreFlags = FlagB | FlagC; // 组合 FlagB 和 FlagC
    flags |= moreFlags; // 添加组合的标志
​
    // 输出当前标志状态
    qDebug() << "Current flags:" << flags;
​
    // 测试 FlagC 是否被设置
    if (flags.testFlag(FlagC)) {
        qDebug() << "FlagC is set.";
    }
​
    // 使用位与操作获取共同标志
    MyFlagSet commonFlags = flags & moreFlags;
    qDebug() << "Common flags:" << commonFlags;
​
    return a.exec();
}
​
Q_DECLARE_METATYPE(MyFlagSet)

QRandomGenerator

这个玩意是检验你是Qt6选手还是Qt5选手的标准类。他就是qt5的qrand()的高级版，提供了一系列方法来生成均匀分布和正态分布的随机数，支持多种数据类型。QRandomGenerator 是线程安全的，因此可以在多线程环境中安全使用。

• 性能：高效生成随机数，适合需要大量随机数的应用场景。

• 可移植性：在不同平台上具有一致的行为。

• 种子控制：支持通过种子初始化生成器，以便于生成可重复的随机数序列。

• 随机数分布：支持生成均匀分布、正态分布等类型的随机数。

#include <QCoreApplication>
#include <QRandomGenerator>
#include <QDebug>
​
int main(int argc, char *argv[]) {
    QCoreApplication a(argc, argv);
​
    // 创建一个 QRandomGenerator 实例
    QRandomGenerator *generator = QRandomGenerator::global();
​
    // 生成 10 个随机整数
    qDebug() << "Random integers:";
    for (int i = 0; i < 10; ++i) {
        int randomInt = generator->bounded(100); // 在 [0, 100) 范围内
        qDebug() << randomInt;
    }
​
    // 生成 10 个随机浮点数
    qDebug() << "Random doubles:";
    for (int i = 0; i < 10; ++i) {
        double randomDouble = generator->generateDouble(); // 在 [0.0, 1.0) 范围内
        qDebug() << randomDouble;
    }
​
    return a.exec();
}

经典的Qt容器

QVector

QVector 是 Qt 提供的一种动态数组容器，类似于 C++ 标准库中的 std::vector。它用于存储同一类型的元素，并支持快速的随机访问、插入和删除操作。QVector 主要用于需要动态调整大小且频繁读取元素的场景。

是的，就是std::vector的Qt版本。笔者在《Qt高性能编程》中见到过观点：use std rather than qt，这个事情仁者见仁智者见智。笔者认为按照场景使用最好。

• 动态大小：QVector 可以根据需要自动扩展或收缩。

• 快速随机访问：可以通过索引快速访问元素，访问时间复杂度为 O(1)。

• 连续内存存储：数据在内存中是连续存储的，能更好地利用 CPU 缓存，提高性能。

• 支持多种数据类型：可以存储任意类型的数据，通常与 Qt 的其他类型（如 QVariant）结合使用。

• 高效的内存管理：通过智能的内存分配策略减少内存碎片。

#include <QVector>
#include <QDebug>
​
int main() {
    // 创建一个空的 QVector
    QVector<int> vec;
​
    // 添加元素
    vec.append(10);
    vec.append(20);
    vec.append(30);
    
    // 输出当前大小
    qDebug() << "Size:" << vec.size(); // Size: 3
​
    // 访问元素
    qDebug() << "First element:" << vec.first(); // First element: 10
​
    // 插入元素
    vec.insert(1, 15);
    
    // 输出元素
    for (int i = 0; i < vec.size(); ++i) {
        qDebug() << vec[i]; // 10 15 20 30
    }
​
    // 移除元素
    vec.removeAt(2); // 移除元素 20
​
    // 清空 QVector
    vec.clear();
    
    // 检查是否为空
    qDebug() << "Is empty:" << vec.isEmpty(); // Is empty: true
​
    return 0;
}

它的数据结构特点：

• 访问速度：因为数据是连续存储的，所以 QVector 的访问速度通常比链表等非连续存储的数据结构快。

• 插入和删除：虽然在末尾插入和删除操作的时间复杂度为 O(1)，但在中间位置插入和删除的时间复杂度为 O(n)，这要注意。

它的常见的使用场景：

• 动态数据集合：当需要一个大小可变的数组来存储数据时，例如用户输入、实时数据流等。

• 临时存储：处理算法时使用的临时数据，例如排序、搜索等。

• 图形界面：在 Qt 应用中，常用于存储 UI 组件、图形对象等。

QList

注意在Qt6下，QList == QVector，这里是给Qt5看的：

QList实际上更加的智能，这点随了Java的List：原生类型存数值，复杂类型存指针。但是注意，QList仍然是连续的。比起来，QLinkedList确实是真正的链表！这点请所有使用链表的客户程序员注意！使用链表是QLinkedList！

#include <QList>
#include <QDebug>
​
int main() {
    // 创建一个空的 QList
    QList<int> list;
​
    // 添加元素
    list.append(10);
    list.append(20);
    list.append(30);
​
    // 输出当前大小
    qDebug() << "Size:" << list.size(); // Size: 3
​
    // 访问元素
    qDebug() << "First element:" << list.first(); // First element: 10
​
    // 插入元素
    list.insert(1, 15);
    
    // 输出元素
    for (int i = 0; i < list.size(); ++i) {
        qDebug() << list[i]; // 10 15 20 30
    }
​
    // 移除元素
    list.removeAt(2); // 移除元素

QMap

QMap 是 Qt 提供的一种基于红黑树的关联容器，主要用于存储键值对。它类似于 C++ 标准库中的 std::map，但在使用上更加方便，特别是在与 Qt 其他类的结合使用时。QMap 提供了快速的查找、插入和删除操作，同时能够保持键的有序性。

• 有序性：QMap 中的键是自动排序的，因此可以根据键的顺序遍历元素。

• 快速查找：使用红黑树实现，查找、插入和删除的平均时间复杂度为 O(log n)。

• 多类型支持：可以存储任意类型的键值对，通常与 Qt 的其他类型（如 QString, QVariant）结合使用。

• 重复键处理：QMap 不允许重复的键，如果插入一个已存在的键，原有的值将被覆盖。

• 易于使用的 API：提供了丰富的方法来操作键值对，方便开发者管理数据。

#include <QMap>
#include <QString>
#include <QDebug>
​
int main() {
    QMap<QString, int> grades;
​
    // 插入键值对
    grades.insert("Alice", 85);
    grades.insert("Bob", 90);
    grades.insert("Charlie", 78);
​
    // 输出总数
    qDebug() << "Total students:" << grades.size(); // Total students: 3
​
    // 获取某个学生的成绩
    qDebug() << "Alice's grade:" << grades.value("Alice"); // Alice's grade: 85
​
    // 修改成绩
    grades["Alice"] = 95; // 更新 Alice 的成绩
    qDebug() << "Alice's updated grade:" << grades.value("Alice"); // Alice's updated grade: 95
​
    // 检查某个学生是否存在
    if (grades.contains("David")) {
        qDebug() << "David's grade:" << grades.value("David");
    } else {
        qDebug() << "David not found."; // David not found.
    }
​
    // 移除某个学生
    grades.remove("Charlie");
​
    // 输出所有学生的成绩
    for (const QString &name : grades.keys()) {
        qDebug() << name << ":" << grades.value(name);
    }
​
    // 清空 QMap
    grades.clear();
    qDebug() << "Is empty:" << grades.isEmpty(); // Is empty: true
​
    return 0;
}

QMap 的性能在大多数场景下都非常优秀。由于采用红黑树实现，其查找、插入和删除操作的平均时间复杂度为 O(log n)。虽然在某些情况下，QMap 的性能可能略逊于 QHash（哈希表实现），但在需要有序存储时，QMap 是更好的选择。

QMap 的使用场景非常广泛，包括但不限于：

• 配置存储：存储配置信息时，可以使用键值对的形式存储各类配置项，便于查找和修改。

• 数据索引：在需要根据某种键（如 ID、名称）快速查找数据时，使用 QMap 可以高效地管理这些关系。

• 有序数据：在需要保持元素顺序的同时又要快速查找和修改的场合，QMap 是一个理想的选择。

QMultiMap

QMultiMap 是 Qt 提供的一种特殊的关联容器，允许多个值与同一个键关联。它类似于 QMap，但不同之处在于 QMultiMap 允许键的重复，适合于需要存储多个值而不想丢失键的场景。

• 允许重复键：QMultiMap 允许多个值与同一个键关联，适合存储一对多关系的数据。

• 自动排序：与 QMap 一样，QMultiMap 中的键是自动排序的，能够根据键的顺序遍历元素。

• 快速查找：基于红黑树实现，查找、插入和删除的平均时间复杂度为 O(log n)。

• 多类型支持：支持存储任意类型的键值对，通常与 Qt 的其他类型（如 QString, QVariant）结合使用。

• 易于使用的 API：提供了丰富的方法来操作键值对，方便开发者管理数据。

#include <QMultiMap>
#include <QString>
#include <QDebug>
​
int main() {
    QMultiMap<QString, QString> studentCourses;
​
    // 插入多个值
    studentCourses.insert("Alice", "Math");
    studentCourses.insert("Alice", "Science");
    studentCourses.insert("Bob", "Math");
    studentCourses.insert("Charlie", "History");
    studentCourses.insert("Charlie", "Math");
​
    // 输出每个学生的课程
    for (const QString &student : studentCourses.keys()) {
        QList<QString> courses = studentCourses.values(student);
        qDebug() << student << "is enrolled in:" << courses;
    }
​
    // 移除某个学生的所有课程
    studentCourses.remove("Alice");
​
    // 检查是否存在
    if (!studentCourses.contains("Alice")) {
        qDebug() << "Alice has been removed from the course list.";
    }
​
    // 清空 QMultiMap
    studentCourses.clear();
    qDebug() << "Is empty:" << studentCourses.isEmpty(); // Is empty: true
​
    return 0;
}

QMultiMap 的性能与 QMap 类似，查找、插入和删除操作的平均时间复杂度为 O(log n)。由于它允许重复键的特性，在管理一对多关系时非常有效。

QMultiMap 适用于多种场景:

• 多对多关系存储：在需要存储一对多或多对多关系的数据时，QMultiMap 是理想的选择。

• 分类数据：在需要将数据分类存储时，可以使用相同的键来代表不同的类别。

• 标签系统：在实现标签系统时，可以将多个标签与同一对象关联，方便管理和查询。

QSet

QSet 是 Qt 提供的一种集合容器，主要用于存储唯一值的集合。它类似于 C++ 标准库中的 std::set，但在使用上更加方便，特别是在与 Qt 其他类的结合使用时。QSet 适合用于需要存储不重复元素的场景，提供快速的查找、插入和删除操作。

• 唯一性：QSet 中的每个元素都是唯一的，不能存储重复的值。

• 无序性：元素在集合中没有特定的顺序，遍历时的顺序与插入顺序无关。

• 快速查找：基于哈希表实现，查找、插入和删除操作的平均时间复杂度为 O(1)。

• 多类型支持：可以存储任意类型的数据，通常与 Qt 的其他类型（如 QString, QVariant）结合使用。

• 易于使用的 API：提供了丰富的方法来操作集合，方便开发者管理数据。

#include <QSet>
#include <QString>
#include <QDebug>
​
int main() {
    QSet<QString> students;
​
    // 插入学生姓名
    students.insert("Alice");
    students.insert("Bob");
    students.insert("Charlie");
    students.insert("Alice"); // 重复插入，不会改变集合
​
    // 输出当前学生人数
    qDebug() << "Total students:" << students.size(); // Total students: 3
​
    // 检查是否包含某个学生
    if (students.contains("Bob")) {
        qDebug() << "Bob is in the set.";
    }
​
    // 移除某个学生
    students.remove("Charlie");
​
    // 输出所有学生姓名
    for (const QString &name : students) {
        qDebug() << name;
    }
​
    // 清空集合
    students.clear();
    qDebug() << "Is empty:" << students.isEmpty(); // Is empty: true
​
    return 0;
}

QHash

QHash 是 Qt 提供的一种基于哈希表的关联容器，主要用于存储键值对。它允许快速的查找、插入和删除操作，适合需要频繁访问数据的场景。与 QMap 不同的是，QHash 不会自动排序其元素，主要关注数据的存取效率。

• 键的唯一性：QHash 中的每个键都是唯一的，不能存储重复的键。

• 无序性：元素在集合中没有特定的顺序，遍历时的顺序与插入顺序无关。

• 快速查找：基于哈希表实现，查找、插入和删除操作的平均时间复杂度为 O(1)。

• 多类型支持：可以存储任意类型的键值对，通常与 Qt 的其他类型（如 QString, QVariant）结合使用。

• 易于使用的 API：提供了丰富的方法来操作键值对，方便开发者管理数据。

cpp复制代码#include <QHash>
#include <QString>
#include <QDebug>
​
int main() {
    QHash<QString, int> grades;
​
    // 插入学生成绩
    grades.insert("Alice", 85);
    grades.insert("Bob", 90);
    grades.insert("Charlie", 78);
​
    // 输出学生总数
    qDebug() << "Total students:" << grades.size(); // Total students: 3
​
    // 获取某个学生的成绩
    qDebug() << "Alice's grade:" << grades.value("Alice"); // Alice's grade: 85
​
    // 修改成绩
    grades["Alice"] = 95; // 更新 Alice 的成绩
    qDebug() << "Alice's updated grade:" << grades.value("Alice"); // Alice's updated grade: 95
​
    // 检查某个学生是否存在
    if (grades.contains("David")) {
        qDebug() << "David's grade:" << grades.value("David");
    } else {
        qDebug() << "David not found."; // David not found.
    }
​
    // 移除某个学生
    grades.remove("Charlie");
​
    // 输出所有学生的成绩
    for (const QString &name : grades.keys()) {
        qDebug() << name << ":" << grades.value(name);
    }
​
    // 清空 QHash
    grades.clear();
    qDebug() << "Is empty:" << grades.isEmpty(); // Is empty: true
​
    return 0;
}

QHash 适用于多种场景，例如：

• 数据索引：在需要根据某个键快速查找数据时，QHash 是一个理想的选择。

• 缓存机制：可以使用 QHash 来实现简单的缓存机制，以存储计算结果或数据。

• 频率统计：在处理需要统计元素出现频率的场景时，QHash 可以轻松存储和更新频率。