[QT编程系列-21]:基本框架 - QT常见数据结构:QString、QList、QVector、QMap、QHash、QSet、QPair详解

目录

1 QString

2 QList

3 QVector

4 QMap

5 QHash

6 QSet

7 QPair


1 QString

QString是Qt中用于存储和操作字符串的类。它提供了丰富的字符串处理方法和功能。

以下是QString的一些主要特点和常用操作:

  1. 创建QString对象:

    QString str = "Hello";                    // 直接初始化
    QString str2("World");                     // 使用字符串字面值初始化
    QString str3 = QString("Bonjour");         // 使用构造函数进行初始化
    
  2. 获取字符串内容和长度:

    QString str = "Hello";
    QString str2 = "World";
    QString combined = str + " " + str2;       // 字符串拼接
    int length = str.length();                  // 获取字符串长度
    
  3. 字符串比较和搜索:

    QString str = "Hello";
    QString str2 = "hello";
    bool result = str.compare(str2, Qt::CaseInsensitive);   // 比较字符串,忽略大小写
    int index = str.indexOf("l");                           // 查找子字符串的位置
    
  4. 字符串分割和连接:

    QString str = "Hello,World,Qt";
    QStringList list = str.split(",");                 // 将字符串分割成字符串列表
    QString joined = list.join(" ");                    // 将字符串列表连接成一个字符串
    
  5. 字符串格式化和转换:

    QString str = QString("%1 %2").arg(42).arg(3.14);    // 格式化字符串
    int num = str.toInt();                               // 字符串转换为整数
    double number = str.toDouble();                       // 字符串转换为浮点数
    
  6. 字符串操作和修改:

    QString str = "Hello World";
    QString upper = str.toUpper();                        // 转换为大写字母
    QString lower = str.toLower();                        // 转换为小写字母
    QString trimmed = str.trimmed();                       // 去除首尾空格
    QString replaced = str.replace("World", "Qt");         // 字符串替换
    

以上是QString的一些常用操作,它提供了很多其他方法来操作和处理字符串。你可以查阅Qt文档以获取更详细的函数列表和使用示例。

2 QList

QList是Qt中用于存储同一数据类型的动态数组容器类。它提供了方便的插入、删除和访问操作,并支持迭代器和算法等功能。

以下是QList的一些主要特点和常用操作:

  1. 创建QList对象:

    QList list;                            // 创建一个空的整型列表
    QList strList = {"Hello", "World"}; // 使用初始化列表创建列表
    QList *doubleList = new QList; // 创建动态分配的列表
    
  2. 添加和删除元素:

    QList list;
    list.append(42);                             // 在列表末尾添加元素
    list.prepend(17);                            // 在列表开头添加元素
    list.insert(2, 99);                           // 在指定位置插入元素
    list.removeFirst();                           // 删除第一个元素
    list.removeLast();                            // 删除最后一个元素
    list.removeAt(1);                             // 删除指定位置的元素
    list.clear();                                 // 清空列表
    
  3. 获取和修改元素:

    QList strList = {"Hello", "World"};
    QString first = strList.first();              // 获取第一个元素
    QString last = strList.last();                // 获取最后一个元素
    QString str = strList.at(1);                  // 获取指定位置的元素
    strList.replace(0, "Bonjour");                 // 替换指定位置的元素
    
  4. 列表的大小和遍历:

    QList list = {1, 2, 3, 4, 5};
    int size = list.size();                       // 获取列表的大小
    for (int i = 0; i < list.size(); ++i) {
        int value = list.at(i);                    // 使用索引遍历元素
        // 进行操作...
    }
    
  5. 使用迭代器遍历:

    QList list = {1, 2, 3, 4, 5};
    QList::iterator iter;
    for (iter = list.begin(); iter != list.end(); ++iter) {
        int value = *iter;                         // 使用迭代器遍历元素
        // 进行操作...
    }
    
  6. STL算法和其他操作:

    QList list = {1, 2, 3, 4, 5};
    std::sort(list.begin(), list.end());           // 使用STL算法排序列表
    bool contains = list.contains(3);              // 列表是否包含指定元素
    int index = list.indexOf(4);                   // 查找元素的索引位置
    

以上是QList的一些常用操作,它还提供了更多的成员函数和功能,如拷贝构造、深拷贝、元素访问等。你可以查阅Qt文档以获取更详细的函数列表和使用示例。

3 QVector

QVector是Qt中的一个动态数组容器类,用于存储同一数据类型的元素。它提供了高效的随机访问和动态调整大小的功能。

