行业资讯

C++常见容器如何使用

发布时间：2023-02-14 09:39:50 作者：iii
来源：亿速云 阅读：180

C++常见容器如何使用

目录

  1. 引言
  2. STL容器概述
  3. 序列容器
  4. 关联容器
  5. 无序关联容器
  6. 容器适配器
  7. 容器的选择与性能分析
  8. 总结

引言

C++标准模板库（STL）提供了丰富的容器类，用于存储和管理数据。这些容器不仅提供了高效的数据存储方式，还提供了多种操作接口，使得开发者能够方便地进行数据的插入、删除、查找等操作。本文将详细介绍C++中常见的容器类型及其使用方法，帮助读者更好地理解和应用这些容器。

STL容器概述

STL容器主要分为三大类：序列容器、关联容器和无序关联容器。此外，STL还提供了容器适配器，用于在特定场景下简化容器的使用。

序列容器

vector

vector 是一个动态数组，支持快速随机访问。它的大小可以动态调整，适合需要频繁插入和删除元素的场景。

基本操作

#include <vector>
#include <iostream>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // 访问元素
    std::cout << "Element at index 2: " << vec[2] << std::endl;

    // 添加元素
    vec.push_back(6);

    // 删除元素
    vec.pop_back();

    // 遍历元素
    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

性能分析

deque

deque 是一个双端队列，支持在两端快速插入和删除元素。它结合了vector和list的优点，适合需要频繁在两端操作元素的场景。

基本操作

#include <deque>
#include <iostream>

