C++ STL 容器与 Qt 容器对比及选型建议

C++ STL 容器与 Qt 容器对比及选型建议 | 极客日志

#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3}; // 初始化
    vec.push_back(4); // 尾部插入，O(1)
    std::cout << vec[0] << std::endl; // 随机访问，O(1)
    return 0;
}

#include <list>
#include <iostream>

int main() {
    std::list<int> lst = {1, 2, 3}; // 初始化
    auto it = lst.begin();
    ++it;
    lst.insert(it, 4); // 在位置插入，O(1)
    for (int n : lst) std::cout << n << " "; // 遍历
    return 0;
}

#include <deque>
#include <iostream>

int main() {
    std::deque<int> dq = {1, 2, 3}; // 初始化
    dq.push_front(0); // 头部插入，O(1)
    dq.push_back(4); // 尾部插入，O(1)
    std::cout << dq[1] << std::endl; // 随机访问，O(1)
    return 0;
}

#include <set>
#include <iostream>

int main() {
    std::set<int> s;
    s.insert(3); // 插入，O(log n)
    s.insert(1);
    s.insert(2);
    if (s.find(2) != s.end()) std::cout << "Found" << std::endl; // 查找，O(log n)
    return 0;
}

#include <set>
#include <iostream>

int main() {
    std::multiset<int> ms;
    ms.insert(1); // 插入，O(log n)
    ms.insert(1); // 允许重复
    std::cout << ms.count(1) << std::endl; // 计数，O(log n)
    return 0;
}

#include <map>
#include <iostream>

int main() {
    std::map<std::string, int> m;
    m["apple"] = 1; // 插入或更新，O(log n)
    m["banana"] = 2;
    std::cout << m["apple"] << std::endl; // 查找，O(log n)
    return 0;
}

#include <map>
#include <iostream>

int main() {
    std::multimap<std::string, int> mm;
    mm.insert({"fruit", 1}); // 插入，O(log n)
    mm.insert({"fruit", 2}); // 键可重复
    auto range = mm.equal_range("fruit"); // 查找所有值
    for (auto it = range.first; it != range.second; ++it) {
        std::cout << it->second << " ";
    }
    return 0;
}

#include <stack>
#include <iostream>

int main() {
    std::stack<int> st;
    st.push(1); // 压栈，O(1)
    st.push(2);
    std::cout << st.top() << std::endl; // 查看栈顶，O(1)
    st.pop(); // 出栈，O(1)
    return 0;
}

#include <queue>
#include <iostream>

int main() {
    std::queue<int> q;
    q.push(1); // 入队，O(1)
    q.push(2);
    std::cout << q.front() << std::endl; // 查看队头，O(1)
    q.pop(); // 出队，O(1)
    return 0;
}

#include <queue>
#include <iostream>

int main() {
    std::priority_queue<int> pq; // 默认最大堆
    pq.push(3); // 插入，O(log n)
    pq.push(1);
    pq.push(2);
    std::cout << pq.top() << std::endl; // 顶部元素，O(1)
    pq.pop(); // 删除顶部，O(log n)
    return 0;
}

#include <QList>
#include <QDebug>

void testQList() {
    // 创建 QList 并添加元素
    QList<QString> list;
    list.append("apple");
    list.append("banana");
    list.append("cherry");
    // 使用<<操作符添加元素
    list << "date" << "elderberry";
    // 访问元素
    qDebug() << "第一个元素:" << list.first(); // 或 list[0]
    qDebug() << "最后一个元素:" << list.last(); // 或 list[list.size()-1]
    // 遍历元素 - 使用索引
    for (int i = 0; i < list.size(); ++i) {
        qDebug() << "元素" << i << ":" << list[i];
    }
    // 遍历元素 - 使用迭代器
    QList<QString>::const_iterator it;
    for (it = list.begin(); it != list.end(); ++it) {
        qDebug() << "迭代器元素:" << *it;
    }
    // 遍历元素 - 使用 foreach
    foreach (const QString &str, list) {
        qDebug() << "foreach 元素:" << str;
    }
    // 修改元素
    list[1] = "blueberry";
    // 插入元素
    list.insert(2, "grape");
    // 删除元素
    list.removeAt(3);
    // 检查元素是否存在
    bool exists = list.contains("apple");
    // 查找元素位置
    int index = list.indexOf("cherry");
}

#include <QLinkedList>

void testQLinkedList() {
    QLinkedList<int> linkedList;
    // 添加元素
    linkedList.append(10);
    linkedList.prepend(5);
    linkedList.insert(linkedList.end(), 15);
    // 遍历元素
    for (QLinkedList<int>::const_iterator it = linkedList.begin(); it != linkedList.end(); ++it) {
        qDebug() << *it;
    }
    // 删除元素
    linkedList.removeFirst();
    linkedList.removeLast();
    // 判断链表是否为空
    bool isEmpty = linkedList.isEmpty();
}