以下是QVector的一些主要特点和常用操作:

  1. 创建QVector对象:

    QVector vector;                            // 创建一个空的整型向量
    QVector strVector = {"Hello", "World"}; // 使用初始化列表创建向量
    QVector *doubleVector = new QVector(); // 创建动态分配的向量
    
  2. 添加和删除元素:

    QVector vector;
    vector.append(42);                                // 在向量末尾添加元素
    vector.prepend(17);                               // 在向量开头添加元素
    vector.insert(2, 99);                              // 在指定位置插入元素
    vector.removeFirst();                              // 删除第一个元素
    vector.removeLast();                               // 删除最后一个元素
    vector.removeAt(1);                                // 删除指定位置的元素
    vector.clear();                                    // 清空向量
    
  3. 获取和修改元素:

    QVector strVector = {"Hello", "World"};
    QString first = strVector.first();                 // 获取第一个元素
    QString last = strVector.last();                   // 获取最后一个元素
    QString str = strVector.at(1);                     // 获取指定位置的元素
    strVector.replace(0, "Bonjour");                    // 替换指定位置的元素
    
  4. 向量的大小和遍历:

    QVector vector = {1, 2, 3, 4, 5};
    int size = vector.size();                          // 获取向量的大小
    for (int i = 0; i < vector.size(); ++i) {
        int value = vector.at(i);                       // 使用索引遍历元素
        // 进行操作...
    }
    
  5. 使用迭代器遍历:

    QVector vector = {1, 2, 3, 4, 5};
    QVector::const_iterator iter;
    for (iter = vector.begin(); iter != vector.end(); ++iter) {
        int value = *iter;                              // 使用迭代器遍历元素
        // 进行操作...
    }
    
  6. STL算法和其他操作:

    QVector vector = {1, 2, 3, 4, 5};
    std::sort(vector.begin(), vector.end());           // 使用STL算法排序向量
    bool contains = vector.contains(3);                 // 向量是否包含指定元素
    int index = vector.indexOf(4);                      // 查找元素的索引位置
    

除了上述操作,QVector还提供了其他一些有用的功能,如数据复制、内存预分配、容量调整等。你可以查阅Qt文档以获取更详细的函数列表和使用示例。

4 QMap

QMap是Qt中的一个关联容器类,用于存储键值对(Key-Value)元素。它提供了高效的基于键的查找和插入操作。

以下是QMap的一些主要特点和常用操作:

  1. 创建QMap对象:

    QMap map;                          // 创建一个空的整型到字符串的映射
    QMap strMap = {{"Alice", 26}, {"Bob", 32}}; // 使用初始化列表创建映射
    QMap *doubleMap = new QMap(); // 创建动态分配的映射
    
  2. 添加和删除元素:

    QMap map;
    map.insert("Alice", 26);                          // 插入键值对
    map.insert("Bob", 32);
    map["Charlie"] = 40;                              // 使用下标操作符插入或修改值
    map.remove("Bob");                                // 根据键删除元素
    map.clear();                                      // 清空映射
    
  3. 获取和修改元素:

    QMap map;
    map.insert("Alice", 26);
    map.insert("Bob", 32);
    int ageAlice = map.value("Alice");                 // 获取键对应的值
    int ageBob = map["Bob"];
    map["Charlie"] = 40;                               // 修改键对应的值
    
  4. 查询操作:

    QMap map;
    map.insert("Alice", 26);
    map.insert("Bob", 32);
    bool containsBob = map.contains("Bob");           // 检查是否包含指定键
    int count = map.count();                          // 获取键值对的数量
    QMap::const_iterator iter = map.find("Alice"); // 查找键对应的迭代器
    if (iter != map.end()) {
        int age = iter.value();
    }
    
  5. 遍历操作:

    QMap map;
    map.insert("Alice", 26);
    map.insert("Bob", 32);
    QMap::const_iterator iter;
    for (iter = map.constBegin(); iter != map.constEnd(); ++iter) {
        QString name = iter.key();
        int age = iter.value();
        // 进行操作...
    }
    

QMap还提供了其他一些功能,如键的排序、范围查询、多重映射等。你可以查阅Qt文档以获取更详细的函数列表和使用示例。

5 QHash

QHash是Qt中的一个散列容器类,用于存储键值对(Key-Value)元素。它提供了高效的基于键的查找和插入操作,并使用哈希函数来散列键以提高性能。

