STL标准库
主要由容器、迭代器、算法组成
STL主要头文件
<algorithm>、<deque>、<functional>、<iterator>、<vector>、<list>、<map>、<memory>、<numeric>、<queue>、<set>、<stack>、<utility>、<unordered_set>、<unordered_m>
//1.算法部分主要由头文件<algorithm>，<numeric>和<functional>组成。
<algorithm>是所有STL头文件中最大的一个（尽管它很好理解），它是由一大堆模版函数组成的，可以认为每个函数在很大程度上都是独立的，其中常用到的功能范围涉及到比较、交换、查找、遍历操作、复制、修改、移除、反转、排序、合并等等。
<numeric>体积很小，只包括几个在序列上面进行简单数学运算的模板函数，包括加法和乘法在序列上的一些操作。
<functional>中则定义了一些模板类，用以声明函数对象。
//2.容器部分主要由头文件<vector>,<list>,<deque>,<set>,<map>,<stack>和<queue>组成。对于常用的一些容器和容器适配器（可以看作由其它容器实现的容器），可以通过下表总结一下它们和相应头文件的对应关系。
向量(vector) 连续存储的元素<vector>
列表(list) 由节点组成的双向链表，每个结点包含着一个元素<list>
双队列(deque) 连续存储的指向不同元素的指针所组成的数组<deque>
集合(set) 由节点组成的红黑树，每个节点都包含着一个元素，节点之间以某种作用于元素对的谓词排列，没有两个不同的元素能够拥有相同的次序 <set>
多重集合(multiset) 允许存在两个次序相等的元素的集合 <set>
栈(stack) 后进先出的值的排列 <stack>
队列(queue) 先进先出的执的排列 <queue>
优先队列(priority_queue) 元素的次序是由作用于所存储的值对上的某种谓词决定的的一种队列 <queue>
映射(map) 由{键，值}对组成的集合，以某种作用于键对上的谓词排列 <map>
多重映射(multimap) 允许键对有相等的次序的映射 <map>
无序集合(unordered_set) 不是使用比较运算符来组织元素的，而是通过一个哈希函数和键类型的==运算符 <unordered_set>
无序多重集合(unordered_multiset) 不是使用比较运算符来组织元素的，而是通过一个哈希函数和键类型的==运算符 <unordered_set>
无序映射(unordered_map) 不是使用比较运算符来组织元素的，而是通过一个哈希函数和键类型的==运算符 <unordered_map>
无序多重映射(unordered_multimap) 不是使用比较运算符来组织元素的，而是通过一个哈希函数和键类型的==运算符 <unordered_map>
//3.迭代器部分主要由头文件<utility>,<iterator>和<memory>组成。
<utility>是一个很小的头文件，它包括了贯穿使用在STL中的几个模板的声明，
<iterator>中提供了迭代器使用的许多方法，而对于<memory>的描述则十分的困难，它以不同寻常的方式为容器中的元素分配存储空间，同时也为某些算法执行期间产生的临时对象提供机制,<memory>中的主要部分是模板类allocator，它负责产生所有容器中的默认分配器。
迭代器
输入、输出流迭代器
#include <iterator>
#include <iostream>
#include <algorithm>
using namespace std;
double square(double x)
{
return x * x;
}
int main()
{
transform(istream_iterator<double>(cin), istream_iterator<double>(), ostream_iterator<double>(cout, "\t"), square);
cout << endl;
return 0;
}
迭代器综合运用
#include <iterator>
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
template <class T, class InputIterator, class OutIterator>
void mySort(InputIterator first, InputIterator last, OutIterator result)
{
vector<T> s;
for (; first != last; ++first)
s.push_back(*first);
sort(s.begin(), s.end());
copy(s.begin(), s.end(), result);
}
int main()
{
double a[5] = { 1.2, 2.4, 0.8, 3.3, 3.2 };
mySort<double>(a, a + 5, ostream_iterator<double>(cout, " "));
cout << endl;
mySort<int>(istream_iterator<int>(cin), istream_iterator<int>(), ostream_iterator<int>(cout, " "));
cout << endl;
}
迭代器适配器
所谓迭代器适配器，其本质也是一个模板类，比较特殊的是，该模板类是借助以上 5 种基础迭代器实现的。换句话说，迭代器适配器模板类的内部实现，是通过对以上 5 种基础迭代器拥有的成员方法进行整合、修改，甚至为了实现某些功能还会添加一些新的成员方法。由此，将基础迭代器“改头换面”，就变成了本节要讲的迭代器适配器。
本质上讲，迭代器适配器仍属于迭代器，可以理解为是基础迭代器的“翻新版”或者“升级版”。同时，“xxx 迭代器适配器”通常直接称为“xxx 迭代器”。
C++ STL迭代器适配器种类
C++ 11 标准中，迭代器适配器供有 4 类，它们各自的名称和功能如下表所示。
| 名称 | 功能 |
|---|
反向迭代器（reverse_iterator） | 又称“逆向迭代器”，其内部重新定义了递增运算符（++）和递减运算符（--），专门用来实现对容器的逆序遍历。 |
安插型迭代器（inserter or insert_iterator） | 通常用于在容器的任何位置添加新的元素，需要注意的是，此类迭代器不能被运用到元素个数固定的容器（比如 array）上。 |
流迭代器（istream_iterator/ostream_iterator流缓冲区迭代器（istreambuf_iterator /streambuf_iterator） | 输入流迭代器用于从文件或者键盘读取数据；相反，输出流迭代器用于将数据输出到文件或者屏幕上。 输入流缓冲区迭代器用于从输入缓冲区中逐个读取数据；输出流缓冲区迭代器用于将数据逐个写入输出流缓冲区。 |
移动迭代器（move_iterator） | 此类型迭代器是 C++ 11 标准中新添加的，可以将某个范围的类对象移动到目标范围，而不需要通过拷贝去移动。 |
容器
向量（vector）
向量是序列容器，表示可以改变大小的数组。
与数组一样，vector的元素使用连续的存储位置，这意味着也可以使用指向其元素的常规指针的偏移量访问它们的元素，并且与在数组中一样有效。但与数组不同的是，它们的大小可以动态变化，它们的存储由容器自动处理。
在内部，向量使用一个动态分配的数组来存储它们的元素。这个数组可能需要重新分配，以便在插入新元素时增加大小，这意味着分配一个新数组并将所有元素移动到其中。就处理时间而言，这是一个相对昂贵的任务，因此，vector不会在每次向容器添加元素时进行重新分配。
相反，vector容器可以分配一些额外的存储空间来容纳可能的增长，因此容器的实际容量可能大于存储其元素的严格需求(即其大小)。库可以实现增长不同的策略来平衡内存使用和重新分配,但在任何情况下,重新分配应该只发生在对数生长间隔的大小,以便插入单个元素的向量可以提供平摊常数时间复杂度(见push_back方法)。
因此，与数组相比，向量消耗更多的内存，以换取管理存储和以一种有效的方式动态增长的能力。
与其他动态序列容器(deque、lists和forward_lists)相比，vector容器访问其元素的效率非常高(就像数组一样)，从其末端添加或删除元素的效率也相对较高。对于涉及在非结束位置插入或删除元素的操作，它们的性能比其他操作差，且迭代器和引用的一致性也不如列表和forward_lists。
内部成员函数
构造函数
vector();
explicit vector (const allocator_type& alloc);
explicit vector (size_type n, const allocator_type& alloc = allocator_type());
vector (size_type n, const value_type& val,
const allocator_type& alloc = allocator_type());
template <class InputIterator>
vector (InputIterator first, InputIterator last,
const allocator_type& alloc = allocator_type());
vector (const vector& x);
vector (const vector& x, const allocator_type& alloc);
vector (vector&& x);
vector (vector&& x, const allocator_type& alloc);
vector (initializer_list<value_type> il,
const allocator_type& alloc = allocator_type());
成员函数
vector::assign
template <class InputIterator>
void assign (InputIterator first, InputIterator last); //将区间[first, last)中得值赋值给向量，向量原有数据将被删除
void assign (size_type n, const value_type& val); //将n个val赋值给向量
void assign (initializer_list<value_type> il); //一个初始化器列表对象。编译器自动从初始化列表声明器构造这样的对象。成员类型 value_type是容器中元素的类型，在vector中定义为其第一个模板形参(T)的别名。
vector::at
reference at (size_type n);
const_reference at (size_type n) const; //返回为n的成员的引用
vector::back
reference back();
const_reference back() const; //返回向量最后一个元素的引用
vector::begin
iterator begin() noexcept;
const_iterator begin() const noexcept; //返回指向序列容器开头的迭代器。
vector::capacity
size_type capacity() const noexcept; //返回向量中当前分配的存储容量的大小，以其可容纳的元素数量来度量
vector::cbegin
const_iterator cbegin() const noexcept; //指向序列开头的const_iterator对象。成员类型const_iterator是一种指向 const元素的随机访问迭代器类型。
vector::cend
const_iterator cend() const noexcept; //指向序列结尾的const_iterator对象。
vector::clear
void clear() noexcept; //移除vector容器中的所有元素(这些元素被销毁)，使容器的大小为0。
vector::crbegin
const_reverse_iterator crbegin() const noexcept; //返回一个const_reverse_iterator对象，指向容器中的最后一个元素(即反向 开始)。
vector::crend
const_reverse_iterator crend() const noexcept; //返回一个const_reverse_iterator对象，指向容器中的第一个元素(即反向 结束)。
vector::data
value_type* data() noexcept;
const value_type* data() const noexcept; //返回一个指向vector对象内部用于存储其所属元素的内存数组的直接指针。
vector::emplace
template <class... Args>
iterator emplace (const_iterator position, Args&&... args); //在指定位置插入新元素
vector::emplace_back
template <class... Args>
void emplace_back (Args&&... args); //在vector对象的最后一个元素的后面插入一个新元素。这个新元素使用args作 为其构造函数的参数就地构造。
vector::empty
bool empty() const noexcept; //判断向量是否为空
vector::end
iterator end() noexcept;
const_iterator end() const noexcept; //返回指向序列容器结尾的迭代器。
vector::erase
iterator erase (const_iterator position);
iterator erase (const_iterator first, const_iterator last); //从向量中删除指定单个元素，或者一系列元素
vector::front
reference front();
const_reference front() const; //返回对vector中第一个元素的引用。
vector::get_allocator
allocator_type get_allocator() const noexcept; //返回与vector关联的allocator对象的副本。/使用构造函数返回一个拷贝
vector::insert
iterator insert (const_iterator position, const value_type& val); //在指定位置插入val数据
iterator insert (const_iterator position, size_type n, const value_type& val); //在指定位置插入n个val数据
template <class InputIterator>
iterator insert (const_iterator position, InputIterator first, InputIterator last); //在指定位置插入一系列数据
iterator insert (const_iterator position, value_type&& val); //在指定位置插入val数据
iterator insert (const_iterator position, initializer_list<value_type> il); //在指定位置插入列表数据
vector::max_size
size_type max_size() const noexcept; //返回vector所能容纳的最大元素数。
vector::operator=
vector& operator= (const vector& x);
vector& operator= (vector&& x);
vector& operator= (initializer_list<value_type> il); //重载“=”
vector::operator[]
reference operator[] (size_type n);
const_reference operator[] (size_type n) const; //重载“[]”
vector::pop_back
void pop_back(); //删除vector中的最后一个元素，将容器大小减少1。这将销毁被删除的元素。
vector::push_back
void push_back (const value_type& val);
void push_back (value_type&& val); //在向量的尾部放入一个元素
vector::rbegin
reverse_iterator rbegin() noexcept;
const_reverse_iterator rbegin() const noexcept; //返回指向vector中最后一个元素的反向迭代器(即反向开始)。
vector::rend
reverse_iterator rbegin() noexcept;
const_reverse_iterator rbegin() const noexcept; //返回指向vector中第一个元素的反向迭代器(即反向结束)。
vector::reserve
void reserve (size_type n); //请求vector容器的容量至少足够包含n个元素。如果n大于当前的vector容量， 该函数将导致容器重新分配其存储空间，将其容量增加到n(或更大)
vector::resize
void resize (size_type n);
void resize (size_type n, const value_type& val); //调整容器的大小，使其包含n个元素如果n小于当前容器的大小，内容将减少到前n 个元素，并删除后面的元素(并销毁它们)如果n大于当前容器的大小，则通过在容 器的末尾插入足够数量的元素来扩展内容。如果指定了val，则将新元素初始化为 val的副本，否则，将其值初始化
vector::shrink_to_fit
void shrink_to_fit(); //请求容器减少其容量以适应其大小请求是非绑定的，容器实现可以自由优化，并留 给vector的容量大于其大小这可能会导致重新分配，但对vector的大小没有影 响，也不能改变其元素。
vector::size
size_type size() const noexcept; //返回vector中的元素个数。
vector::swap
void swap (vector& x); //用x的内容交换容器的内容，x是另一个相同类型的向量对象。大小可能不同。
栈（stack）
栈是一种容器适配器，专门设计用于后进先出的上下文中操作，在这种上下文中，元素只从容器的一端插入和提取。
堆栈是作为容器适配器实现的，容器适配器是使用特定容器类的封装对象作为其底层容器的类，提供了一组特定的成员函数来访问其元素。
元素从特定容器的“背面”推送/弹出，该容器称为堆栈的顶部。底层容器可以是任何标准容器类模板或其他特定设计的容器类。容器应支持以下操作:
- empty
- size
- back
- push_back
- pop_back
成员函数
构造函数
explicit stack (const container_type& ctnr);
explicit stack (container_type&& ctnr = container_type());
template <class Alloc> explicit stack (const Alloc& alloc);
template <class Alloc> stack (const container_type& ctnr, const Alloc& alloc);
template <class Alloc> stack (container_type&& ctnr, const Alloc& alloc);
template <class Alloc> stack (const stack& x, const Alloc& alloc);
template <class Alloc> stack (stack&& x, const Alloc& alloc);
成员函数
stack::emplace
template <class... Args>
void emplace (Args&&... args); //在堆栈顶部的当前顶部元素之上添加一个新元素。将参数作为其构造函数的参数传递。这 个成员函数有效地调用基础容器的成员函数emplace_back，转发参数。
stack::empty
bool empty() const; //判断栈是否为空
stack::pop
void pop(); //移除堆栈顶部的元素，有效地将其大小减少1。
stack::push
void push (const value_type& val);
void push (value_type&& val); //将一个新元素插入堆栈的顶部，位于其当前顶部元素的上方。
stack::size
size_type size() const; //返回堆栈中的元素个数。
stack::swap
void swap (stack& x); //与堆栈x交换内容
stack::top
reference top();
const_reference top() const; //返回对堆栈顶部元素的引用。
集合（set）
集合是按照特定顺序存储惟一元素的容器。
在一个集合中，元素的值也可以标识它(该值本身就是T类型的键)，每个值必须是唯一的。 集合中的元素的值不能在容器中修改一次(元素总是const)，但它们可以从容器中插入或删除。
在内部，集合中的元素总是按照内部比较对象(Compare类型)指示的特定严格弱排序标准进行排序。
Set容器通过键访问单个元素通常比unordered_set容器慢，但它们允许根据它们的顺序对子集进行直接迭代。
集合通常被实现为二叉搜索树。
模板定义
template < class T, // set::key_type/value_type
class Compare = less<T>, // set::key_compare/value_compare
class Alloc = allocator<T> // set::allocator_type
> class set;
构造函数
set();
explicit set (const key_compare& comp,
const allocator_type& alloc = allocator_type());
explicit set (const allocator_type& alloc);
template <class InputIterator>
set (InputIterator first, InputIterator last,
const key_compare& comp = key_compare(),
const allocator_type& = allocator_type());
template <class InputIterator>
set (InputIterator first, InputIterator last,
const allocator_type& = allocator_type());
set (const set& x);
set (const set& x, const allocator_type& alloc);
set (set&& x);
set (set&& x, const allocator_type& alloc);
set (initializer_list<value_type> il,
const key_compare& comp = key_compare(),
const allocator_type& alloc = allocator_type());
set (initializer_list<value_type> il,
const allocator_type& alloc = allocator_type());
成员函数
Iterators:
set::begin
iterator begin() noexcept;
const_iterator begin() const noexcept; //返回开始的迭代器
set::end
const_iterator cend() const noexcept; //返回到end的迭代器
set::rbegin
reverse_iterator rbegin() noexcept;
const_reverse_iterator rbegin() const noexcept; //返回反向开始的迭代器
set::rend
reverse_iterator rend() noexcept;
const_reverse_iterator rend() const noexcept; //返回到反向end的反向迭代器
set::cbegin
const_iterator cbegin() const noexcept; //返回指向开始的const迭代器
set::cend
const_iterator cend() const noexcept; //返回指向end的const迭代器
set::crbegin
const_reverse_iterator crbegin() const noexcept; //返回const_reverse_iterator以反转开始
set::crend
const_reverse_iterator crend() const noexcept; //返回反向end的const reverse_iterator
Capacity:
set::empty
bool empty() const noexcept; //判断容器是否为空
set::size
size_type size() const noexcept; //返回容器集合元素大小
set::max_size
size_type max_size() const noexcept; //返回集合容器可容纳的最大元素数。
Modifiers:
set::insert
pair<iterator,bool> insert (const value_type& val);
pair<iterator,bool> insert (value_type&& val); //返回一个pair，pair里面包含两种数据类型，一个是迭代器，一个是bool类 型；pair的第一个参数为该set的迭代器，表示如果插入一个set里面不存在的 数据，则迭代器指向这个新增结点，如果插入一个set里面已经存在的数据，则迭 代器指向已经存在的数据；pair的第二个参数为bool类型，表示如果是true， 则数据成功插入，如果为false则表示插入的数据已经存在。
iterator insert (const_iterator position, const value_type& val);
iterator insert (const_iterator position, value_type&& val); //在某个位置上插入一个数据
template <class InputIterator>
void insert (InputIterator first, InputIterator last);
void insert (initializer_list<value_type> il); //将一个区间的数据插入
set::erase
iterator erase (const_iterator position); //删除某个位置的元素
size_type erase (const value_type& val); //删除值为val的元素
iterator erase (const_iterator first, const_iterator last);//删除一个区间元素
set::swap
void swap (set& x); //用x的内容交换容器的内容，x是同一类型的另一个集合。大小可能不同。
set::clear
void clear() noexcept; //清除集合的内容
set::emplace
template <class... Args>
pair<iterator,bool> emplace (Args&&... args); //构造并插入元素
set::emplace_hint
template <class... Args>
iterator emplace_hint (const_iterator position, Args&&... args); //使用hint构造和插入元素
Observers:
set::key_comp
key_compare key_comp() const; //返回比较对象
set::value_comp
value_compare value_comp() const; //返回比较对象
Operations:
set::find
const_iterator find (const value_type& val) const;
iterator find (const value_type& val); //获取元素val的迭代器
set::count
size_type count (const value_type& val) const; //计数具有特定值的元素 1或0
set::lower_bound
iterator lower_bound (const value_type& val);
const_iterator lower_bound (const value_type& val) const; //返回指向容器中第一个大于等于val元素的迭代器
set::upper_bound
iterator upper_bound (const value_type& val);
const_iterator upper_bound (const value_type& val) const; //返回指向容器中第一个小于等于val元素的迭代器
set::equal_range
pair<const_iterator,const_iterator> equal_range (const value_type& val) const;
pair<iterator,iterator> equal_range (const value_type& val); //返回一个范围的边界，该范围包含容器中与val等价的所有 元素。
Allocator:
set::get_allocator
获取分配器(公共成员函数)
映射（map）
映射是关联容器，按照特定的顺序存储由键值和映射值组合而成的元素。
在映射中，键值通常用于对元素进行排序和惟一标识，而映射的值则存储与此键相关的内容。key和映射值的类型可能不同，并在成员类型value_type中组合在一起，value_type是一种组合这两种类型的pair类型:
typedef pair<const Key, T> value_type;
在内部，映射中的元素总是按照其键进行排序，并遵循由内部比较对象(Compare类型)指示的特定严格弱排序标准。
Map容器通过键访问单个元素的速度通常比unordered _map容器慢，但它们允许根据它们的顺序直接迭代子集。
映射中的映射值可以使用括号操作符直接通过对应的键访问([operator[])
映射通常被实现为二叉搜索树。
模板定义
template < class Key, // map::key_type
class T, // map::mapped_type
class Compare = less<Key>, // map::key_compare
class Alloc = allocator<pair<const Key,T> > // map::allocator_type
> class map;
构造函数
explicit map (const key_compare& comp = key_compare(),
const allocator_type& alloc = allocator_type());
explicit map (const allocator_type& alloc);
template <class InputIterator>
map (InputIterator first, InputIterator last,
const key_compare& comp = key_compare(),
const allocator_type& = allocator_type());
map (const map& x);
map (const map& x, const allocator_type& alloc);
map (map&& x);
map (map&& x, const allocator_type& alloc);
map (initializer_list<value_type> il,
const key_compare& comp = key_compare(),
const allocator_type& alloc = allocator_type());
成员函数
operator=
复制容器内容
Iterators:
map::begin
iterator begin() noexcept;
const_iterator begin() const noexcept; //返回到开始的迭代器
map::end
iterator end() noexcept;
const_iterator end() const noexcept; //返回到end的迭代器
map::rbegin
reverse_iterator rbegin() noexcept;
const_reverse_iterator rbegin() const noexcept; //返回反转beginninq的反向迭代器
map::rend
reverse_iterator rend() noexcept;
const_reverse_iterator rend() const noexcept; //返回反向末端的反向迭代器
map::cbegin
const_iterator cbegin() const noexcept; //返回类型为const_iterator的容器开头
map::cend
const_iterator cend() const noexcept; //返回类型为const_iterator的容器结尾
map::crbegin
const_reverse_iterator crbegin() const noexcept; //返回类型为const_iterator的容器结尾
map::crend
const_reverse_iterator crend() const noexcept; //返回类型为const_iterator的容器开头
Capacity:
map::empty
bool empty() const noexcept; //判断容器是否为空
map::size
size_type size() const noexcept; //返回映射容器中的元素数。
map::max_size
size_type max_size() const noexcept; //返回映射容器可以容纳的最大元素数
Element access:
map::operator[]
mapped_type& operator[] (const key_type& k);
mapped_type& operator[] (key_type&& k); //运算符重载，访问元素
map::at
mapped_type& at (const key_type& k);
const mapped_type& at (const key_type& k) const; //返回对用键k标识的元素的映射值的引用。
Modifiers:
map::insert
pair<iterator,bool> insert (const value_type& val); //插入value_type值
template <class P>
pair<iterator,bool> insert (P&& val); //插入P定义的值
iterator insert (const_iterator position, const value_type& val); //在某个位置插入value_type值
template <class P>
iterator insert (const_iterator position, P&& val); //在某个位置插入P定义的值
template <class InputIterator>
void insert (InputIterator first, InputIterator last); //插入一个区间的值
void insert (initializer_list<value_type> il); //插入列表元素
map::erase
iterator erase (const_iterator position);
size_type erase (const key_type& k);
iterator erase (const_iterator first, const_iterator last); //从map容器中移除单个元素或一系列元素([first, last))。
map::map::swap
void swap (map& x); //用x的内容交换容器的内容，x是同一类型的另一个映射。大小可能不同。
map::clear
void clear() noexcept; //清除集合内所有内容
map::emplace
template <class... Args>
pair<iterator,bool> emplace (Args&&... args); //如果新元素的键是唯一的，则在映射中插入新元素。这个新元素使用args 为构造value_type(一个pair类型的对象)的参数就地构造。
map::emplace_hint
template <class... Args>
iterator emplace_hint (const_iterator position, Args&&... args); //如果新元素的键是唯一的，则在映射中插入新元素，并提示插入 位置。这个新元素使用args作为构造value_type(一个pair 类型的对象)的参数就地构造。
Observers:
map::key_comp
key_compare key_comp() const; //返回容器用于比较键的比较对象的副本。
map::value_comp
value_compare value_comp() const; //返回一个比较对象，该对象可用于比较两个元素，以获得第一个元素的键是否在第 二个元素之前。
Operations:
map::find
iterator find (const key_type& k);
const_iterator find (const key_type& k) const; //在容器中搜索键值等于k的元素，如果找到，返回该元素的迭代器，否则返回映 射::end的迭代器。
map::count
size_type count (const key_type& k) const; //在容器中搜索键值等于k的元素，并返回匹配的数量。
map::lower_bound
iterator lower_bound (const key_type& k);
const_iterator lower_bound (const key_type& k) const; //返回一个指向容器中第一个元素的迭代器，该元素的键不被认为在k之前
map::upper_bound
iterator upper_bound (const key_type& k);
const_iterator upper_bound (const key_type& k) const; //返回指向容器中第一个元素的迭代器，该元素的键被认为位于k之后。
map::equal_range
pair<const_iterator,const_iterator> equal_range (const key_type& k) const;
pair<iterator,iterator> equal_range (const key_type& k); //返回一个范围的边界，范围包含容器中键值等于k的所有元素。
Allocator:
map::get_allocator
allocator_type get_allocator() const noexcept; //返回与映射关联的分配器对象的副本。
队列（queue）
queue是一种容器适配器，专门设计用于在FIFO上下文中操作(先进先出)，其中元素被插入到容器的一端，然后从另一端提取。
队列是作为容器适配器实现的，容器适配器是使用特定容器类的封装对象作为其底层容器的类，提供了一组特定的成员函数来访问其元素。
元素被推入特定容器的“背面”，并从其“正面”弹出。底层容器可以是标准容器类模板之一，也可以是其他特定设计的容器类。此基础容器应至少支持以下操作:
- empty
- size
- front
- back
- push_back
- pop_front
模板定义
template <class T, class Container = deque<T> >
class queue;
构造函数
explicit queue (const container_type& ctnr);
explicit queue (container_type&& ctnr = container_type());
template <class Alloc>
explicit queue (const Alloc& alloc);
template <class Alloc>
queue (const container_type& ctnr, const Alloc& alloc);
template <class Alloc>
queue (container_type&& ctnr, const Alloc& alloc);
template <class Alloc>
queue (const queue& x, const Alloc& alloc);
template <class Alloc>
queue (queue&& x, const Alloc& alloc);
成员函数
queue::empty
bool empty() const; //判断容器是否为空
queue::size
size_type size() const; //返回队列中的元素数
queue::front
reference& front();
const_reference& front() const; //返回对队列中头部元素的引用。
queue::back
reference& back();
const_reference& back() const; //返回对队列中最后一个元素的引用。
queue::push
void push (const value_type& val);
void push (value_type&& val); //在尾部插入元素
queue::emplace
template <class... Args> void emplace (Args&&... args); //在队列的最后一个元素之后添加一个新元素。这个新元素是就地构造的，将参数作 为其构造函数的参数传递。
queue::pop
void pop(); //删除头部的第一个元素
queue::swap
void swap (queue& x) noexcept(/*see below*/); //将容器适配器(*this)的内容交换为x的内容。大小可能不同
双端队列（deque）
Deque是双端队列(double-end queue)的不规则首字母缩写。双端队列是具有动态大小的序列容器，可以在两端(前端或后端)进行扩展或收缩。
特定的库可以以不同的方式实现deque，通常作为某种形式的动态数组。但在任何情况下，它们都允许通过随机访问迭代器直接访问单个元素，并根据需要通过扩展和收缩容器自动处理存储空间。
因此，它们提供了一种类似于vector的功能，但是在序列的开始，而不仅仅是在序列的结尾，都可以有效地插入和删除元素。但是，与vector不同，deque不能保证将所有元素存储在连续的存储位置上:通过偏移指向另一个元素的指针来访问deque中的元素会导致未定义的行为。
vector和deque都提供了一个非常相似的接口，可以用于类似的目的，但在内部它们的工作方式截然不同:虽然向量使用一个数组需要偶尔增长重新分配,双端队列的元素可以分散在不同的块存储、与容器保持必要的内部信息,以提供直接访问任何元素在常数时间和均匀连续的界面(通过迭代器)。因此，deque在内部比vector稍微复杂一些，但这使得它们在某些情况下能够更有效地增长，特别是在非常长的序列中，因为重新分配的代价会更大。
对于经常在开始或结束位置以外的位置插入或删除元素的操作，与列表和前向列表相比，deque的性能更差，迭代器和引用也更不一致。
模板定义
template < class T, class Alloc = allocator<T> >
class deque;
构造函数
explicit deque (const allocator_type& alloc = allocator_type());
explicit deque (size_type n);
deque (size_type n, const value_type& val,
const allocator_type& alloc = allocator_type());
template <class InputIterator>
deque (InputIterator first, InputIterator last,
const allocator_type& alloc = allocator_type());
deque (const deque& x);
deque (const deque& x, const allocator_type& alloc);
deque (deque&& x);
deque (deque&& x, const allocator_type& alloc);
deque (initializer_list<value_type> il,
const allocator_type& alloc = allocator_type());
成员函数
deque::operator=
Assign content (public member function )
Iterators:
deque::begin
iterator begin() noexcept;
const_iterator begin() const noexcept; //返回返回指向deque容器中第一个元素的迭代器。
deque::end
iterator end() noexcept;
const_iterator end() const noexcept; //返回指向deque容器中超末端元素的迭代器。
deque::deque::rbegin
reverse_iterator rbegin() noexcept;
const_reverse_iterator rbegin() const noexcept; //返回指向容器中最后一个元素的反向迭代器(即反向开始)。
deque::rend
reverse_iterator rend() noexcept;
const_reverse_iterator rend() const noexcept; //返回一个反向迭代器，指向deaue容器中第一个元素之前的理论元素
deque::cbegin
const_iterator cbegin() const noexcept; //返回指向容器中第一个元素的const_iterator对象。
deque::cend
const_iterator cend() const noexcept; //返回一个const迭代器，指向容器中最后一个元素。
deque::crbegin
const_reverse_iterator crbegin() const noexcept; //返回一const_reverse_iterator对象，指向容器中的最后一个元素(即它的反向开头)。
deque::crend
const_reverse_iterator crend() const noexcept; //返回const_reverse_iterator对象，该对象指向容器中第一个元素之前的元素(该元素被 认为是容器的反向末端)。
Capacity:
deque::size
size_type size() const noexcept; //返回集合容器中的元素个数。
deque::max_size
size_type max_size() const noexcept; //返回集合容器可容纳的最大元素数。
deque::resize
void resize (size_type n);
void resize (size_type n, const value_type& val); //调整容器的大小，使其包含n个元素。
deque::empty
bool empty() const noexcept; //判断容器是否为空
deque::shrink_to_fit
void shrink_to_fit(); //请求容器减少其内存使用以适应其大小。
Element access:
deque::operator[]
reference operator[] (size_type n);
const_reference operator[] (size_type n) const; //函数重载
deque::at
reference at (size_type n);
const_reference at (size_type n) const; //返回对deque容器对象中位置n的元素的引用。
deque::front
reference front();
const_reference front() const; //返回对deque容器中的第一个元素的引用。
deque::back
reference back();
const_reference back() const; //返回对容器中最后一个元素的引用。
Modifiers:
deque::assign
template <class InputIterator>
void assign (InputIterator first, InputIterator last);
void assign (size_type n, const value_type& val);
void assign (initializer_list<value_type> il); //将新内容分配给deque容器，替换其当前内容，并相应地修改其大小。
deque::push_back
void push_back (const value_type& val);
void push_back (value_type&& val); //在deque容器最后一个元素之后添加一个新元素。val的内容被复制(或移动)到新元素中。
deque::push_front
void push_front (const value_type& val);
void push_front (value_type&& val); //在deque容器的开头插入一个新元素，就在其当前的第一个元素之前。val的内容被复制(或 移动)到插入的元素中
deque::pop_back
void pop_back(); //移除deque容器中的最后一个元素，有效地将容器大小减少1。
deque::pop_front
void pop_front(); //移除deque容器中的第一个元素，有效地将其大小减少1。
deque::insert
iterator insert (const_iterator position, const value_type& val);
iterator insert (const_iterator position, size_type n, const value_type& val);
template <class InputIterator>
iterator insert (const_iterator position, InputIterator first, InputIterator last);
iterator insert (const_iterator position, value_type&& val);
iterator insert (const_iterator position, initializer_list<value_type> il); //插入数据
deque::erase
iterator erase (const_iterator position );
iterator erase (const_iterator first, const_iterator last ); //从deque容器中移除单个元素(position)或一系列元素([first, last))。
deque::swap
void swap (deque& x); //用x的内容交换容器的内容，x是另一个包含ame类型元素的deque对象。大小可能不同。
deque::clear
void clear() noexcept; //从deque容器中移除所有元素(这些元素被销毁)，留下大小为o的容器。
deque::emplace
template <class... Args>
iterator emplace (const_iterator position, Args&&... args); //通过在位置插入新元素来扩展容器。这个新元素使用args作为其构造 的参数就地构造
deque::emplace_front
template <class... Args>
void emplace_front (Args&&... args); //在deque容器的开头插入一个新元素，就在当前元素的第一个元素之 前。这个新元素使用aras作为其构造的参数就地构造。
deque::emplace_back
template <class... Args>
void emplace_back (Args&&... args); //在deque容器的最后一个元素的后面插入一个新元素。这个新元素使 用args作为其构造的参数就地构造。
Allocator:
deque::get_allocator
allocator_type get_allocator() const noexcept; //返回与deque对象关联的allocator对象的副本
列表（list）
列表是序列容器，允许在序列中任意位置进行常量时间的插入和删除操作，并在两个方向上进行迭代。
列表容器被实现为双链表;双链表可以将它们所包含的每个元素存储在不同且不相关的存储位置。这个顺序是由链接到前面的元素和链接到后面的元素的每个元素的关联在内部保持的。
它们与forward_list非常相似:主要的区别是forward_list对象是单链表，因此它们只能向前迭代，以换取更小和更高效。
与其他基本标准序列容器(array、vector和deque)相比，列表在插入、提取和移动容器中已经获得迭代器的任何位置的元素时，通常表现得更好，因此在大量使用这些元素的算法中也一样，比如排序算法。
与其他序列容器相比，list和forward_lists的主要缺点是它们不能直接访问元素的位置;例如，要访问列表中的第6个元素，必须从已知的位置(如开始或结束)迭代到该位置，这需要在这些位置之间的距离上花费线性时间。它们还会消耗一些额外的内存来保存与每个元素相关联的链接信息(对于由小型元素组成的大型列表来说，这可能是一个重要因素)。
模板定义
template < class T, class Alloc = allocator<T> >
class list;
构造函数
list();
explicit list (const allocator_type& alloc);
explicit list (size_type n, const allocator_type& alloc = allocator_type());
list (size_type n, const value_type& val,
const allocator_type& alloc = allocator_type());
template <class InputIterator>
list (InputIterator first, InputIterator last,
const allocator_type& alloc = allocator_type());
list (const list& x);
list (const list& x, const allocator_type& alloc);
list (list&& x);
list (list&& x, const allocator_type& alloc);
list (initializer_list<value_type> il,
const allocator_type& alloc = allocator_type());
成员函数
(constructor)
operator=
Assign content (public member function)
Iterators:
list::begin
iterator begin() noexcept;
const_iterator begin() const noexcept; //返回指向列表容器中第一个元素的迭代器。
list::end
iterator end() noexcept;
const_iterator end() const noexcept; //返回指向列表容器中最后一个元素的迭代器。
list::rbegin
reverse_iterator rbegin() noexcept;
const_reverse_iterator rbegin() const noexcept; //返回指向容器中最后一个元素的反向迭代器(即反向开始)。
list::rend
reverse_iterator rend() nothrow;
const_reverse_iterator rend() const nothrow; //返回一个反向迭代器，指向列表容器中第一个元素之前的理论元素(被认为是它的反 向末端)。
list::cbegin
const_iterator cbegin() const noexcept; //返回指向容器中第一个元素的const_iterator对象。
list::cend
const_iterator cend() const noexcept; //返回一个const迭代器，指向容器中最后一个元素。
list::crbegin
const_reverse_iterator crbegin() const noexcept; //返回一个const_reverse_iterator对象，指向容器中的最后一个元素(即它的 反向开头)。
list::crend
const_reverse_iterator crend() const noexcept; //返回const_reverse_iterator对象，指向容器中第一个元素之前的理论元素 (被认为是它的反向末端)。
Capacity:
list::empty
bool empty() const noexcept; //返回列表容器是否为空(即其大小是否为0)。
list::size
size_type size() const noexcept; //返回列表容器中的元素个数。
list::max_size
size_type max_size() const noexcept; //返回列表容器可容纳的最大元素数。
Element access:
list::front
reference front();
const_reference front() const; //返回对列表容器中第一个元素的引用。
list::back
reference back();
const_reference back() const; //返回对列表容器中最后一个元素的引用。
Modifiers:
list::assign
template <class InputIterator>
void assign (InputIterator first, InputIterator last);
void assign (size_type n, const value_type& val);
void assign (initializer_list<value_type> il); //将新内容分配给列表容器，替换其当前内容，并相应地修改其大小。
list::emplace_front
template <class... Args>
void emplace_front (Args&&... args); //在列表的开头，即当前第一个元素的前面插入一个新元素。这个新元素使用aras 作为其构造的参数就地构造。
list::push_front
void push_front (const value_type& val);
void push_front (value_type&& val); //在列表的开头，即当前第一个元素的前面插入一个新元素。val的内容被复制(或 移动)到插入的元素中
list::pop_front
void pop_front(); //移除列表容器中的第一个元素，有效地将其大小减少1。
list::emplace_back
template <class... Args>
void emplace_back (Args&&... args); //将新元素插入到列表的末尾，即当前最后一个元素的后面。这个新元素使用args 作为其构造的参数就地构造。
list::push_back
void push_back (const value_type& val);
void push_back (value_type&& val); //在列表容器的末尾，当前最后一个元素之后，添加一个新元素。val的内容被复制 (或移动)到新元素中。
list::pop_back
void pop_back(); //移除列表容器中的最后一个元素，有效地将容器大小减少1
list::emplace
template <class... Args>
iterator emplace (const_iterator position, Args&&... args); //通过在位置插入新元素来扩展容器。这个新元素使用args来构造它的 参数。
list::insert
iterator insert (const_iterator position, const value_type& val);
iterator insert (const_iterator position, size_type n, const value_type& val);
template <class InputIterator>
iterator insert (const_iterator position, InputIterator first, InputIterator last);
iterator insert (const_iterator position, value_type&& val);
iterator insert (const_iterator position, initializer_list<value_type> il); //插入元素
list::erase
iterator erase (const_iterator position);
iterator erase (const_iterator first, const_iterator last); //从列表容器中移除单个元素(position)或一系列元素 ([first, last))。
list::swap
void swap (list& x); //用x的内容交换容器的内容，x是另一个相同类型的列表。大小可能不同。
list::resize
void resize (size_type n);
void resize (size_type n, const value_type& val); //调整容器的大小，使其包含n个元素。
list::clear
void clear() noexcept; //移除列表容器中的所有元素(这些元素将被销毁)，并将容器的大小保留为0
Operations:
list::splice
void splice (const_iterator position, list& x);
void splice (const_iterator position, list&& x);
void splice (const_iterator position, list& x, const_iterator i);
void splice (const_iterator position, list&& x, const_iterator i);
void splice (const_iterator position, list& x,
const_iterator first, const_iterator last);
void splice (const_iterator position, list&& x,
const_iterator first, const_iterator last); //将元素从x传输到容器中，并在容器的位置插入它们。
list::remove
void remove (const value_type& val); //从容器中移除所有与val相等的元素。该函数调用这些对象的析构函数，并通过移 除元素的数量来减小容器的大小。
list::remove_if
template <class Predicate>
void remove_if (Predicate pred); //从容器中移除所有Predicate pred返回true的元素。这将调用这些对象的析 构函数，并通过删除元素的数量来减少容器的大小。
list::unique
void unique();
template <class BinaryPredicate>
void unique (BinaryPredicate binary_pred); //从容器中每个连续相等的元素组中删除除第一个元素外的所有元素。
list::merge
void merge (list& x);
void merge (list&& x);
template <class Compare>
void merge (list& x, Compare comp);
template <class Compare>
void merge (list&& x, Compare comp); //通过将x的所有元素在它们各自的有序位置转移到容器中，将x合并到列表中(两个 容器都应该已经被排序)。
list::sort
void sort();
template <class Compare>
void sort (Compare comp); //对列表中的元素进行排序，改变它们在容器中的位置。
list::reverse
void reverse() noexcept; //颠倒列表容器中元素的顺序。
Observers:
list::get_allocator
allocator_type get_allocator() const noexcept; //返回与列表容器关联的分配器对象的副本。
多重集合（multiset）
multiset是按照特定顺序存储元素的容器，多个元素可以具有相同的值。
在multiset中，元素的值也可以用来标识它(该值本身就是T类型的键)。multiset中的元素的值在容器中不能修改一次(元素总是const)，但它们可以从容器中插入或删除。
在内部，multiset中的元素总是按照内部比较对象(Compare类型)指示的特定严格弱排序标准进行排序。
Multiset容器通过键访问单个元素通常比unordered_mu ltiset容器慢，但它们允许根据它们的顺序直接迭代子集。
multiset通常被实现为二叉搜索树。
关联容器中的元素是通过它们的键引用的，而不是通过它们在容器中的绝对位置引用的。
容器中的元素始终遵循严格的顺序。所有插入的元素都按此顺序给定一个位置。
元素的值也是用来标识它的键。
容器中的多个元素可以具有等价的键。
容器使用一个allocator对象来动态地处理其存储需求。
模板定义
template < class T, // multiset::key_type/value_type
class Compare = less<T>, // multiset::key_compare/value_compare
class Alloc = allocator<T> > // multiset::allocator_type
> class multiset;
构造函数
explicit multiset (const key_compare& comp = key_compare(),
const allocator_type& alloc = allocator_type());
explicit multiset (const allocator_type& alloc);
template <class InputIterator>
multiset (InputIterator first, InputIterator last,
const key_compare& comp = key_compare(),
const allocator_type& = allocator_type());
multiset (const multiset& x);
multiset (const multiset& x, const allocator_type& alloc);
multiset (multiset&& x);
multiset (multiset&& x, const allocator_type& alloc);
multiset (initializer_list<value_type> il,
const key_compare& comp = key_compare(),
const allocator_type& alloc = allocator_type());
成员函数
operator=
Copy container content (public member function )
Iterators:
multiset::begin
iterator begin() noexcept;
const_iterator begin() const noexcept; //返回指向文件开头的迭代器
multiset::end
iterator end() noexcept;
const_iterator end() const noexcept; //返回指向文件结尾的迭代器
multiset::rbegin
reverse_iterator rbegin() noexcept;
const_reverse_iterator rbegin() const noexcept; //返回指向容器调到后的开头的迭代器
multiset::rend
reverse_iterator rend() nothrow;
const_reverse_iterator rend() const nothrow; //返回指向容器调到后的结尾的迭代器
multiset::cbegin
const_iterator cbegin() const noexcept; //返回指向文件开头的const_iterator迭代器
multiset::cend
const_iterator cend() const noexcept; //返回指向文件结尾的const_iterator迭代器
multiset::crbegin
const_reverse_iterator crbegin() const noexcept; //返回指向文件反转后开头的const_iterator迭代器
multiset::crend
const_reverse_iterator crend() const noexcept; //返回指向文件反转后结尾的const_iterator迭代器
Capacity:
multiset::empty
bool empty() const noexcept; //判断容器是否为空
multiset::size
size_type size() const noexcept; //返回容器内元素的数量
multiset::max_size
size_type max_size() const noexcept; //返回容器内能容纳元素的最大数量
Modifiers:
multiset::insert
iterator insert (const value_type& val);
iterator insert (value_type&& val);
iterator insert (const_iterator position, const value_type& val);
iterator insert (const_iterator position, value_type&& val); //插入元素
template <class InputIterator>
void insert (InputIterator first, InputIterator last);
void insert (initializer_list<value_type> il);
multiset::erase
iterator erase (const_iterator position);
size_type erase (const value_type& val);
iterator erase (const_iterator first, const_iterator last); //从列表容器中移除单个元素或一系列元素([first, last))。
multiset::swap
void swap (multiset& x); //与容器x交换内容，大小可能不同
multiset::clear
void clear() noexcept; //清除容器内的内容
multiset::emplace
template <class... Args>
iterator emplace (Args&&... args); //通过在位置插入新元素来扩展容器
multiset::emplace_hint
template <class... Args>
iterator emplace_hint (const_iterator position, Args&&... args); //使用hint构造元素
Observers:
multiset::key_comp
key_compare key_comp() const; //返回比较的副本
multiset::value_comp
value_compare value_comp() const; //返回比较的副本
Operations:
multiset::find
const_iterator find (const value_type& val) const;
iterator find (const value_type& val); //寻找元素
multiset::count
size_type count (const value_type& val) const; //计算某个元素的个数
multiset::lower_bound
const_iterator lower_bound (const value_type& val) const;
iterator lower_bound (const value_type& val); //返回低于或等于该元素的迭代器
multiset::upper_bound
const_iterator upper_bound (const value_type& val) const;
iterator upper_bound (const value_type& val); //返回大于或等于该元素的迭代器
multiset::equal_range
pair<const_iterator,const_iterator> equal_range (const value_type& val) const;
pair<iterator,iterator> equal_range (const value_type& val); //返回一个范围的边界，该范围包含容器中与val等价的所有元素。
Allocator:
multiset::get_allocator
allocator_type get_allocator() const noexcept; //返回与列表容器关联的分配器对象的副本
多重映射（multimap）
multimap是一种关联容器，存储由键值和映射值按特定顺序组合而成的元素，多个元素可以具有相同的键值。
在multimap中，键值通常用于对元素进行排序和唯一标识，而映射的值则存储与该键相关的内容。key和映射值的类型可能不同，并在成员类型value_type中组合在一起，value_type是一种组合这两种类型的pair类型:
typedef pair<const Key, T> value_type;
在内部，multimap中的元素总是按照其键的严格弱排序标准进行排序，该标准由其内部比较对象(Compare类型)指示。
在通过键访问单个元素时，Multimap容器通常比unordered_multimap容器慢，但它们允许根据顺序直接迭代子集。
multimap通常被实现为二叉搜索树。
关联容器中的元素是通过它们的键引用的，而不是通过它们在容器中的绝对位置引用的。
容器中的元素始终遵循严格的顺序。所有插入的元素都按此顺序给定一个位置。
每个元素将一个键与一个映射值相关联:键意味着标识其主要内容是映射值的元素。
容器中的多个元素可以具有等价的键。
容器使用一个allocator对象来动态地处理其存储需求。
模板定义
template < class Key, // multimap::key_type
class T, // multimap::mapped_type
class Compare = less<Key>, // multimap::key_compare
class Alloc = allocator<pair<const Key,T> > // multimap::allocator_type
> class multimap;
构造函数
explicit multimap (const key_compare& comp = key_compare(),
const allocator_type& alloc = allocator_type());
explicit multimap (const allocator_type& alloc);
template <class InputIterator>
multimap (InputIterator first, InputIterator last,
const key_compare& comp = key_compare(),
const allocator_type& = allocator_type());
multimap (const multimap& x);
multimap (const multimap& x, const allocator_type& alloc);
multimap (multimap&& x);
multimap (multimap&& x, const allocator_type& alloc);
multimap (initializer_list<value_type> il,
const key_compare& comp = key_compare(),
const allocator_type& alloc = allocator_type());
成员函数
multimap::operator=
Iterators:
multimap::begin
iterator begin() noexcept;
const_iterator begin() const noexcept; //返回指向文件开头的迭代器
multimap::end
iterator end() noexcept;
const_iterator end() const noexcept; //返回指向文件结尾的迭代器
multimap::rbegin
reverse_iterator rbegin() noexcept;
const_reverse_iterator rbegin() const noexcept; //返回指向容器调到后的开头的迭代器
multimap::rend
reverse_iterator rend() nothrow;
const_reverse_iterator rend() const nothrow; //返回指向容器调到后的结尾的迭代器
multimap::cbegin
const_iterator cbegin() const noexcept; //返回指向文件开头的const_iterator迭代器
multimap::cend
const_iterator cend() const noexcept; //返回指向文件结尾的const_iterator迭代器
multimap::crbegin
const_reverse_iterator crbegin() const noexcept; //返回指向文件反转后开头的const_iterator迭代器
multimap::crend
const_reverse_iterator crend() const noexcept; //返回指向文件反转后结尾的const_iterator迭代器
Capacity:
multimap::empty
bool empty() const noexcept; //判断容器是否为空
multimap::size
size_type size() const noexcept; //返回容器内元素的数量
multimap::max_size
size_type max_size() const noexcept; //返回容器内能容纳元素的最大数量
Modifiers:
multimap::insert
iterator insert (const value_type& val);
template <class P>
iterator insert (P&& val);
iterator insert (const_iterator position, const value_type& val);
template <class P>
iterator insert (const_iterator position, P&& val);
template <class InputIterator>
void insert (InputIterator first, InputIterator last);
void insert (initializer_list<value_type> il); //插入元素
multimap::erase
iterator erase (const_iterator position);
size_type erase (const key_type& k);
iterator erase (const_iterator first, const_iterator last); //删除一个或一系列元素
multimap::swap
void swap (multimap& x); //与容器x的内容进行交换
multimap::clear
void clear() noexcept; //清除容器的内容
multimap::emplace
template <class... Args>
iterator emplace (Args&&... args); //通过在位置插入新元素来扩展容器
multimap::emplace_hint
template <class... Args>
iterator emplace_hint (const_iterator position, Args&&... args);//使用hint构造元素
Observers:
multimap::key_comp
key_compare key_comp() const; //返回比较的副本
multimap::value_comp
value_compare value_comp() const; //返回比较的副本
Operations:
multimap::find
iterator find (const key_type& k);
const_iterator find (const key_type& k) const; //寻找元素
multimap::count
size_type count (const key_type& k) const; //计算某个元素的个数
multimap::lower_bound
iterator lower_bound (const key_type& k);
const_iterator lower_bound (const key_type& k) const; //返回低于或等于该元素的迭代器
multimap::upper_bound
iterator upper_bound (const key_type& k);
const_iterator upper_bound (const key_type& k) const; //返回大于或等于该元素的迭代器
multimap::equal_range
pair<const_iterator,const_iterator> equal_range (const key_type& k) const;
pair<iterator,iterator> equal_range (const key_type& k);//返回一个范围的边界，该范围包含容器中与val等价的所有元素。
Allocator:
multimap::get_allocator
allocator_type get_allocator() const noexcept; //返回与列表容器关联的分配器对象的副本
无序集合（unordered_set）
无序集是不按特定顺序存储惟一元素的容器，允许根据元素的值快速检索单个元素。
在unordered_set中，元素的值同时也是唯一标识它的键。键是不可变的，因此，unordered_set中的元素在容器中不能被修改—但是它们可以被插入和删除。
在内部，unordered_set中的元素并不按照任何特定的顺序排序，而是根据它们的散列值组织到桶中，从而允许根据它们的值直接快速访问单个元素(平均平均时间复杂度为常数)。
与set容器相比，Unordered_set容器通过键访问单个元素的速度更快，尽管它们通常在通过元素的子集进行范围迭代时效率较低。
容器中的迭代器至少是前向迭代器。
关联容器中的元素是通过它们的键引用的，而不是通过它们在容器中的绝对位置引用的。
无序容器使用哈希表组织元素，允许通过键快速访问元素。
元素的值也是用来标识它的键。
容器中没有两个元素具有相同的键。
容器使用一个allocator对象来动态地处理其存储需求。
模板定义
template < class Key, // unordered_set::key_type/value_type
class Hash = hash<Key>, // unordered_set::hasher
class Pred = equal_to<Key>, // unordered_set::key_equal
class Alloc = allocator<Key> // unordered_set::allocator_type
> class unordered_set;
构造函数
explicit unordered_set ( size_type n = /* see below */,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& alloc = allocator_type() );
explicit unordered_set ( const allocator_type& alloc );
template <class InputIterator>
unordered_set ( InputIterator first, InputIterator last,
size_type n = /* see below */,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& alloc = allocator_type() );
unordered_set ( const unordered_set& ust );
unordered_set ( const unordered_set& ust, const allocator_type& alloc );
unordered_set ( unordered_set&& ust );
unordered_set ( unordered_set&& ust, const allocator_type& alloc );
unordered_set ( initializer_list<value_type> il,
size_type n = /* see below */,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& alloc = allocator_type() );
成员函数
operator=
Assign content (public member function )
Capacity
unordered_set::empty
bool empty() const noexcept; //判断容器是否为空。
unordered_set::size
size_type size() const noexcept; //返回容器中的元素数量
unordered_set::max_size
size_type max_size() const noexcept; //返回容器可容纳的最大元素数。
Iterators
unordered_set::begin
iterator begin() noexcept;
const_iterator begin() const noexcept;
local_iterator begin ( size_type n );
const_local_iterator begin ( size_type n ) const; //返回指容器或其bucket中的第一个元素的迭代器
unordered_set::end
iterator end() noexcept;
const_iterator end() const noexcept;
local_iterator end (size_type n);
const_local_iterator end (size_type n) const; //返回指容器或其bucket中的结尾元素的迭代器
unordered_set::cbegin
const_iterator cbegin() const noexcept;
const_local_iterator cbegin ( size_type n ) const; //返回const_iterator对象，指向容器或其bucket中的第一个元素。
unordered_set::cend
const_iterator cend() const noexcept;
const_local_iterator cend ( size_type n ) const; //返回const_iterator对象，指向容器或其bucket中的最后一个元素。
Element lookup
unordered_set::find
iterator find ( const key_type& k );
const_iterator find ( const key_type& k ) const; //在容器中搜索值为k的元素，如果找到则返回该元素的迭代器，否则返回 unordered_set:zend(容器末端的元素)的迭代器。
unordered_set::count
size_type count ( const key_type& k ) const; //在容器中搜索值为k的元素，并返回找到的元素数量
unordered_set::equal_range
pair<iterator,iterator>
equal_range ( const key_type& k );
pair<const_iterator,const_iterator>
equal_range ( const key_type& k ) const; //返回一个范围的边界，该范围包括所有比较等于k的元素。
Modifiers
unordered_set::emplace
template <class... Args>
pair <iterator,bool> emplace ( Args&&... args );//如果新元素的值是唯一的，则在无序集合中插入新元素。"
unordered_set::emplace_hint
template <class... Args如果新元素的值是唯一的，则在unordered_set中插入新元素。
iterator emplace_hint ( const_iterator position, Args&&... args );//如果新元素的值是唯一的，则在unordered_set中插入新元素。
unordered_set::insert
pair<iterator,bool> insert ( const value_type& val );
pair<iterator,bool> insert ( value_type&& val );
iterator insert ( const_iterator hint, const value_type& val );
iterator insert ( const_iterator hint, value_type&& val );
template <class InputIterator>
void insert ( InputIterator first, InputIterator last );
void insert ( initializer_list<value_type> il ); //插入元素
unordered_set::erase
iterator erase ( const_iterator position );
size_type erase ( const key_type& k );
iterator erase ( const_iterator first, const_iterator last ); //擦除容器中一个或一系列元素
unordered_set::clear
void clear() noexcept; //清楚容器中的元素
unordered_set::swap
void swap ( unordered_set& ust ); //通过ust的内容交换容器的内容，ust是另一个包含相同类型元素的unordered_set对象。 大小可能不同。
Buckets
unordered_set::bucket_count
size_type bucket_count() const noexcept; //返回unordered_set容器中桶的数量。
/*bucket是容器内部哈希表中的一个槽，根据元素的哈希值将其分配给该槽。桶的数量直接影响容器哈希表的加载因子(从而影响碰撞的概率)。容器会自动增加/ /桶的数量，以保持装载系数低于特定的阈值(最大装载系数)，导致每次需要增加桶的数量时进行重新散列*/
unordered_set::max_bucket_count
size_type max_bucket_count() const noexcept; //返回无序集容器可以拥有的最大桶数。这是由于系统限制或对其库实现的限制，容器可能拥 有的最大潜在桶数
unordered_set::bucket_size
size_type bucket_size ( size_type n ) const; //返回桶n中的元素个数。
unordered_set::bucket
size_type bucket ( const key_type& k ) const; //返回值为k的元素所在的桶号。
Hash policy
unordered_set::load_factor
float load_factor() const noexcept; //返回unordered_set容器中的当前加载因子。
unordered_set::max_load_factor
float max_load_factor() const noexcept; //返回unordered_set容器的当前最大加载因子。
void max_load_factor ( float z ); //设置z为无序集容器的新的最大加载因子。
unordered_set::rehash
void rehash ( size_type n ); //将容器中的桶数设置为n或更多。
unordered_set::reserve
void reserve ( size_type n ); //设置容器中桶的数量(bucket_count)为最合适的，至少包含n个元素。
Observers
unordered_set::hash_function
hasher hash_function() const; //返回unordered_set容器使用的哈希函数对象。
unordered_set::key_eq
key_equal key_eq() const; //返回unordered _set容器使用的键等价比较谓词。
unordered_set::get_allocator
allocator_type get_allocator() const noexcept; //返回用于构造容器的allocator对象。
无序映射（unordered_map）
无序映射是一种关联容器，它存储由键值和映射值组合而成的元素，允许基于键快速检索单个元素。
在unordered_map中，键值通常用于唯一地标识元素，而映射的值是一个具有与该键关联的内容的对象。键和映射值的类型可能不同。
在内部,unordered_map中的元素没有在任何特定的顺序排序对关键或映射值,但组织成桶取决于他们的散列值,以便快速访问单个元素直接的键值(平均一个恒定的平均时间复杂度)。
与map容器相比，Unordered_map容器通过键访问单个元素的速度更快，尽管它们通常在通过元素的子集进行范围迭代时效率较低。
无序映射实现了直接访问操作符(operator[])，该操作符允许使用映射值的键值作为参数直接访问映射值。
容器中的迭代器至少是前向迭代器。
关联容器中的元素是通过它们的键引用的，而不是通过它们在容器中的绝对位置引用的。
无序容器使用哈希表组织元素，允许通过键快速访问元素。
每个元素将一个键与一个映射值相关联:键意味着标识其主要内容是映射值的元素。
容器中没有两个元素具有相同的键。
容器使用一个allocator对象来动态地处理其存储需求。
模板定义
template < class Key, // unordered_map::key_type
class T, // unordered_map::mapped_type
class Hash = hash<Key>, // unordered_map::hasher
class Pred = equal_to<Key>, // unordered_map::key_equal
class Alloc = allocator< pair<const Key,T> > // unordered_map::allocator_type
> class unordered_map;
构造函数
explicit unordered_map ( size_type n = /* see below */,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& alloc = allocator_type() );
explicit unordered_map ( const allocator_type& alloc );
template <class InputIterator>
unordered_map ( InputIterator first, InputIterator last,
size_type n = /* see below */,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& alloc = allocator_type() );
unordered_map ( const unordered_map& ump );
unordered_map ( const unordered_map& ump, const allocator_type& alloc );
unordered_map ( unordered_map&& ump );
unordered_map ( unordered_map&& ump, const allocator_type& alloc );
unordered_map ( initializer_list<value_type> il,
size_type n = /* see below */,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& alloc = allocator_type() );
成员函数
unordered_map::operator=
Capacity
unordered_map::empty
bool empty() const noexcept; //判断容器是否为空。
unordered_map::size
size_type size() const noexcept; //返回容器中的元素数量
unordered_map::unordered_map::max_size
size_type max_size() const noexcept; //返回容器可容纳的最大元素数。
Iterators
unordered_map::begin
iterator begin() noexcept;
const_iterator begin() const noexcept;
local_iterator begin ( size_type n );
const_local_iterator begin ( size_type n ) const; //返回指容器或其bucket中的第一个元素的迭代器
unordered_map::end
iterator end() noexcept;
const_iterator end() const noexcept;
local_iterator end (size_type n);
const_local_iterator end (size_type n) const; //返回指容器或其bucket中的结尾元素的迭代器
unordered_map::cbegin
const_iterator cbegin() const noexcept;
const_local_iterator cbegin ( size_type n ) const; //返回const_iterator对象，指向容器或其bucket中的第一个元素。
unordered_map::cend
const_iterator cend() const noexcept;
const_local_iterator cend ( size_type n ) const; //返回const_iterator对象，指向容器或其bucket中的最后一个元素。
Element access
unordered_map::operator[]
mapped_type& operator[] ( const key_type& k );
mapped_type& operator[] ( key_type&& k );
unordered_map::at
mapped_type& at ( const key_type& k );
const mapped_type& at ( const key_type& k ) const; //返回对unordered_map中键为k的元素映射值的引用。
Element lookup
unordered_map::find
iterator find ( const key_type& k );
const_iterator find ( const key_type& k ) const; //在容器中搜索值为k的元素，如果找到则返回该元素的迭代器，否则返回
unordered_map::count
size_type count ( const key_type& k ) const; //在容器中搜索值为k的元素，并返回找到的元素数量
unordered_map::equal_range
pair<iterator,iterator>
equal_range ( const key_type& k );
pair<const_iterator,const_iterator>
equal_range ( const key_type& k ) const; //返回一个范围的边界，该范围包括所有比较等于k的元素。
Modifiers
unordered_map::emplace
template <class... Args>
pair<iterator, bool> emplace ( Args&&... args );//如果新元素的值是唯一的，则在无序集合中插入新元素。"
unordered_map::emplace_hint
template <class... Args>
iterator emplace_hint ( const_iterator position, Args&&... args );//如果新元素的值是唯一的，则在unordered_set中插入新元素。
unordered_map::insert
pair<iterator,bool> insert ( const value_type& val );
template <class P>
pair<iterator,bool> insert ( P&& val );
iterator insert ( const_iterator hint, const value_type& val );
template <class P>
iterator insert ( const_iterator hint, P&& val );
template <class InputIterator>
void insert ( InputIterator first, InputIterator last );
void insert ( initializer_list<value_type> il ); //插入元素
unordered_map::erase
iterator erase ( const_iterator position );
size_type erase ( const key_type& k );
iterator erase ( const_iterator first, const_iterator last );//擦除容器中一个或一系列元素
unordered_map::clear
void clear() noexcept; //清楚容器中的元素
unordered_map::swap
void swap ( unordered_map& ump ); //通过ust的内容交换容器的内容，ust是另一个包含相同类型元素的unordered_set对象。
Buckets
unordered_map::bucket_count
size_type bucket_count() const noexcept; //返回unordered_set容器中桶的数量。
unordered_map::max_bucket_count
size_type max_bucket_count() const noexcept; //返回无序集容器可以拥有的最大桶数。这是由于系统限制或对其库实现的限制，容器可能拥有的最大潜在桶数
unordered_map::bucket_size
size_type bucket_size ( size_type n ) const; //返回桶n中的元素个数。
unordered_map::bucket
size_type bucket ( const key_type& k ) const; //返回值为k的元素所在的桶号。
Hash policy
unordered_map::load_factor
float load_factor() const noexcept; //返回unordered_set容器中的当前加载因子。
unordered_map::max_load_factor
float max_load_factor() const noexcept; //返回unordered_set容器的当前最大加载因子。
void max_load_factor ( float z ); //设置z为无序集容器的新的最大加载因子。
unordered_map::rehash
void rehash( size_type n ); //将容器中的桶数设置为n或更多。
unordered_map::reserve
void reserve ( size_type n ); //设置容器中桶的数量(bucket_count)为最合适的，至少包含n个元素。
Observers
unordered_map::hash_function
hasher hash_function() const; //返回unordered_set容器使用的哈希函数对象。
unordered_map::key_eq
key_equal key_eq() const; //返回unordered _set容器使用的键等价比较谓词。
unordered_map::get_allocator
allocator_type get_allocator() const noexcept;
allocator_type get_allocator() const noexcept; //返回用于构造容器的allocator对象。
无序多重集合（unordered_multiset）
无序多集是一种不按特定顺序存储元素的容器，允许根据元素的值快速检索单个元素，很像unordered_set容器，但允许不同的元素具有相同的值。
在unordered_multiset中，元素的值同时是它的键，用来标识它。键是不可变的，因此，unordered_multiset中的元素不能在容器中修改一次——但是它们可以插入和删除。
在内部，unordered_multiset中的元素不是按照任何特定的顺序排序，而是根据它们的散列值组织到桶中，从而允许根据它们的值直接快速访问单个元素(平均时间复杂度为常数)。
具有相等值的元素被分组在同一个桶中，这样迭代器(参见equal_range)就可以遍历所有的元素。
容器中的迭代器至少是前向迭代器。
注意，这个容器不是在它自己的头文件中定义的，而是共享header <unordered_set>unordered_set。
关联容器中的元素是通过它们的键引用的，而不是通过它们在容器中的绝对位置引用的。
无序容器使用哈希表组织元素，允许通过键快速访问元素。
元素的值也是用来标识它的键。
容器可以存放多个具有等价键的元素。
容器使用一个allocator对象来动态地处理其存储需求。
模板定义
template < class Key, // unordered_multiset::key_type/value_type
class Hash = hash<Key>, // unordered_multiset::hasher
class Pred = equal_to<Key>, // unordered_multiset::key_equal
class Alloc = allocator<Key> // unordered_multiset::allocator_type
> class unordered_multiset;
构造函数
empty (1)
explicit unordered_multiset ( size_type n = /* see below */,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& alloc = allocator_type() );
explicit unordered_multiset ( const allocator_type& alloc );
range (2)
template <class InputIterator>
unordered_multiset ( InputIterator first, InputIterator last,
size_type n = /* see below */,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& alloc = allocator_type() );
copy (3)
unordered_multiset ( const unordered_multiset& ums );
unordered_multiset ( const unordered_multiset& ums, const allocator_type& alloc );
move (4)
unordered_multiset ( unordered_multiset&& ums );
unordered_multiset ( unordered_multiset&& ums, const allocator_type& alloc );
initializer list (5)
unordered_multiset ( initializer_list<value_type> il,
size_type n = /* see below */,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& alloc = allocator_type() );
成员函数
unordered_multiset::operator=
Capacity
unordered_multiset::empty
bool empty() const noexcept; //判断容器是否为空。
unordered_multiset::size
size_type size() const noexcept; //返回容器中的元素数量
unordered_multiset::max_size
size_type max_size() const noexcept; //返回容器可容纳的最大元素数。
Iterators
unordered_multiset::begin
iterator begin() noexcept;
const_iterator begin() const noexcept;
local_iterator begin ( size_type n );
const_local_iterator begin ( size_type n ) const; //返回指容器或其bucket中的第一个元素的迭代器
unordered_multiset::end
iterator end() noexcept;
const_iterator end() const noexcept;
local_iterator end (size_type n);
const_local_iterator end (size_type n) const; //返回指容器或其bucket中的结尾元素的迭代器
unordered_multiset::cbegin
const_iterator cbegin() const noexcept;
const_local_iterator cbegin ( size_type n ) const; //返回const_iterator对象，指向容器或其bucket中的第一个元素。
unordered_multiset::cend
const_iterator cend() const noexcept;
const_local_iterator cend ( size_type n ) const; //返回const_iterator对象，指向容器或其bucket中的最后一个元素。
Element lookup
unordered_multiset::find
iterator find ( const key_type& k );
const_iterator find ( const key_type& k ) const; //在容器中搜索值为k的元素，如果找到则返回该元素的迭代器，否则返回
unordered_multiset::count
size_type count ( const key_type& k ) const; //在容器中搜索值为k的元素，并返回找到的元素数量
unordered_multiset::equal_range
pair<iterator,iterator>
equal_range ( const key_type& k );
pair<const_iterator,const_iterator>
equal_range ( const key_type& k ) const; //返回一个范围的边界，该范围包括所有比较等于k的元素。
Modifiers
unordered_multiset::emplace
template <class... Args>
pair <iterator,bool> emplace ( Args&&... args );//如果新元素的值是唯一的，则在无序集合中插入新元素。"
unordered_multiset::emplace_hint
template <class... Args如果新元素的值是唯一的，则在unordered_set中插入新元素。
iterator emplace_hint ( const_iterator position, Args&&... args );//如果新元素的值是唯一的，则在unordered_set中插入新元素。
unordered_multiset::insert
pair<iterator,bool> insert ( const value_type& val );
pair<iterator,bool> insert ( value_type&& val );
iterator insert ( const_iterator hint, const value_type& val );
iterator insert ( const_iterator hint, value_type&& val );
template <class InputIterator>
void insert ( InputIterator first, InputIterator last );
void insert ( initializer_list<value_type> il ); //插入元素
unordered_multiset::erase
iterator erase ( const_iterator position );
size_type erase ( const key_type& k );
iterator erase ( const_iterator first, const_iterator last ); //擦除容器中一个或一系列元素
unordered_multiset::clear
void clear() noexcept; //清楚容器中的元素
unordered_multiset::swap
void swap ( unordered_set& ust ); //通过ust的内容交换容器的内容，ust是另一个包含相同类型元素的unordered_set对象。大小可能不同。
Buckets
unordered_multiset::bucket_count
size_type bucket_count() const noexcept; //返回unordered_set容器中桶的数量。
/*bucket是容器内部哈希表中的一个槽，根据元素的哈希值将其分配给该槽。桶的数量直接影响容器哈希表的加载因子(从而影响碰撞的概率)。容器会自动增加//桶的数量，以保持装载系数低于特定的阈值(最大装载系数)，导致每次需要增加桶的数量时进行重新散列*/
unordered_multiset::max_bucket_count
size_type max_bucket_count() const noexcept; //返回无序集容器可以拥有的最大桶数。这是由于系统限制或对其库实现的限制，容器可能拥有的最大潜在桶数
unordered_multiset::bucket_size
size_type bucket_size ( size_type n ) const; //返回桶n中的元素个数。
unordered_multiset::bucket
size_type bucket ( const key_type& k ) const; //返回值为k的元素所在的桶号。
Hash policy
unordered_multiset::load_factor
float load_factor() const noexcept; //返回unordered_set容器中的当前加载因子。
unordered_multiset::max_load_factor
float max_load_factor() const noexcept; //返回unordered_set容器的当前最大加载因子。
void max_load_factor ( float z ); //设置z为无序集容器的新的最大加载因子。
unordered_multiset::rehash
void rehash ( size_type n ); //将容器中的桶数设置为n或更多。
unordered_multiset::reserve
void reserve ( size_type n ); //设置容器中桶的数量(bucket_count)为最合适的，至少包含n个元素。
Observers
unordered_multiset::hash_function
hasher hash_function() const; //返回unordered_set容器使用的哈希函数对象。
unordered_multiset::key_eq
key_equal key_eq() const; //返回unordered _set容器使用的键等价比较谓词。
unordered_multiset::get_allocator
allocator_type get_allocator() const noexcept; //返回用于构造容器的allocator对象。
无序多重映射（unordered_multimap）
无序multimap是一种关联容器，存储由键值和映射值组合而成的元素，很像unordered_map容器，但允许不同的元素拥有相同的键值。
在unordered_multimap中，键值通常用于唯一地标识元素，而映射的值是与该键关联的内容的对象。键和映射值的类型可能不同。
在内部,unordered_multimap中的元素没有在任何特定的顺序排序对关键或映射值,但组织成桶取决于他们的散列值,以便快速访问单个元素直接的键值(平均一个恒定的平均时间复杂度)。
具有等价键的元素被分组在同一个bucket中，这样迭代器(参见equal_range)就可以遍历所有的元素。
容器中的迭代器至少是前向迭代器。
注意，这个容器不是在它自己的头文件中定义的，而是共享header <unordered_map>unordered_map。
关联容器中的元素是通过它们的键引用的，而不是通过它们在容器中的绝对位置引用的。
无序容器使用哈希表组织元素，允许通过键快速访问元素。
每个元素将一个键与一个映射值相关联:键意味着标识其主要内容是映射值的元素。容器可以存放多个具有等价键的元素。
容器使用一个allocator对象来动态地处理其存储需求。
模板定义
template < class Key, // unordered_multimap::key_type
class T, // unordered_multimap::mapped_type
class Hash = hash<Key>, // unordered_multimap::hasher
class Pred = equal_to<Key>, // unordered_multimap::key_equal
class Alloc = allocator< pair<const Key,T> > // unordered_multimap::allocator_type
> class unordered_multimap;
构造函数
explicit unordered_multimap ( size_type n = /* see below */,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& alloc = allocator_type() );
explicit unordered_multimap ( const allocator_type& alloc );
template <class InputIterator>
unordered_multimap ( InputIterator first, InputIterator last,
size_type n = /* see below */,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& alloc = allocator_type() );
unordered_multimap ( const unordered_multimap& umm );
unordered_multimap ( const unordered_multimap& umm, const allocator_type& alloc );
unordered_multimap ( unordered_multimap&& umm );
unordered_multimap ( unordered_multimap&& umm, const allocator_type& alloc );
unordered_multimap ( initializer_list<value_type> il, size_type n = /* see below */,
const hasher& hf = hasher(), const key_equal& eql = key_equal(),
const allocator_type& alloc = allocator_type() );
成员函数
unordered_multimap::operator=
Capacity
unordered_multimap::empty
bool empty() const noexcept; //判断容器是否为空。
unordered_multimap::size
size_type size() const noexcept; //返回容器中的元素数量
unordered_multimap::max_size
size_type max_size() const noexcept; //返回容器可容纳的最大元素数。
Iterators
unordered_multimap::begin
iterator begin() noexcept;
const_iterator begin() const noexcept;
local_iterator begin ( size_type n );
const_local_iterator begin ( size_type n ) const; //返回指容器或其bucket中的第一个元素的迭代器
unordered_multimap::end
iterator end() noexcept;
const_iterator end() const noexcept;
local_iterator end (size_type n);
const_local_iterator end (size_type n) const; //返回指容器或其bucket中的结尾元素的迭代器
unordered_multimap::cbegin
const_iterator cbegin() const noexcept;
const_local_iterator cbegin ( size_type n ) const; //返回const_iterator对象，指向容器或其bucket中的第一个元素。
unordered_multimap::cend
const_iterator cend() const noexcept;
const_local_iterator cend ( size_type n ) const; //返回const_iterator对象，指向容器或其bucket中的最后一个元素。
Element lookup
unordered_multimap::find
iterator find ( const key_type& k );
const_iterator find ( const key_type& k ) const; //在容器中搜索值为k的元素，如果找到则返回该元素的迭代器，否则返回
unordered_multimap::count
size_type count ( const key_type& k ) const; //在容器中搜索值为k的元素，并返回找到的元素数量
unordered_multimap::equal_range
pair<iterator,iterator>
equal_range ( const key_type& k );
pair<const_iterator,const_iterator>
equal_range ( const key_type& k ) const; //返回一个范围的边界，该范围包括所有比较等于k的元素。
Modifiers
unordered_multimap::emplace
template <class... Args>
pair <iterator,bool> emplace ( Args&&... args );//如果新元素的值是唯一的，则在无序集合中插入新元素。"
unordered_multimap::emplace_hint
template <class... Args如果新元素的值是唯一的，则在unordered_set中插入新元素。
iterator emplace_hint ( const_iterator position, Args&&... args );//如果新元素的值是唯一的，则在unordered_set中插入新元素。
unordered_multimap::insert
pair<iterator,bool> insert ( const value_type& val );
pair<iterator,bool> insert ( value_type&& val );
iterator insert ( const_iterator hint, const value_type& val );
iterator insert ( const_iterator hint, value_type&& val );
template <class InputIterator>
void insert ( InputIterator first, InputIterator last );
void insert ( initializer_list<value_type> il ); //插入元素
unordered_multimap::erase
iterator erase ( const_iterator position );
size_type erase ( const key_type& k );
iterator erase ( const_iterator first, const_iterator last ); //擦除容器中一个或一系列元素
unordered_multimap::clear
void clear() noexcept; //清楚容器中的元素
unordered_multimap::swap
void swap ( unordered_set& ust ); //通过ust的内容交换容器的内容，ust是另一个包含相同类型元素的unordered_set对象。大小可能不同。
Buckets
unordered_multimap::bucket_count
size_type bucket_count() const noexcept; //返回unordered_set容器中桶的数量。
/*bucket是容器内部哈希表中的一个槽，根据元素的哈希值将其分配给该槽。桶的数量直接影响容器哈希表的加载因子(从而影响碰撞的概率)。容器会自动增加//桶的数量，以保持装载系数低于特定的阈值(最大装载系数)，导致每次需要增加桶的数量时进行重新散列*/
unordered_multimap::max_bucket_count
size_type max_bucket_count() const noexcept; //返回无序集容器可以拥有的最大桶数。这是由于系统限制或对其库实现的限制，容器可能拥有的最大潜在桶数
unordered_multimap::bucket_size
size_type bucket_size ( size_type n ) const; //返回桶n中的元素个数。
unordered_multimap::bucket
size_type bucket ( const key_type& k ) const; //返回值为k的元素所在的桶号。
Hash policy
unordered_multimap::load_factor
float load_factor() const noexcept; //返回unordered_set容器中的当前加载因子。
unordered_multimap::max_load_factor
float max_load_factor() const noexcept; //返回unordered_set容器的当前最大加载因子。
void max_load_factor ( float z ); //设置z为无序集容器的新的最大加载因子。
unordered_multimap::rehash
void rehash ( size_type n ); //将容器中的桶数设置为n或更多。
unordered_multimap::reserve
void reserve ( size_type n ); //设置容器中桶的数量(bucket_count)为最合适的，至少包含n个元素。
Observers
unordered_multimap::hash_function
hasher hash_function() const; //返回unordered_set容器使用的哈希函数对象。
unordered_multimap::key_eq
key_equal key_eq() const; //返回unordered _set容器使用的键等价比较谓词。
unordered_multimap::get_allocator
allocator_type get_allocator() const noexcept; //返回用于构造容器的allocator对象。
多容器
#include <iterator>
#include <iostream>
#include <vector>
#include <queue>
#include <list>
#include <algorithm>
using namespace std;
template <class T>
void printContainer(const char *msg, const T &s)
{
cout << msg << ": ";
copy(s.begin, s.end, ostream_iterator<int>(cout, ""));
cout << endl;
}
int main()
{
deque<int> s;
for(int i = 0; i < 10; i++)
{
int x;
cin >> x;
s.push_front(x);
}
printContainer("deque at first", s);
list<int> l(s.rbegin(), s.rend());
printContainer("list at first", l);
list<int>::iterator iter = l.begin();
while(iter != l.end())
{
int v = *iter;
iter = l.erase(iter);
l.insert(++iter, v);
}
printContainer("list at first", l);
s.assign(l.begin(), l.end());
printContainer("deque at first", s);
return 0;
}
双端队列
#include <iterator>
#include <iostream>
#include <vector>
#include <queue>
#include <list>
#include <algorithm>
using namespace std;
int main()
{
istream_iterator<int> i1(cin), i2;
vector<int> s1(i1, i2);
sort(s1.begin(), s1.end());
deque<int> s2;
for (vector<int>::iterator iter = s1.begin(); iter != s1.end(); ++iter)
{
if(*iter % 2 == 0)
s2.push_back(*iter);
else
s2.push_front(*iter);
}
copy(s2.begin(), s2.end(), ostream_iterator<int>(cout, ""));
cout << endl;
return 0;
}
splice(position,list_value);
splice(position,list_value,ptr);
splice(position,list_value,first,last);
list_value是一个已存在的列表，它将被插入到源列表中，position是一个迭代參数，他当前指向的是要进行拼接的列表中的特定位置。
列表
#include <iterator>
#include <iostream>
#include <vector>
#include <queue>
#include <list>
#include <algorithm>
using namespace std;
int main()
{
string names1[] = {"Alice","Helen", "Lucy", "Susan"};
string names2[] = {"Bob", "David", "Levin", "Mike"};
list<string> s1(names1, names1 + 4);
list<string> s2(names2, names2 + 4);
s2.splice (s2.end(), s1, s1.begin());
list<string>::iterator iter1 = s1.begin();
advance(iter1, 2);
list<string>::iterator iter2 = s2.begin();
++iter2;
list<string>::iterator iter3 = iter2;
advance(iter3, 2);
s1.splice(iter1, s2, iter2, iter3);
copy(s1.begin(), s1.end(), ostream_iterator<string>(cout, " "));
cout << endl;
copy(s2.begin(), s2.end(), ostream_iterator<string>(cout, " "));
cout << endl;
return 0;
}
栈
#include <iterator>
#include <iostream>
#include <vector>
#include <queue>
#include <list>
#include <stack>
#include <string>
#include <algorithm>
using namespace std;
int main()
{
string str;
stack<char> s;
cin >> str;
for(string::iterator iter = str.begin(); iter != str.end(); ++iter)
s.push(*iter);
while(!s.empty())
{
cout << s.top();
s.pop();
}
cout << endl;
return 0;
}
class cell;
priority_queue<cell> cellQueue;
集合
#include <set>
#include <list>
#include <queue>
#include <vector>
#include <iterator>
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
set<double> s;
while(true) {
double v;
cin >> v;
if(v == 0) break;
pair<set<double>::iterator, bool> r = s.insert(v);
if(!r.second)
cout << v << "is duplicated" << endl;
}
set<double>::iterator iter1 = s.begin();
set<double>::iterator iter2 = s.end();
double medium = (*iter1 + *(--iter2)) / 2;
cout << "<= medium: ";
copy(s.begin(), s.upper_bound(medium), ostream_iterator<double>(cout ," "));
cout << endl;
cout << ">= medium: ";
copy(s.lower_bound(medium), s.end(), ostream_iterator<double>(cout, " "));
cout << endl;
return 0;
}
映射
#include <set>
#include <map>
#include <list>
#include <queue>
#include <string>
#include <vector>
#include <iterator>
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
map<string, int> course;
course.insert(make_pair("CSAPP", 3));
course.insert(make_pair("C++", 2));
course.insert(make_pair("CSARCH", 4));
course.insert(make_pair("COMPILER", 4));
course.insert(make_pair("OS", 5));
int n = 3;
int sum = 0;
while(n > 0) {
string name;
cin >> name;
map<string, int>::iterator iter = course.find(name);
if(iter == course.end()) {
cout << name << "is not available" << endl;
} else {
sum += iter -> second;
course.erase(iter);
n--;
}
}
cout << "Total credit: " << sum << endl;
return 0;
}
多重集合与多重映射
#include <set>
#include <map>
#include <list>
#include <queue>
#include <string>
#include <vector>
#include <iterator>
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
multimap<string, string> courses;
typedef multimap<string, string>::iterator CourseIter;
courses.insert(make_pair("c++", "2-6"));
courses.insert(make_pair("COMPILER", "3-1"));
courses.insert(make_pair("COMPILER", "5-2"));
courses.insert(make_pair("OS", "1-2"));
courses.insert(make_pair("OS", "4-1"));
courses.insert(make_pair("OS", "5-5"));
string name;
int count;
do {
cin >> name;
count = courses.count(name);
if(count == 0)
cout << "Cannot find this course!" << endl;
} while (count == 0);
cout << count << " lesson(s) per week: ";
pair<CourseIter, CourseIter> range = courses.equal_range(name);
for (CourseIter iter = range.first; iter != range.second; ++iter)
cout << iter->second << " ";
cout << endl;
return 0;
}
函数对象
#include <iostream>
#include <numeric>
using namespace std;
class MultClass {
public:
int operator() (int x, int y) {
return x + y;
}
};
int main()
{
int a[] = {1, 2, 3, 4, 5};
const int N = sizeof(a) / sizeof(int);
cout << accumulate(a, a + N, 0, MultClass()) << endl;
return 0;
}
#include <iterator>
#include <iostream>
#include <numeric>
#include <algorithm>
using namespace std;
int mult(int x, int y) { return x * y; };
int main()
{
int a[] = {1, 2, 3, 4, 5};
const int N = sizeof(a) / sizeof(int);
cout << "The result by multipling all elements in a is " << accumulate(a, a + N, 1, mult) << endl;
return 0;
}
#include <set>
#include <map>
#include <list>
#include <queue>
#include <string>
#include <vector>
#include <iterator>
#include <iostream>
#include <numeric>
#include <algorithm>
using namespace std;
int main()
{
int intArr[] = {30, 90, 10, 40, 70, 50, 20, 80};
const int N = sizeof(intArr) / sizeof(int);
vector<int> a(intArr, intArr + N);
cout << "before sorting:" << endl;
copy(a.begin(), a.end(), ostream_iterator<int>(cout, "\t"));
cout << endl;
sort(a.begin(), a.end(), greater<int>());
cout << "after sorting:" << endl;
copy(a.begin(), a.end(), ostream_iterator<int>(cout, "\t"));
cout << endl;
return 0;
}
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)
