C++ Qt框架中的各种集合详解
一、QList
QList
是一个动态数组,类似于C++标准库的std::vector。它可以存储各种类型的元素,并提供了插入、删除和访问元素的方法。
#include <QList>
int main() {
QList<int> numbers;
numbers << 1 << 2 << 3 << 4;
// 访问元素
int secondNumber = numbers.at(1); // 2
// 插入元素
numbers.insert(2, 5);
// 删除元素
numbers.removeOne(3);
return 0;
}
- 添加和插入元素
QList<int> numbers;
numbers.append(1); // 在末尾添加元素
numbers.prepend(0); // 在开头添加元素
numbers.insert(2, 5); // 在索引位置插入元素
- 访问元素
int value = numbers.at(1); // 访问索引为 1 的元素
int firstValue = numbers.first(); // 第一个元素
int lastValue = numbers.last(); // 最后一个元素
- 修改元素
numbers[0] = 10; // 修改索引为 0 的元素
numbers.replace(1, 20); // 替换索引为 1 的元素
- 删除元素
numbers.removeAt(2); // 移除索引为 2 的元素
numbers.removeOne(10); // 移除第一个值为 10 的元素
numbers.removeAll(5); // 移除所有值为 5 的元素
numbers.clear(); // 清空列表
- 查找元素
int index = numbers.indexOf(20); // 查找值为 20 的元素的索引
int lastIndex = numbers.lastIndexOf(20); // 查找最后一个值为 20 的元素的索引
bool contains = numbers.contains(30); // 判断是否包含值为 30 的元素
- 遍历元素
foreach (int num, numbers) {
// 遍历所有元素
}
for (int i = 0; i < numbers.size(); ++i) {
int num = numbers[i];
// 使用索引遍历
}
- 获取列表信息
int size = numbers.size(); // 获取列表大小
bool isEmpty = numbers.isEmpty(); // 检查列表是否为空
- 排序
numbers.sort(); // 对列表进行默认升序排序
numbers.sort(Qt::DescendingOrder); // 对列表进行降序排序
- 复制和合并
QList<int> copy = numbers; // 复制列表
QList<int> merged = numbers + otherList; // 合并两个列表
numbers << 100 << 200; // 通过添加元素来合并列表
二、QVector
QVector
类似于 QList
,但适用于需要高效连续内存存储的情况。
#include <QVector>
int main() {
QVector<QString> names;
names << "Alice" << "Bob" << "Charlie";
// 使用索引访问元素
QString secondName = names[1]; // "Bob"
return 0;
}
QVector的常用的添加、修改、访问、修改、查找以及遍历元素的方式和QList是一致的,可以直接参考QList。
三、QMap
QMap
是一个关联数组,存储键-值对,键是唯一的,并按键的排序顺序排列。
#include <QMap>
int main() {
QMap<QString, int> ageMap;
ageMap.insert("Alice", 25);
ageMap.insert("Bob", 30);
ageMap.insert("Charlie", 28);
// 通过键访问值
int bobAge = ageMap.value("Bob"); // 30
return 0;
}
- 添加键值对
QMap<QString, int> ageMap;
ageMap.insert("Alice", 25);
ageMap.insert("Bob", 30);
ageMap["Charlie"] = 28; // 使用运算符重载添加键值对
- 访问值
int aliceAge = ageMap.value("Alice"); // 获取键为 "Alice" 的值
int bobAge = ageMap["Bob"]; // 使用键访问值
- 修改值
ageMap["Charlie"] = 29; // 修改键为 "Charlie" 的值
- 删除键值对
ageMap.remove("Alice"); // 移除键为 "Alice" 的键值对
ageMap.clear(); // 清空映射
- 检查键是否存在
bool containsBob = ageMap.contains("Bob"); // 检查是否包含键 "Bob"
- 遍历键值对
foreach (const QString &name, ageMap.keys()) {
int age = ageMap.value(name);
// 遍历所有键值对的键
}
QMapIterator<QString, int> i(ageMap);
while (i.hasNext()) {
i.next();
QString name = i.key();
int age = i.value();
// 使用迭代器遍历键值对
}
- 获取映射信息
int size = ageMap.size(); // 获取映射中键值对的数量
bool isEmpty = ageMap.isEmpty(); // 检查映射是否为空
-
排序
QMap 默认按照键的升序进行排序。如果需要自定义排序方式,可以使用自定义比较函数或者使用QMap::insertMulti()
来插入多个相同键的值。
ageMap.insertMulti("Alice", 24);
ageMap.insertMulti("Alice", 26);
// 现在 ageMap["Alice"] 会包含多个值
- 复制和合并
QMap<QString, int> copyMap = ageMap; // 复制映射
ageMap.unite(otherMap); // 合并映射,相同键的值会合并
四、QHash
QHash
是一个散列表,存储键-值对,具有快速查找性能,但不保持键的顺序。
#include <QHash>
int main() {
QHash<QString, QString> cityCountry;
cityCountry.insert("Paris", "France");
cityCountry.insert("Tokyo", "Japan");
cityCountry.insert("New York", "USA");
// 使用键查找值
QString tokyoCountry = cityCountry.value("Tokyo"); // "Japan"
return 0;
}
- 添加键值对
QHash<QString, int> ageHash;
ageHash.insert("Alice", 25);
ageHash.insert("Bob", 30);
ageHash["Charlie"] = 28; // 使用运算符重载添加键值对
- 访问值
int aliceAge = ageHash.value("Alice"); // 获取键为 "Alice" 的值
int bobAge = ageHash["Bob"]; // 使用键访问值
- 修改值
ageHash["Charlie"] = 29; // 修改键为 "Charlie" 的值
- 删除键值对
ageHash.remove("Alice"); // 移除键为 "Alice" 的键值对
ageHash.clear(); // 清空哈希表
- 检查键是否存在
bool containsBob = ageHash.contains("Bob"); // 检查是否包含键 "Bob"
- 遍历键值对
foreach (const QString &name, ageHash.keys()) {
int age = ageHash.value(name);
// 遍历所有键值对的键
}
QHashIterator<QString, int> i(ageHash);
while (i.hasNext()) {
i.next();
QString name = i.key();
int age = i.value();
// 使用迭代器遍历键值对
}
- 获取哈希表信息
int size = ageHash.size(); // 获取哈希表中键值对的数量
bool isEmpty = ageHash.isEmpty(); // 检查哈希表是否为空
- 复制和合并
QHash<QString, int> copyHash = ageHash; // 复制哈希表
ageHash.unite(otherHash); // 合并哈希表,相同键的值会合并
五、QSet
QSet
是一个无序集合,存储不重复的值。它不会保持特定的顺序
#include <QSet>
int main() {
QSet<int> numbers;
numbers << 3 << 5 << 7 << 5; // 注意:重复的值只会存储一次
// 判断值是否存在
bool containsSeven = numbers.contains(7); // true
return 0;
}
- 添加值
QSet<QString> names;
names.insert("Alice");
names.insert("Bob");
- 检查值是否存在
bool containsAlice = names.contains("Alice"); // 检查是否包含值 "Alice"
- 删除值
names.remove("Alice"); // 移除值 "Alice"
names.clear(); // 清空集合
- 遍历值
foreach (const QString &name, names) {
// 遍历所有值
}
QSetIterator<QString> i(names);
while (i.hasNext()) {
QString name = i.next();
// 使用迭代器遍历值
}
- 获取集合信息
int size = names.size(); // 获取集合中值的数量
bool isEmpty = names.isEmpty(); // 检查集合是否为空
- 复制和合并
QSet<QString> copySet = names; // 复制集合
names.unite(otherSet); // 合并集合,会保留不重复的值
六、QLinkedList
QLinkedList
是一个双向链表,适用于频繁插入和删除操作,但是在访问元素时性能相对较差。
#include <QLinkedList>
int main() {
QLinkedList<QString> names;
names << "Alice" << "Bob" << "Charlie";
// 在链表中插入元素
names.insert(names.begin(), "David");
// 从链表中移除元素
names.removeOne("Bob");
return 0;
}
- 添加元素
QLinkedList<QString> names;
names.append("Alice"); // 在末尾添加元素
names.prepend("Bob"); // 在开头添加元素
names.insert(++names.begin(), "Charlie"); // 在指定位置插入元素
- 访问元素
QString first = names.first(); // 获取第一个元素
QString last = names.last(); // 获取最后一个元素
- 修改元素
*names.begin() = "David"; // 修改第一个元素
- 删除元素
names.erase(names.begin()); // 移除第一个元素
names.removeOne("Charlie"); // 移除值为 "Charlie" 的元素
names.clear(); // 清空链表
- 遍历元素
foreach (const QString &name, names) {
// 遍历所有元素
}
QLinkedListIterator<QString> i(names);
while (i.hasNext()) {
QString name = i.next();
// 使用迭代器遍历元素
}
- 获取链表信息
int size = names.size(); // 获取链表中元素的数量
bool isEmpty = names.isEmpty(); // 检查链表是否为空
- 复制和合并
QLinkedList<QString> copyList = names; // 复制链表
names += otherList; // 合并链表
七、QStack
QStack
是一个堆栈,支持后进先出(LIFO)操作。
#include <QStack>
int main() {
QStack<int> stack;
stack.push(10);
stack.push(20);
stack.push(30);
// 弹出栈顶元素
int poppedValue = stack.pop(); // 30
return 0;
}
- 入栈
QStack<int> stack;
stack.push(10); // 将 10 入栈
stack.push(20); // 将 20 入栈
stack.push(30); // 将 30 入栈
- 出栈
int poppedValue = stack.pop(); // 弹出栈顶元素,poppedValue = 30
- 获取栈顶元素
int topValue = stack.top(); // 获取栈顶元素,但不弹出
- 检查栈是否为空
bool isEmpty = stack.isEmpty(); // 检查栈是否为空
- 获取栈的大小
int size = stack.size(); // 获取栈中元素的数量
- 遍历栈
while (!stack.isEmpty()) {
int value = stack.pop(); // 从栈中依次弹出所有元素
}
八、QQueue
QQueue
是一个队列,支持先进先出(FIFO)操作。
#include <QQueue>
int main() {
QQueue<QString> tasks;
tasks.enqueue("Task 1");
tasks.enqueue("Task 2");
tasks.enqueue("Task 3");
// 出队列
QString nextTask = tasks.dequeue(); // "Task 1"
return 0;
}
- 入队
QQueue<QString> tasks;
tasks.enqueue("Task 1"); // 将任务 1 入队
tasks.enqueue("Task 2"); // 将任务 2 入队
tasks.enqueue("Task 3"); // 将任务 3 入队
- 出队
QString dequeuedTask = tasks.dequeue(); // 出队一个任务,dequeuedTask = "Task 1"
- 获取队首元素
QString frontTask = tasks.first(); // 获取队首元素,但不出队
- 检查队列是否为空
bool isEmpty = tasks.isEmpty(); // 检查队列是否为空
- 获取队列的大小
int size = tasks.size(); // 获取队列中元素的数量
- 遍历对列
while (!tasks.isEmpty()) {
QString task = tasks.dequeue(); // 从队列中依次出队所有任务
}
九、QMultiMap
QMultiMap
是 Qt 中的一个关联数组集合类,允许一个键对应多个值。它类似于 QMap
,但不同的是它允许多个相同的键存在,并且会按照键的插入顺序保持排序。
#include <QMultiMap>
int main() {
QMultiMap<QString, int> scores;
scores.insert("Alice", 90);
scores.insert("Bob", 85);
scores.insert("Alice", 95);
// 获取所有 Alice 的分数
QList<int> aliceScores = scores.values("Alice"); // [90, 95]
return 0;
}
- 创建和添加键值对
QMultiMap<QString, int> scores;
scores.insert("Alice", 90);
scores.insert("Bob", 85);
scores.insert("Alice", 95); // 允许同一个键对应多个值
- 访问值
QList<int> aliceScores = scores.values("Alice"); // 获取键为 "Alice" 的所有值
- 遍历键值对
foreach (const QString &name, scores.uniqueKeys()) {
QList<int> values = scores.values(name);
// 遍历所有键值对的键,并获取对应的值列表
}
- 修改值
QList<int> aliceScores = scores.values("Alice");
if (!aliceScores.isEmpty()) {
scores.insert("Alice", aliceScores.first() + 5); // 修改第一个值
}
- 删除键值对
QList<int> aliceScores = scores.values("Alice");
if (!aliceScores.isEmpty()) {
scores.insert("Alice", aliceScores.first() + 5); // 修改第一个值
}
- 获取多重映射信息
int size = scores.size(); // 获取多重映射中键值对的数量
bool isEmpty = scores.isEmpty(); // 检查多重映射是否为空
十、QMultiHash
QMultiHash
是 Qt 中的一个散列表(哈希表)集合类,允许一个键对应多个值。与 QMultiMap
类似,但不同的是 QMultiHash
不会保持键的插入顺序。文章来源:https://www.toymoban.com/news/detail-675767.html
- 创建和添加键值对
QMultiHash<QString, int> scores;
scores.insert("Alice", 90);
scores.insert("Bob", 85);
scores.insert("Alice", 95); // 允许同一个键对应多个值
- 访问值
QList<int> aliceScores = scores.values("Alice"); // 获取键为 "Alice" 的所有值
- 遍历键值对
QList<QString> keys = scores.keys(); // 获取所有键
foreach (const QString &key, keys) {
QList<int> values = scores.values(key);
// 遍历所有键值对的键,并获取对应的值列表
}
- 修改值
QList<int> aliceScores = scores.values("Alice");
if (!aliceScores.isEmpty()) {
scores.insert("Alice", aliceScores.first() + 5); // 修改第一个值
}
- 删除键值对
scores.remove("Alice"); // 移除键为 "Alice" 的所有键值对
scores.remove("Alice", 95); // 移除键为 "Alice",值为 95 的键值对
scores.clear(); // 清空多重哈希
- 获取多重哈希信息
int size = scores.size(); // 获取多重哈希中键值对的数量
bool isEmpty = scores.isEmpty(); // 检查多重哈希是否为空
QMultiHash
提供了一种使用散列表来实现多重映射的方式,适用于需要一个键可以对应多个值的情况。与 QMultiMap
不同的是,QMultiHash
不会保持键的插入顺序,因此在需要快速查找的场景中可能更具有优势。无论是需要一对一映射还是一对多映射,都可以根据需求选择适当的集合类。文章来源地址https://www.toymoban.com/news/detail-675767.html
到了这里,关于c++ Qt框架中的各种集合详解的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!