#include <QVector>

void testQVector() {
    QVector<double> vector;
    // 预分配空间
    vector.reserve(100);
    // 添加元素
    for (int i = 0; i < 10; ++i) {
        vector.append(i * 0.1);
    }
    // 访问元素
    double value = vector[5];
    // 调整大小
    vector.resize(15); // 多余的元素将被默认构造
    vector.resize(8); // 超出部分将被截断
    // 快速填充
    vector.fill(1.0);
}

#include <QMap>

void testQMap() {
    QMap<QString, int> map;
    // 添加元素
    map["apple"] = 1;
    map["banana"] = 2;
    map["cherry"] = 3;
    // 另一种添加元素的方式
    map.insert("date", 4);
    // 访问元素
    int value = map["apple"]; // 如果键不存在，会插入一个默认值
    int value2 = map.value("banana"); // 更安全的访问方式
    int defaultValue = map.value("grape", 0); // 指定默认值
    // 检查键是否存在
    bool exists = map.contains("cherry");
    // 遍历元素 - 按键的顺序
    QMap<QString, int>::const_iterator it;
    for (it = map.begin(); it != map.end(); ++it) {
        qDebug() << "键:" << it.key() << "值:" << it.value();
    }
    // 删除元素
    map.remove("banana");
    // 获取所有键和值
    QList<QString> keys = map.keys();
    QList<int> values = map.values();
}

#include <QHash>

void testQHash() {
    QHash<QString, int> hash;
    // 添加元素
    hash["apple"] = 1;
    hash["banana"] = 2;
    hash["cherry"] = 3;
    // 访问元素
    int value = hash["apple"];
    // 检查键是否存在
    bool exists = hash.contains("cherry");
    // 遍历元素 - 无序
    QHash<QString, int>::const_iterator it;
    for (it = hash.begin(); it != hash.end(); ++it) {
        qDebug() << "键:" << it.key() << "值:" << it.value();
    }
    // 删除元素
    hash.remove("banana");
    // 获取键的数量
    int size = hash.size();
}

#include <QMultiMap>

void testQMultiMap() {
    QMultiMap<QString, int> multiMap;
    // 添加多个值
    multiMap.insert("apple", 1);
    multiMap.insert("apple", 2);
    multiMap.insert("apple", 3);
    // 获取所有值
    QList<int> values = multiMap.values("apple");
    // 遍历所有键值对
    QMultiMap<QString, int>::const_iterator it;
    for (it = multiMap.begin(); it != multiMap.end(); ++it) {
        qDebug() << "键:" << it.key() << "值:" << it.value();
    }
    // 删除所有"apple"的键值对
    multiMap.remove("apple");
}

操作	QList	QLinkedList	QVector
随机访问	极快	很慢	极快
头部插入/删除	快（如果预分配）	极快	慢
尾部插入/删除	极快	极快	极快
中间插入/删除	慢	快	慢
内存预分配	支持	不支持	支持

操作	QMap	QHash
插入	较慢（红黑树）	极快（哈希表）
查找	较慢（O(log n))	极快（平均 O(1))
删除	较慢（红黑树）	极快（哈希表）
有序性	有序	无序
键的类型要求	必须支持<运算符	必须支持==运算符和 qHash() 函数

C++ STL 容器与 Qt 容器对比及选型建议

一、前言

1.1 标准模板库（STL）容器

1.2 Qt 容器

1.3 比较

通用性 vs 特定功能

性能

使用场景

1.4 结论

二、C++ STL 标准库容器介绍

2.1 简介

2.2 顺序容器

2.2.1 vector（向量）

2.2.2 list（链表）

2.2.3 deque（双端队列）

2.3 关联容器

2.3.1 set（集合）

2.3.2 multiset（多重集合）

2.3.3 map（映射）

2.3.4 multimap（多重映射）

2.4 容器适配器

2.4.1 stack（栈）

2.4.2 queue（队列）

2.4.3 priority_queue（优先队列）

2.5 总结

三、Qt 容器介绍

3.1 顺序容器

3.1.1 QList（数组列表）

3.1.2 QLinkedList（双向链表）

3.1.3 QVector (向量)

3.1.4 QStack / QQueue

3.2 关联容器

3.2.1 QMap<Key, T> 映射

3.2.2 QHash<Key, T>

3.2.3 QSet

3.2.4 QMultiMap 和 QMultiHash

3.3 字符串专用容器

QStringList

3.4 性能比较

3.4.1 顺序容器性能比较

3.4.2 关联容器性能比较

3.4.3 Qt 容器选择建议

四、对比与建议

1. 设计理念

2. 性能

3. 接口和易用性

4. 兼容性

5. 适用场景

6. 总结

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具