int main() {
    std::deque<int> deq = {1, 2, 3, 4, 5};

    // 在头部插入元素
    deq.push_front(0);

    // 在尾部插入元素
    deq.push_back(6);

    // 删除头部元素
    deq.pop_front();

    // 删除尾部元素
    deq.pop_back();

    // 遍历元素
    for (int i : deq) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

性能分析

list

list 是一个双向链表，支持在任意位置快速插入和删除元素。由于链表的特性，list不支持随机访问，适合需要频繁在中间插入和删除元素的场景。

基本操作

#include <list>
#include <iostream>

int main() {
    std::list<int> lst = {1, 2, 3, 4, 5};

    // 在头部插入元素
    lst.push_front(0);

    // 在尾部插入元素
    lst.push_back(6);

    // 在中间插入元素
    auto it = lst.begin();
    std::advance(it, 2);
    lst.insert(it, 7);

    // 删除元素
    lst.pop_front();
    lst.pop_back();

    // 遍历元素
    for (int i : lst) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

性能分析

forward_list

forward_list 是一个单向链表，只支持从头部插入和删除元素。由于单向链表的特性，forward_list比list更节省内存，适合需要频繁在头部操作元素的场景。

基本操作

#include <forward_list>
#include <iostream>

int main() {
    std::forward_list<int> flst = {1, 2, 3, 4, 5};

    // 在头部插入元素
    flst.push_front(0);

    // 删除头部元素
    flst.pop_front();

    // 遍历元素
    for (int i : flst) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

性能分析

array

array 是一个固定大小的数组，支持快速随机访问。由于大小固定，array适合需要固定大小数组的场景。

基本操作

#include <array>
#include <iostream>

int main() {
    std::array<int, 5> arr = {1, 2, 3, 4, 5};

    // 访问元素
    std::cout << "Element at index 2: " << arr[2] << std::endl;

    // 遍历元素
    for (int i : arr) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

性能分析

关联容器

set

set 是一个有序集合，元素按升序排列且唯一。set基于红黑树实现，适合需要快速查找和去重的场景。

基本操作

#include <set>
#include <iostream>

int main() {
    std::set<int> s = {1, 2, 3, 4, 5};

    // 插入元素
    s.insert(6);

    // 删除元素
    s.erase(3);

    // 查找元素
    auto it = s.find(4);
    if (it != s.end()) {
        std::cout << "Element found: " << *it << std::endl;
    }

    // 遍历元素
    for (int i : s) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

性能分析

multiset

multiset 是一个有序集合，元素按升序排列且允许重复。multiset基于红黑树实现，适合需要快速查找和允许重复元素的场景。

基本操作

#include <set>
#include <iostream>

int main() {
    std::multiset<int> ms = {1, 2, 2, 3, 4, 5};

    // 插入元素
    ms.insert(2);

    // 删除元素
    ms.erase(2);

    // 查找元素
    auto it = ms.find(3);
    if (it != ms.end()) {
        std::cout << "Element found: " << *it << std::endl;
    }

    // 遍历元素
    for (int i : ms) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

性能分析

map

map 是一个有序键值对集合，键按升序排列且唯一。map基于红黑树实现，适合需要快速查找和去重的键值对场景。

基本操作

#include <map>
#include <iostream>

int main() {
    std::map<std::string, int> m = {{"apple", 1}, {"banana", 2}, {"cherry", 3}};

    // 插入元素
    m.insert({"date", 4});

    // 删除元素
    m.erase("banana");

    // 查找元素
    auto it = m.find("cherry");
    if (it != m.end()) {
        std::cout << "Element found: " << it->second << std::endl;
    }

    // 遍历元素
    for (const auto& pair : m) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    return 0;
}

性能分析

multimap

multimap 是一个有序键值对集合，键按升序排列且允许重复。multimap基于红黑树实现，适合需要快速查找和允许重复键的场景。

基本操作

#include <map>
#include <iostream>

int main() {
    std::multimap<std::string, int> mm = {{"apple", 1}, {"banana", 2}, {"banana", 3}, {"cherry", 4}};

    // 插入元素
    mm.insert({"date", 5});

    // 删除元素
    mm.erase("banana");

    // 查找元素
    auto it = mm.find("cherry");
    if (it != mm.end()) {
        std::cout << "Element found: " << it->second << std::endl;
    }

    // 遍历元素
    for (const auto& pair : mm) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    return 0;
}

性能分析

无序关联容器

unordered_set

unordered_set 是一个无序集合，元素不按特定顺序排列且唯一。unordered_set基于哈希表实现，适合需要快速查找和去重的场景。

基本操作

#include <unordered_set>
#include <iostream>

int main() {
    std::unordered_set<int> us = {1, 2, 3, 4, 5};

    // 插入元素
    us.insert(6);

    // 删除元素
    us.erase(3);

    // 查找元素
    auto it = us.find(4);
    if (it != us.end()) {
        std::cout << "Element found: " << *it << std::endl;
    }

    // 遍历元素
    for (int i : us) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

性能分析

unordered_multiset

unordered_multiset 是一个无序集合，元素不按特定顺序排列且允许重复。unordered_multiset基于哈希表实现，适合需要快速查找和允许重复元素的场景。

基本操作

#include <unordered_set>
#include <iostream>

int main() {
    std::unordered_multiset<int> ums = {1, 2, 2, 3, 4, 5};

    // 插入元素
    ums.insert(2);

    // 删除元素
    ums.erase(2);

    // 查找元素
    auto it = ums.find(3);
    if (it != ums.end()) {
        std::cout << "Element found: " << *it << std::endl;
    }

    // 遍历元素
    for (int i : ums) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    return 0;
}

性能分析

unordered_map

unordered_map 是一个无序键值对集合，键不按特定顺序排列且唯一。unordered_map基于哈希表实现，适合需要快速查找和去重的键值对场景。

基本操作

#include <unordered_map>
#include <iostream>

int main() {
    std::unordered_map<std::string, int> um = {{"apple", 1}, {"banana", 2}, {"cherry", 3}};

    // 插入元素
    um.insert({"date", 4});

    // 删除元素
    um.erase("banana");

    // 查找元素
    auto it = um.find("cherry");
    if (it != um.end()) {
        std::cout << "Element found: " << it->second << std::endl;
    }

    // 遍历元素
    for (const auto& pair : um) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    return 0;
}

性能分析

unordered_multimap

unordered_multimap 是一个无序键值对集合，键不按特定顺序排列且允许重复。unordered_multimap基于哈希表实现，适合需要快速查找和允许重复键的场景。

基本操作

#include <unordered_map>
#include <iostream>

int main() {
    std::unordered_multimap<std::string, int> umm = {{"apple", 1}, {"banana", 2}, {"banana", 3}, {"cherry", 4}};

    // 插入元素
    umm.insert({"date", 5});

    // 删除元素
    umm.erase("banana");

    // 查找元素
    auto it = umm.find("cherry");
    if (it != umm.end()) {
        std::cout << "Element found: " << it->second << std::endl;
    }

    // 遍历元素
    for (const auto& pair : umm) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    return 0;
}

性能分析

容器适配器

stack

stack 是一个后进先出（LIFO）的容器适配器，基于deque实现。stack适合需要后进先出操作的场景。

基本操作

#include <stack>
#include <iostream>

int main() {
    std::stack<int> stk;

    // 压入元素
    stk.push(1);
    stk.push(2);
    stk.push(3);

    // 弹出元素
    stk.pop();

    // 访问栈顶元素
    std::cout << "Top element: " << stk.top() << std::endl;

    // 遍历元素
    while (!stk.empty()) {
        std::cout << stk.top() << " ";
        stk.pop();
    }
    std::cout << std::endl;

    return 0;
}

性能分析

queue

queue 是一个先进先出（FIFO）的容器适配器，基于deque实现。queue适合需要先进先出操作的场景。

基本操作

#include <queue>
#include <iostream>

int main() {
    std::queue<int> q;

    // 压入元素
    q.push(1);
    q.push(2);
    q.push(3);

    // 弹出元素
    q.pop();

    // 访问队首元素
    std::cout << "Front element: " << q.front() << std::endl;

    // 遍历元素
    while (!q.empty()) {
        std::cout << q.front() << " ";
        q.pop();
    }
    std::cout << std::endl;

    return 0;
}

性能分析

priority_queue

priority_queue 是一个优先队列，元素按优先级排列。priority_queue基于vector实现，适合需要按优先级处理元素的场景。

基本操作

”`cpp #include #include

int main() { std::priority_queue pq;

// 压入元素
pq.push(3);
pq.push(1);
pq.push(4);
pq.push(2);

// 弹出元素
pq.pop();
推荐阅读：
  1. C++字符函数、数字函数和日期函数的说明
  2. python和C++语言有何优缺点

免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。

c++

上一篇：openGauss的SCHEMA的原理及管理方法是什么

下一篇：Flutter配置代理抓包如何实现

相关阅读

您好，登录后才能下订单哦！

密码登录
登录注册
获取短信验证码
其他方式登录
点击 登录注册 即表示同意《亿速云用户服务条款》
产品服务
地区划分
帮助支持
关于我们
行业资讯-文章归档 问答-问答归档
广州亿速云计算有限公司

7*24小时在线电话：400-100-2938

7*24小时在线QQ：800811969

Copyright © Yisu Cloud Ltd. All Rights Reserved. 2018 版权所有
粤ICP备17096448号-1 粤公网安备 44010402001142号