C++std库

C++ 标准库（STL）提供了丰富的功能，其中包含了大量的数据结构、算法和工具函数。这些功能大多数都定义在不同的头文件中，涉及到的成员函数主要是用于容器、算法、迭代器和其他辅助功能的操作。

下面是一些常见的 C++ 标准库成员函数分类：

1. 容器（Containers）

C++ 标准库提供了多种容器，每种容器类都有自己的一组成员函数，用于操作和管理存储的数据。

常见容器及其成员函数：

• std::vector

  • push_back()：在末尾添加元素。
  • pop_back()：移除末尾元素。
  • size()：返回容器的大小（元素数量）。
  • empty()：检查容器是否为空。
  • at()：通过索引访问元素，提供边界检查。
  • operator[]：通过索引访问元素（不进行边界检查）。
  • insert()：在指定位置插入元素。
  • erase()：删除指定位置的元素。
  • clear()：清空所有元素。
  • begin()：返回容器的起始迭代器。
  • end()：返回容器的尾后迭代器。

• std::list

  • push_front()：在头部插入元素。
  • push_back()：在尾部插入元素。
  • pop_front()：删除头部元素。
  • pop_back()：删除尾部元素。
  • size()：返回元素数量。
  • empty()：判断容器是否为空。
  • insert()：插入元素。
  • erase()：删除元素。
  • clear()：清空容器。
  • begin()：返回头部迭代器。
  • end()：返回尾后迭代器。

• std::deque

  • push_front()：在头部插入元素。
  • push_back()：在尾部插入元素。
  • pop_front()：删除头部元素。
  • pop_back()：删除尾部元素。
  • size()：返回元素数量。
  • at()：通过索引访问元素。
  • insert()：插入元素。
  • erase()：删除元素。
  • clear()：清空容器。

std::deque 的特点：

1. 双端操作：

   • 支持在容器的 前端 和 后端 进行快速插入和删除操作（O(1)）。
   • 这使得 deque 比普通的 std::vector 更灵活，因为 vector 在头部插入或删除元素的操作需要 O(n) 的时间复杂度（需要移动元素）。

2. 动态数组实现：

   • deque 是由多个小的固定大小数组块组成的，它通过这种方式实现了高效的两端操作。
   • 因为 deque 的内存是分散的，它不像 std::vector 那样使用连续的内存块，所以它允许更高效的头部操作。

3. 随机访问：

   • deque 支持随机访问，像 std::vector 一样，可以通过下标访问任意位置的元素（O(1) 时间复杂度）。

4. 存储方式：

   • 与 std::vector 使用连续的内存不同，std::deque 是分段存储的。每个存储块都包含一个小数组，而所有这些小数组又通过指针连接在一起。

5. 适用场景：

   • deque 适用于需要频繁在两端插入和删除元素的场景，例如在实现队列、双端队列或滑动窗口算法时，deque 是一个非常好的选择。

std::deque 的基本操作：

• 插入操作：

  • push_back(value)：在队列尾部插入元素。
  • push_front(value)：在队列头部插入元素。

• 删除操作：

  • pop_back()：删除队列尾部的元素。
  • pop_front()：删除队列头部的元素。

• 访问操作：

  • front()：访问队列头部的元素。
  • back()：访问队列尾部的元素。

• 其他操作：

  • empty()：判断队列是否为空。
  • size()：获取队列的元素个数。
  • operator[]：通过下标访问元素。

• std::set 和 std::map

  • insert()：插入元素。
  • erase()：删除元素。
  • find()：查找元素。
  • count()：返回指定元素的个数（在 std::map 和 std::set 中最多为 1）。
  • size()：返回元素数量。
  • empty()：检查容器是否为空。

• std::unordered_set 和 std::unordered_map

  • insert()：插入元素。
  • erase()：删除元素。
  • find()：查找元素。
  • count()：返回指定元素的个数。
  • size()：返回元素数量。
  • empty()：检查容器是否为空。

2. 算法（Algorithms）

C++ 标准库提供了大量的算法，用于操作容器中的数据。算法是独立于容器的，可以在任何容器上执行。

常见算法：

• 排序类算法

  • std::sort()：排序容器中的元素。
  • std::stable_sort()：稳定排序，保持相等元素的相对顺序。
  • std::partial_sort()：部分排序。

• 查找类算法

  • std::find()：查找容器中的元素。
  • std::binary_search()：二分查找。
  • std::lower_bound()：查找不小于指定值的第一个位置。
  • std::upper_bound()：查找大于指定值的第一个位置。

• 其他常见算法

  • std::copy()：拷贝元素。
  • std::reverse()：反转容器中的元素。
  • std::accumulate()：累加元素。
  • std::for_each()：对容器中的每个元素执行指定操作。
  • std::remove()：删除容器中的特定元素。

3. 迭代器（Iterators）

C++ 中的容器通过迭代器来访问容器中的元素。迭代器提供了类似指针的操作。

常见迭代器操作：

• begin()：返回容器的开始迭代器。
• end()：返回容器的结束迭代器。
• rbegin()：返回容器的逆向开始迭代器。
• rend()：返回容器的逆向结束迭代器。
• advance()：将迭代器前移或后移指定数量的位置。

4. 智能指针（Smart Pointers）

C++11 引入了智能指针，用于自动管理动态分配的内存。

