C++11 标准库 STL

已于 2024-09-12 14:38:20 修改
阅读量791 收藏 20
点赞数 24
文章标签： c++
于 2024-09-11 08:49:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/waltWu0705/article/details/142123009
版权

STL 中的容器是用来存储和管理对象集合的类。容器根据其内部数据结构和访问方式可以分为三大类：顺序容器、关联容器和无序关联容器。下面是对这些容器的详细介绍

1. 顺序容器（Sequence Containers）

顺序容器用于按特定顺序存储元素。主要包括以下几种

1.1 *std::vector

• 特点：动态数组，支持快速随机访问，插入和删除操作在末尾很快，但在中间或前面插入和删除速度较慢(中间插入/删除用list)。

• 使用场景：需要动态调整大小且频繁进行随机访问(list/deque不支持这个功能)的场景。

	    #include <vector>
		#include <iostream>
		int main() {
		    std::vector<int> vec = {1, 2, 3, 4, 5};
		    vec.push_back(6); // 在末尾添加元素
		    for (int val : vec) {
		        std::cout << val << " ";
		    }
		    return 0;
		}

1.2 std::deque

• 特点：双端队列，支持快速随机访问，允许在两端进行快速插入和删除操作。

• 使用场景：需要在两端插入和删除元素的场景。

#include <deque>
		#include <iostream>
		int main() {
		    std::deque<int> deq = {1, 2, 3, 4, 5};
		    deq.push_front(0); // 在前面添加元素
		    deq.push_back(6);  // 在末尾添加元素
		    for (int val : deq) {
		        std::cout << val << " ";
		    }
		    return 0;
		}

如定义一个task队列， 从队列的尾部添加新的task，从队列的头部开始执行task

template <class T>
class TaskQueue {
 public:
  TaskQueue() {}
  virtual ~TaskQueue() {}

  void AppendTask(T task) {
    Lock lock(mutex_);
    tasks_.push_back(task);
  }

  void TriggerAllTask() {
    Lock lock(mutex_);
    while (!tasks_.empty()) {
      T task = tasks_.front();
      tasks_.pop_front();
      mutex_.Unlock();

      task();
      mutex_.Lock();
    }
  }

  void pop_front() {
    Lock lock(mutex_);
    if (!tasks_.empty()) {
      T task = tasks_.front();
      tasks_.pop_front();
      mutex_.Unlock();
      task();
    }
  }
 protected:
  std::deque<T> tasks_;
  PthreadMutex mutex_;
};

实例化上面的task如下：

class MsgTaskQueue
{
    public:
    static MsgTaskQueue& Instance() {
        static MsgTaskQueue instance;
        return instance;
    }
    void RemoveTask(const std::string uuId) {
        std::lock_guard<std::mutex> lockGuard(mutex_);
        for (std::deque<MsgTaskQueue>::iterator iter = tasks_.begin();
             iter != tasks_.end();) {
          if (iter->uuId == uuId) {
            iter = tasks_.erase(iter);
          } else {
            ++iter;
          }
        }
    }

    void AppendTask(MsgTaskQueuetask) {
        std::lock_guard<std::mutex> lockGuard(mutex_);
        tasks_.push_back(task);
    }


    void PopFront() {
        std::lock_guard<std::mutex> lockGuard(mutex_);
        if (!tasks_.empty()) {
           MsgTaskQueue task = tasks_.front();
            tasks_.pop_front();
            mutex_.unlock();
            task();
        }
    }


    protected:
    std::deque<MsgTaskQueue> tasks_;
    std::mutex mutex_;
};

1.3 ** std::list

• 特点：双向链表，支持快速插入和删除操作，但不支持随机访问。

• 使用场景：需要频繁在中间插入和删除元素的场景。

#include <list>
		#include <iostream>
		int main() {
		    std::list<int> lst = {1, 2, 3, 4, 5};
		    lst.push_back(6); // 在末尾添加元素
		    lst.push_front(0); // 在前面添加元素
		    for (int val : lst) {
		        std::cout << val << " ";
		    }
		    return 0;
		}

1.4 std::forward_list

特点：单向链表，只能向前遍历，内存开销比 std::list 小。

• 使用场景：需要轻量级的链表结构且只需向前遍历的场景。

1.5 std::array

特点：固定大小的数组，大小在编译时确定

使用场景：需要固定大小数组且不需要动态调整大小的场景。

#include <array>
		#include <iostream>
		int main() {
		    std::array<int, 5> arr = {1, 2, 3, 4, 5};
		    for (int val : arr) {
		        std::cout << val << " ";
		    }
		    return 0;
		}

1.6 std::vector<bool>

• 特点：特殊化的 std::vector，用于存储布尔值。

