1. vector

元素可重复的长度可变的线性表，类似 java 的 ArrayList

成员函数
$\color{red}{ Access }$
operator[]	`reference operator[] (size_type n);` `const_reference operator[] (size_type n) const;` 表明可以通过数组以角标方式访问，即将其视作指针；*若角标越界，则行为未知*
at()	`reference at (size_type n);` `const_reference at (size_type n) const;` 获取指定角标的元素，*如果不存在该角标，那么抛出越界异常*
data()	`value_type* data() noexcept;` `const value_type* data() const noexcept;` 获取该vector实例的首地址，即指针
front()	`reference front();` `const_reference front() const;` 获取该vector实例的首个元素
back()	`reference back();` `const_reference back() const;` 获取该vector实例的末尾元素

$\color{red}{ Capacity }$
empty()	`bool empty() const;` 容器是否为空（没有元素）
size()	`size_type size() const;` 容器内元素的数量，非负数
capacity()	`size_type capacity() const;` 容器已分配内存可存放元素的数量，一般略大于 size()
max_size()	`size_type max_size() const;` 最大的元素数量，像是固定值？ 0x3FFFFFFF
resize()	`void resize (size_type n, value_type val = value_type());` 容器的元素数量置为 n；若 n 小于原大小，则从尾部开始删除，剩余n个元素，capacity不会变化；若 n 大于原大小，则添加元素，若指定值，则新增元素都等于该值，若不指定则是0，capacity随之变化。
reserve()	`void reserve (size_type n);` 请求 vector 的容量（capacity）至少可以包含 n 个元素。若 n 小于原capacity，则无变化；若 n 大于原capacity，则capacity=n。
shrink_to_fit()	`void shrink_to_fit();` 使得 capacity = size

$\color{red}{ Iterators }$	*iterator 即可取到迭代器对应的元素
begin()	`iterator begin();` `const_iterator begin() const;`
end()	`iterator end();` `const_iterator end() const;`
cbegin()	`const_iterator cbegin() const noexcept;`
cend()	`const_iterator cend() const noexcept;`
rbegin()	`reverse_iterator rbegin();` `const_reverse_iterator rbegin() const;`
rend()	`reverse_iterator rend();` `const_reverse_iterator rend() const;`
crbegin()	`const_reverse_iterator crbegin() const noexcept;`
crend()	`const_reverse_iterator crend() const noexcept;`

$\color{red}{ Modifier }$
clear()	`void clear();` 清空内部元素，size变成0，但capacity不变
push_back()	`void push_back (const value_type& val);` 从尾部添加指定元素
pop_back()	`void pop_back();` 从尾部删除一个元素
insert()	`iterator insert (iterator position, const value_type& val);` 向指定位置的前面，插入元素，返回的迭代器指向刚刚插入的元素 `void insert (iterator position, size_type n, const value_type& val);` 向指定位置的前面，插入 n 个指定值的元素 `template <class InputIterator> void insert (iterator position, InputIterator first, InputIterator last);` 向指定位置的前面，插入迭代器的 [first, last) 之间的元素
erase()	`iterator erase (iterator position);` 删除指定迭代器的元素 `iterator erase (iterator first, iterator last);` 删除迭代器 [first, last) 之间的元素
swap()	`void swap (vector& x);` 交换两个vector的所有元素
assign()	`void assign (size_type n, const value_type& val);` 清空容器，指定容器的大小，并全部赋予初值 `template <class InputIterator> void assign (InputIterator first, InputIterator last);` 清空容器，将迭代器 [first, last) 之间的元素放入容器中
emplace()	`template <class... Args>iterator emplace (const_iterator position, Args&&... args);` 在指定的位置（iterator）的前面，插入一个新元素，该新元素以第二个及后续参数作为构其造函数的参数
emplace_back()	`template <class... Args> void emplace_back (Args&&... args);` 在vector尾部插入一个新元素，该新元素以第二个及后续参数作为其构造函数的参数

2. set

元素 $\color{red}{不}$ 可重复的长度可变的线性表
与 map 对外提供了相同的方法（方法名相同），仅参数或元素类型等不同。
可能与 java 类似，也是由 map 实现的。

3.array