以下是QHash的一些主要特点和常用操作:

  1. 创建QHash对象:

    QHash hash;                          // 创建一个空的整型到字符串的散列
    QHash strHash = {{"Alice", 26}, {"Bob", 32}}; // 使用初始化列表创建散列
    QHash *doubleHash = new QHash(); // 创建动态分配的散列
    
  2. 添加和删除元素:

    QHash hash;
    hash.insert("Alice", 26);                          // 插入键值对
    hash.insert("Bob", 32);
    hash["Charlie"] = 40;                              // 使用下标操作符插入或修改值
    hash.remove("Bob");                                // 根据键删除元素
    hash.clear();                                      // 清空散列
    
  3. 获取和修改元素:

    QHash hash;
    hash.insert("Alice", 26);
    hash.insert("Bob", 32);
    int ageAlice = hash.value("Alice");                 // 获取键对应的值
    int ageBob = hash["Bob"];
    hash["Charlie"] = 40;                               // 修改键对应的值
    
  4. 查询操作:

    QHash hash;
    hash.insert("Alice", 26);
    hash.insert("Bob", 32);
    bool containsBob = hash.contains("Bob");           // 检查是否包含指定键
    int count = hash.count();                          // 获取键值对的数量
    QHash::const_iterator iter = hash.find("Alice"); // 查找键对应的迭代器
    if (iter != hash.end()) {
        int age = iter.value();
    }
    
  5. 遍历操作:

    QHash hash;
    hash.insert("Alice", 26);
    hash.insert("Bob", 32);
    QHash::const_iterator iter;
    for (iter = hash.constBegin(); iter != hash.constEnd(); ++iter) {
        QString name = iter.key();
        int age = iter.value();
        // 进行操作...
    }
    

QHash还提供了其他一些功能,如键的排序、范围查询、多重散列等。你可以查阅Qt文档以获取更详细的函数列表和使用示例。

6 QSet

QSet是Qt中的一个集合容器类,用于存储不重复的元素。它提供了高效的查找和插入操作,并保持元素的唯一性。

以下是QSet的一些主要特点和常用操作:

  1. 创建QSet对象:
QSet set;                             // 创建一个空的整型集合
QSet strSet = {"Apple", "Orange"}; // 使用初始化列表创建集合
QSet *doubleSet = new QSet(); // 创建动态分配的集合

  1. 添加和删除元素:
QSet set;
set.insert(10);                            // 插入元素
set.insert(20);
set.insert(30);
set.remove(20);                            // 删除指定元素

  1. 查询操作:
QSet set = {10, 20, 30};
bool contains = set.contains(20);          // 检查是否包含指定元素
int count = set.count();                    // 获取集合中元素的数量

  1. 遍历操作:
QSet set = {10, 20, 30};
QSet::const_iterator iter;
for (iter = set.constBegin(); iter != set.constEnd(); ++iter) {
    int value = *iter;
    // 进行操作...
}

  1. 集合运算:
QSet setA = {1, 2, 3, 4, 5};
QSet setB = {4, 5, 6, 7, 8};
QSet intersection = setA.intersect(setB);    // 交集
QSet unionSet = setA.unite(setB);             // 并集
QSet difference = setA.subtract(setB);        // 差集

QSet还提供了其他一些功能,如集合的排序、集合的交叉验证等。你可以查阅Qt文档以获取更详细的函数列表和使用示例。

7 QPair

QPair是Qt中的一个通用容器类,用于存储两个不同类型的值。它可以将两个值组合成一个单元,方便进行传递和处理。

以下是QPair的一些主要特点和常用操作:

  1. 创建QPair对象:

    QPair pair;                          // 创建一个空的整型和字符串的配对
    QPair strIntPair = {"Alice", 26};     // 使用初始化列表创建配对
    QPair *strDoublePair = new QPair(); // 创建动态分配的配对
    
  2. 设置和获取值:

    QPair pair;
    pair.first = "Alice";                               // 设置第一个值
    pair.second = 26;                                   // 设置第二个值
    QString name = pair.first;                           // 获取第一个值
    int age = pair.second;                               // 获取第二个值
    
  3. 比较操作:

    QPair pairA = {1, 2};
    QPair pairB = {3, 4};
    bool equal = (pairA == pairB);                       // 比较两个配对是否相等
    bool notEqual = (pairA != pairB);                    // 比较两个配对是否不相等
    
  4. 交换操作:

    QPair pair = {1, 2};
    pair.swap();                                         // 交换两个值
    

QPair提供了一种简便的方式来保存两个不同类型的值,并进行直接访问和操作。它在许多Qt类中被广泛使用,如QMap、QHash等。你可以查阅Qt文档以获取更详细的函数列表和使用示例。

你可能感兴趣的:(编程系列-QT,qt,开发语言,C++)