• 注意：由于实现方式的不同，std::vector<bool> 不能像其他 std::vector 那样直接访问元素

#include <vector>
		#include <iostream>
		int main() {
		    std::vector<bool> vec = {true, false, true};
		    for (bool val : vec) {
		        std::cout << val << " ";
		    }
		    return 0;
		}

2.关联容器（Associative Containers）

关联容器用于以键值对的形式存储元素，并基于键进行快速查找

2.1 std::set

• 特点：存储唯一的键，自动排序。

• 使用场景：需要存储唯一元素并快速查找的场景。

#include <set>
		#include <iostream>
		int main() {
			std::cout << " main started" << std::endl;
		    std::set<int> s = {1, 2, 7, 4, 5};
		    
		    for (int val : s) {
		        std::cout << val << " ";
		    }
		    return 0;
		}
output:
 main started
1 2 4 5 7

2.2 std::map

• 特点：存储键值对，键唯一且自动排序。

• 使用场景：需要根据键快速查找值的场景。

#include <map>
		#include <iostream>
		int main() {
		    std::map<int, std::string> m = {{1, "one"}, {7, "two"}, {3, "three"}};
		
		    for (const auto& [key, val] : m) {
		        std::cout << key << ": " << val << std::endl;
		    }
		    return 0;
		}

1: one
3: three
7: two

2.3 std::multiset

• 特点：存储可重复的键，自动排序。

• 使用场景：需要存储重复元素并快速查找的场景。

2.4 std::multimap

• 特点：存储键值对，键可重复且自动排序。

• 使用场景：需要根据键快速查找多个值的场景。

3. 无序关联容器（Unordered Associative Containers）

无序关联容器通过哈希表实现，支持更快的平均查找速度

3.1 std::unordered_set

3.2 std::unordered_map

3.3 std::unordered_multiset

3.4 std::unordered_multimap

4.迭代器的使用

4.1 访问迭代器中的值

* 解引用

->

4.2 基本用法（注意：删除其中的某个数据）

4.2.1 遍历