元素可重复的长度 $\color{red}{不}$ 可变的线性表
std::array<type, fixed-length> arr;

成员函数
$\color{red}{ Access }$	同 vector
$\color{red}{ Capacity }$	同 map
$\color{red}{ Iterators }$	同 vector
$\color{red}{ Modifiers }$
fill()	`void fill (const value_type& val);` 用指定的值，填充数组
swap()	交换两个容器的内容

5. other linear tables（list, stack, queue, deque）

list：序列容器，允许常量时间内的操作和移除操作，可双向操作。
stack: FIFO 栈，只能操作线性表的一端；
queue：FIFO 队列，线性表一端新增，另一端删除；
deque：队列，线性表的两端均可操作；

6. map

键值对，同一个 map 内 key 唯一。

成员函数
$\color{red}{ Access }$
operator[]	`reference operator[] (size_type n);` `const_reference operator[] (size_type n) const;` 表明可以通过数组以角标方式访问，即将其视作指针；*如果指定的位置不存在，那么该操作符会创建该key并返回默认元素*。
at()	`reference at (size_type n);` `const_reference at (size_type n) const;` 获取指定角标的元素；*如果找不到该key 会抛出异常*。

$\color{red}{ Capacity }$
empty()	`bool empty() const;` 容器是否为空（没有元素）
size()	`size_type size() const;` 容器内元素的数量，非负数
max_size()	`size_type max_size() const;` 最大的元素数量，固定值？？

$\color{red}{ Iterators }$	迭代器的函数与 vector 相同 *iterator 即可取到迭代器对应的map的元素，其元素类型是 *std::pair<const key_type, mapped_type>； iterator->first* 取 map 某元素的 key; iterator->second 取 map 某元素的 value

$\color{red}{ Modifiers }$
swap()	`void swap (map& x);` 交换本容器与参数容器的内部元素
clear()	清空
erase()	`iterator erase (const_iterator position);` 删除指定位置 `size_type erase (const key_type& k);` 直接删除 key `iterator erase (const_iterator first, const_iterator last);` 删除指定的key范围的键值对
insert()	`pair<iterator,bool> insert (const value_type& val);` `template <class P> pair<iterator,bool> 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);` insert(std::map<type1, type2>(value1, value2)) insert(std::pair<type1, type2>(value1, value2)) insert(std::make_pair(value1, value2))
emplace()	`template <class... Args>` `pair<iterator,bool> emplace (Args&&... args);`
emplace_hint()	`template <class... Args>` `iterator emplace_hint (const_iterator position, Args&&... args);`

$\color{red}{ Observers }$
key_comp()	`key_compare key_comp() const;` 返回用于比较容器内 key 的比较器对象；该对象决定元素在容器内的排序；该比较器是一个函数指针或函数对象，它有两个参数（key 类型），若前者小于后者则返回true，否则返回false
value_comp()	`value_compare value_comp() const;` 返回用于比较*两个元素（元素类型）*的比较器对象，该比较器函数的作用是决定哪个元素的 key 应该在前面

$\color{red}{ Operations}$
find()	`iterator find (const key_type& k);` `const_iterator find (const key_type& k) const;` 在 map 中寻找指定的key，若找到返回迭代器；若找不到返回 map.end()
count()	`size_type count (const key_type& k) const;` 在map中寻找指定的key的数量，由于map的key唯一，因此若存在则是1；否则返回0
lower_bound()	`iterator lower_bound (const key_type& k);` `const_iterator lower_bound (const key_type& k) const;` 如果存在该指定的key，则返回该指定key的迭代器；*若不存在呢？*
upper_bound()	`iterator upper_bound (const key_type& k);` `const_iterator upper_bound (const key_type& k) const;` 若存在该指定的key，则返回该指定key的后一个元素的迭代器；*若不存在呢？*
equal_range()	`pair<const_iterator,const_iterator> equal_range (const key_type& k) const;` `pair<iterator,iterator> equal_range (const key_type& k);` 返回包含指定key的边界范围，空间包含的形态是 [ , )。若指定key不存在，则边界范围是 [当前元素迭代器，下一个元素迭代器)；若指定key不存在，则边界范围是相同元素的迭代器

STL - Container