常见智能指针成员函数：

• std::unique_ptr

  • get()：获取裸指针。
  • release()：释放智能指针的管理，但不删除对象。
  • reset()：重置智能指针，释放管理的对象。

• std::shared_ptr

  • use_count()：返回共享指针的引用计数。
  • reset()：重置共享指针，释放管理的对象。

• std::weak_ptr

  • lock()：返回一个共享指针（如果对象还存在）。

5. 容器适配器（Container Adapters）

C++ 提供了三种容器适配器，用于封装底层容器。

• std::stack

  • push()：将元素推入栈中。
  • pop()：从栈中弹出元素。
  • top()：访问栈顶元素。

• std::queue

  • push()：将元素推入队列中。
  • pop()：从队列中弹出元素。
  • front()：访问队列的前端元素。
  • back()：访问队列的尾端元素。

• std::priority_queue

  • push()：将元素推入优先队列。
  • pop()：从优先队列中弹出元素。
  • top()：访问优先队列的顶端元素。

6. 其他常见工具类成员函数

除了容器和算法，C++ 标准库还提供了各种工具类和辅助功能。

• std::pair

  • first：访问 pair 的第一个元素。
  • second：访问 pair 的第二个元素。

• std::tuple

  • get<N>()：访问 tuple 中的第 N 个元素。

• std::string

  • length()：返回字符串的长度。
  • empty()：检查字符串是否为空。
  • substr()：返回字符串的子串。
  • find()：查找子串。

• std::iostream（输入输出流）

  • operator<<：输出流操作符，用于打印数据。
  • operator>>：输入流操作符，用于读取数据。

STL（标准模板库，Standard Template Library）容器是C++标准库的一部分，它提供了许多通用的、模板化的数据结构和算法，用于处理集合、容器和数据操作。STL容器是STL的核心组成部分，旨在简化数据存储和管理任务。它们具有高效的内存管理、灵活的接口以及与算法的高度兼容性。

STL容器的分类

STL容器根据其存储和访问方式的不同，通常分为三类：序列容器、关联容器和无序关联容器。

1. 序列容器（Sequence Containers）

序列容器是按顺序存储数据的容器，它们允许按照元素的顺序进行访问。常见的序列容器有：

• std::vector：动态数组，可以在末尾高效插入和删除元素。支持随机访问。
• std::deque（双端队列）：可以从两端高效插入和删除元素，支持随机访问。
• std::list：双向链表，元素可以在任意位置插入和删除，但不支持随机访问。
• std::array：固定大小的数组，大小在编译时确定，支持快速随机访问。
• std::forward_list：单向链表，类似 std::list，但只允许从前端进行插入和删除。

2. 关联容器（Associative Containers）

关联容器以键值对的形式存储数据，并且能够根据键值高效地查找和操作元素。常见的关联容器有：

• std::set：存储唯一的元素，按照一定的顺序（默认是升序）排列。元素的查找、插入和删除都是对数时间复杂度（O(log n)）。
• std::map：存储键值对，每个键都是唯一的，并且按照键的顺序排列。提供根据键查找值的功能。
• std::multiset：类似于 std::set，但是允许重复元素。
• std::multimap：类似于 std::map，但是允许重复键。

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

无序关联容器通过哈希表实现元素的存储和查找，不保证元素的顺序。常见的无序关联容器有：

• std::unordered_set：与 std::set 类似，但元素是通过哈希表存储的，因此查找、插入和删除的平均时间复杂度是常数时间（O(1)）。
• std::unordered_map：与 std::map 类似，但通过哈希表存储键值对，查找、插入和删除的平均时间复杂度是常数时间。
• std::unordered_multiset：与 std::multiset 类似，但使用哈希表存储元素。
• std::unordered_multimap：与 std::multimap 类似，但使用哈希表存储键值对。

4. 适配器容器（Container Adapters）

适配器容器是基于其他容器类型（通常是序列容器）实现的容器，它们通过提供特定的接口，改变了底层容器的使用方式。常见的适配器容器有：

• std::stack：栈，遵循后进先出（LIFO）原则，通常基于 std::deque 或 std::vector 实现。
• std::queue：队列，遵循先进先出（FIFO）原则，通常基于 std::deque 实现。
• std::priority_queue：优先队列，元素按照优先级顺序存储，通常基于 std::vector 实现，并且提供了堆的特性。

STL容器的特点

1. 模板化：STL容器是模板类，可以存储任何类型的元素，不仅限于基本数据类型。你可以用 int、double、std::string 或自定义的类型作为容器的元素类型。

2. 内存管理：STL容器通常会自动管理内存。例如，std::vector 会根据元素的数量动态扩展内存，而 std::list 则通过动态分配每个元素的内存来支持链式结构。

3. 算法支持：STL提供了许多常用算法（如排序、查找、复制等），并且这些算法与容器类型解耦。容器和算法通过迭代器进行交互，使得算法能够用于各种容器类型。

4. 高效性：STL容器的设计通常追求高效的时间复杂度。例如，std::vector 对于随机访问操作是常数时间复杂度 O(1)，std::map 对于查找操作是对数时间复杂度 O(log n)。

5. 类型安全：STL容器通过模板机制确保类型安全，容器只能存储指定类型的元素，避免了类型错误。