#include <iostream>
#include <vector>

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

    // 使用普通迭代器遍历
    for (std::vector<int>::iterator it = vec.begin(); it != vec.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    // 使用范围 for 循环（C++11 引入）
    for (int val : vec) {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    return 0;
}

4.2.2 修改（访问其中的数据）

vector/list：

使用* 或者->

#include <iostream>
#include <vector>

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

    for (std::vector<int>::iterator it = vec.begin(); it != vec.end(); ++it) {
        *it *= 2; // 将每个元素乘以 2
    }

    for (int val : vec) {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    return 0;
}

map:

使用iter->second;

4.2.2.1 注意删除操作
1. 从 std::vector 删除元素

std::vector 的删除操作会导致后续元素移动，从而使迭代器失效。解决办法是使用 erase 方法的返回值来更新迭代器

#include <iostream>
#include <vector>

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

    for (std::vector<int>::iterator it = vec.begin(); it != vec.end(); /* 空 */) {
        if (*it % 2 == 0) {
            it = vec.erase(it); // 更新迭代器
        } else {
            ++it; // 仅在没有删除时递增迭代器
        }
    }

    for (int val : vec) {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    return 0;
}
2. 从 std::list 删除元素

std::list 的删除操作不会使其他迭代器失效，但仍需要更新当前迭代器。

#include <iostream>
#include <list>

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

    for (std::list<int>::iterator it = lst.begin(); it != lst.end(); /* 空 */) {
        if (*it % 2 == 0) {
            it = lst.erase(it); // 更新迭代器
        } else {
            ++it; // 仅在没有删除时递增迭代器
        }
    }

    for (int val : lst) {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    return 0;
}
3. 从 std::map 或 std::unordered_map 删除元素

std::map 和 std::unordered_map 的删除操作也不会使其他迭代器失效，但需要更新当前迭代器。

#include <iostream>
#include <map>

int main() {
    std::map<int, std::string> myMap = {{1, "one"}, {2, "two"}, {3, "three"}, {4, "four"}};

    for (auto it = myMap.begin(); it != myMap.end(); /* 空 */) {
        if (it->first % 2 == 0) {
            it = myMap.erase(it); // 更新迭代器
        } else {
            ++it; // 仅在没有删除时递增迭代器
        }
    }

    for (const auto& pair : myMap) {
        std::cout << pair.first << ": " << pair.second << " ";
    }
    std::cout << std::endl;

    return 0;
}
4.2.2.2 遍历过程插入数据

对于vector/list

#include <iostream>
#include <vector>

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

    // 在遍历过程中插入数据
    for (auto it = vec.begin(); it != vec.end(); ++it) {
        if (*it == 3) {
            it = vec.insert(it, 99); // 在元素3之前插入99
            ++it; // 移动迭代器到下一个位置
        }
    }

    for (int val : vec) {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    return 0;
}

5.map与unordered_map（红黑树VS哈希表）

map ： map内部实现了一个红黑树（红黑树是非严格平衡二叉搜索树，），红黑树具有自动排序的功能，因此map内部的所有元素都是 有序 的.
缺点：
因为红黑树结构需要额外的内存来存储树节点的指针和其他信息，所以 内存占用较高。
由于需要保持有序性，所以 插入和删除性能较低：
优点：
有序性，这是 map 结构最大的优点；
红黑树，内部实现一个红黑书使得 map 的很多操作在 lgn的时间复杂度下就可以实现，因此效率可以(但又因为保证有序性，所以)

适用场景

1. 需要有序或范围查询的访问：例如需要按键排序输出或范围查询。

2. 查找、插入和删除操作频繁：但对性能要求不是极限

假设需要管理一个学生成绩的系统，并且需要按成绩排序输出：

unordered_map : unordered_map 内部实现了一个哈希表（也叫散列表，通过把关键码值映射到
Hash 表中一个位置来访问记录，查找的时间复杂度可达到 O(1) ，其在海量数据处理中有着广泛应
用）。因此，其元素的排列顺序是无序的。
1. 优点：
因为内部实现了哈希表，因此其插入/查找/删除的速度非常的快；
哈希表结构相对简单，内存占用较低
2. 缺点：
无序； 不支持有序遍历
哈希表的建立比较耗费时间
3. 适用场景

不需要有序访问：例如快速查找某个键值对。

对性能要求较高：需要快速插入、删除和查找操作。

假设需要管理一个产品库存系统，并且需要快速查找某个产品的库存数量：

waltWu0705
关注
  • 24
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++标准库STL源码
03-24
它是C++标准库的一个重要实现,对STL的发展和推广产生了重大影响。 SGI STL的源码是开源的,其设计和实现体现了诸多优秀的编程思想和技巧。下面是对SGI STL源码的一些关键特点和描述:泛型编程、算法与容器的分离、...
【STL源代码】C++标准库STL源代码下载
09-05
STL，全称为Standard Template Library，是C++标准库的核心部分，它提供了一组高效、通用的容器、迭代器、算法和函数对象。在【STL源代码】中，我们可以深入学习并理解这些组件的实现细节，从而提高编程技能和效率。...
C++ 标准模板库STL
热门推荐
kyle的博客
06-11 2万+
C++ STL标准模板库详解
掌握C++11标准库(STL)：理解STL的核心概念
Lion_Long的博客
01-01 1317
STL定义了强大的、基于模板的、可复用的组件，实现了许多通用的数据结构及处理这些数据结构的算法。其中包含三个关键组件——容器（container，流行的模板数据结构）、迭代器（iterator）和算法（algorithm）。
C++ - STL标准库
weixin_49303682的博客
12-25 1万+
1.C++ STL标准库简介 长久以来，软件界一直希望建立一种可重复利用的东西，以及一种得以制造出”可重复运用的东西” 的方法，从函数(functions)，类别(classes),函数库(function libraries),类别库(class libraries)、各种 组件，从模块化设计，到面向对象(object oriented )，为的就是复用性的提升。 复用性必须建立在某种标准之上。但是在许多环境下，就连软件开发最基本的数据结构(data structures) 和算法(algori
C++ - 标准库（STL）
m0_54386352的博客
05-02 1981
C++标准库是C++编程语言的标准程式库，它提供了一个通用的容器类、算法和函数模板库。其中包括了多种容器类型，例如：向量（vector）、双向链表（deque）、列表（list）、集合（set）和映射（map）等，各种容器类型均具备不同的优缺点和使用场景，STL还提供了许多算法和函数模板，使程序员能够轻松地完成一些常见的操作，例如排序、搜索、遍历和数据转换等。可以通过使用STL，从而提高代码的可读性和可维护性。
C++ STL标准库
C++++ ++
05-23 8853
STL 组件 STL 是 C++ 标准程序库的核心。STL 内的所有组件都由模板构成，其元素可以是任意型别。程序员通过选用恰当的群集类别调用其成员函数和算法中的数据即可，但代价是 STL 晦涩难懂。 STL 组件主要包括容器，迭代器、算法和仿函数。 容器 容器即用来存储并管理某类对象的集合。每一种容器都有其优点和缺点。为满足程序的各种需求，STL 准备了多种容器类型，容器可以是 arrays 或是 linked lists，或者每个元素有特别的键值。 迭代器 迭代器用于在一个对象群集的元素上进行遍历动作。对
《C++语言 - 标准模板库STL》_标准模板库_C++_C++STL_
09-29
STL是C++标准库的一个核心部分，极大地提升了代码的可读性和复用性，使得开发者能够更加专注于解决问题本身，而不是底层的实现细节。 STL主要由以下四个主要组件构成： 1. 容器（Containers）：容器是用来存储和...
boost-STL.rar_Boost_C++标准库_STL_c 标准库_chm
09-21
Boost.STL是Boost库的一个重要组成部分，它是对C++标准库STL（Standard Template Library）的扩展和增强，旨在提供更高效、功能更丰富的容器、迭代器、算法和函数对象。Boost库本身是一个开源的C++库集合，其目标是...
C++与QML的数据交互
最新发布
qq_50679120的博客
09-11 336
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
【C++】vector的简单模拟实现
2303_80828380的博客
09-05 1279
vector的简单模拟实现！！！
【C++】CLion配置cout打印语句快捷键
qq_38196449的博客
09-10 190
当我们sout时，自动出现打印语句。点击Apply 和 OK 保存。
C语言 | Leetcode C语言题解之第389题找不同
m0_59237910的博客
09-07 536
C语言 | Leetcode C语言题解之第389题找不同
QWidget(c++)嵌入window环境的exe
sunflower_2020的博客
09-05 303
QWidget(c++)嵌入window环境的exe
C语言初阶 --- ⾃定义类型：结构体
2301_79842589的博客
09-08 952
💫往期文章👇：
C语言作用域
天道酬勤
09-07 977
作用域 (scope) 是描述程序可以访问标识符的区域。块是一对花括号 {} 括起来的区域 或 函数体内任意复合语句定义范围内的区域。定义在块中的变量具有块作用域。块作用域的变量的可见范围从定义处开始到该块定义范围的末尾为止。函数作用域是在整个函数体内可见的意思，在 C 程序中，函数形参和 goto 语句的标签具有函数作用域，在整个函数体内可见。在所有函数外定义的变量具有全局作用域，在整个程序都可见。在数据类型前加 static 关键字定义的全局变量具有文件作用域。
C和指针：标准函数库
暮色年华的博客
09-11 463
longjmp 函数:一旦在程序的其他部分遇到了 longjmp 调用，并且传入了之前 setjmp 初始化的 jmp_buf 数组以及一个非零值作为跳转值，那么程序的控制就会立即跳回到与那个 jmp_buf 关联的 setjmp 处。setjmp 函数：一个函数中调用 setjmp 并传递一个类型为 jmp_buf 的数组作为参数时，setjmp 将会保存当前程序执行环境的一个快照（包括处理器寄存器和程序计数器等状态信息）到这个 jmp_buf 数组中。如果在某个低层的函数中检测到一个错误，你可以立。
完全背包（C++）
lim6ere的博客
09-11 604
DP42 【模板】完全背包以上就是今天要讲的内容，本文仅仅详细介绍了。希望对大家的学习有所帮助，仅供参考 如有错误请大佬指点我会尽快去改正 欢迎大家来评论~~ 😘 😘 😘。
C++二叉查找树类层序遍历
07-28
您好！对于C++的二叉查找树类，可以使用层序遍历算法来遍历树的节点。下面是一个示例代码： ```cpp #include <iostream> #include <queue> using namespace std; // 二叉查找树节点类 class TreeNode { public: int val; TreeNode* left; TreeNode* right; TreeNode(int value) { val = value; left = nullptr; right = nullptr; } }; // 层序遍历函数 void levelOrderTraversal(TreeNode* root) { if (root == nullptr) { return; } queue<TreeNode*> q; q.push(root); while (!q.empty()) { TreeNode* node = q.front(); q.pop(); cout << node->val << " "; if (node->left != nullptr) { q.push(node->left); } if (node->right != nullptr) { q.push(node->right); } } } int main() { // 创建一个二叉查找树 TreeNode* root = new TreeNode(4); root->left = new TreeNode(2); root->right = new TreeNode(6); root->left->left = new TreeNode(1); root->left->right = new TreeNode(3); root->right->left = new TreeNode(5); root->right->right = new TreeNode(7); // 层序遍历二叉查找树 levelOrderTraversal(root); return 0; } ``` 这段代码定义了一个`TreeNode`类表示二叉查找树的节点，以及一个`levelOrderTraversal`函数来进行层序遍历。在`main`函数中，创建了一个二叉查找树，并调用`levelOrderTraversal`函数来进行层序遍历。输出结果为：`4 2 6 1 3 5 7`。 希望对您有所帮助！如果您有任何其他问题，请随时提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值