[人工智能]STL | STL成员大汇总及其分类（必看）

前言

一、容器内的型别

1.1 value_type

container::value_type
* 元素型别；
* 用于sets和multisets为常数；
* 用于map和multimaps为pair<const key-type, vaue-type>；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

1.2 reference

container::reference
* 元素引用型别；
* 在vector<bool>中是个辅助类别；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

1.3 const_reference

container::const_reference
* 常数元素的引用型别；
* 在vector<bool>中是bool；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

1.4 iterator

container::iterator
* 迭代器型别；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

1.5 const_iterator

container::const_iterator
* 常数迭代器型别；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

1.6 reverse_iterator

container::reverse_iterator
* 反向迭代器型别；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

1.7 const_reverse_iterator

container::const_reverse_iterator
* 常数反向迭代器型别；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

1.8 size_type

container::size_type
* 常数反向迭代器型别；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

1.9 difference_type

container::difference_type
* 无正负号整数型别，用于定义容器大小；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

1.10 key_type

container::key_type
* 用于定义关联式容器元素内的key型别；
* 用于sets和multisets时，相当于value_type；
* 可用容器：sets、mulitsets、maps、multimaps；

1.11 mapped_type

container::mapped_type
* 用于定义关联式容器元素的key类别；
* 可用容器：maps、multimaps；

1.12 key_compare

container::key_compare
* 关联式容器内的“比较准则”的型别；
* 可用容器：sets、mulitsets、maps、multimaps；

1.13 value_compare

container::key_type
* 用于整个元素之“比较准则”的型别；
* 用于sets和multisets时，相当于key_compare；
* 可用容器：sets、mulitsets、maps、multimaps；

1.14 allocator_type

container::key_type
* 配置器型别；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

二、生成

2.1 container()

container::container()
* default默认构造；
* 产生一个新的空容器；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

2.2 container(const CompFunc& op)

explicit container::container(const CompFunc& op)
* 以op排序准则，生产一个空容器；
* 可用容器：sets、mulitsets、maps、multimaps；

2.3 container(const container& c)

explicit container::container(const container& c)
* copy默认构造；
* 产生一个既有容器的一个副本；
* 针对c中的每一个元素调用copy构造函数；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

2.4 container(size_type num)

container::container(size_type num)
* 产生一个容器，可含有num个元素；
* 元素由其default默认构造函数创建；
* 可用容器：vector、deques、lists；

2.5 container(size_type num, const T& value)

container::container(size_type num, const T& value)
* 产生一个容器，可含有num个元素；
* 所有元素都是value的副本；
* T是元素型别；
* 对于strings，value并非pass by reference；
* 可用容器：vector、deques、lists、strings；

2.6 container(InputIterator beg, InputIterator end)

template<class InputIterator>
container::container(InputIterator beg, InputIterator end)
* 产生一个容器，并以区间[beg, end)内的所有元素为初值；
* 需要源区间的元素型别可转换为容器元素型别；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

2.7 container(InputIterator beg, InputIterator end， const CompFunc& op)

template<class InputIterator>
container::container(InputIterator beg, InputIterator end， const CompFunc& op)
* 产生一个容器，并以区间[beg, end)内的所有元素为初值，以op为排序准则；
* 需要源区间的元素型别可转换为容器元素型别；
* 可用容器：sets、mulitsets、maps、multimaps；

2.8 ~container()

container::~container()
* 析构函数；
* 移除所有元素，并释放内存；
* 对每个元素调用其析构函数；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

三、非变动性操作

3.1 size()

size_type container::size() const
* 返回现有元素的数目；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

3.2 empty()

bool container::empty() const
* 检查容器是否为空，相比于size更快；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

3.3 max_size()

size_type container::max_size() const
* 返回容器可包含的最大元素个数；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

3.4 capacity()

size_type container::capacity() const
* 返回重新分配内存之前能容纳的最多元素个数；
* 可用容器：vector、strings；

3.5 reserve(size_type num)

void container::reserve(size_type num) 
* 在内部保留若干内存，至少能容纳num个元素；
* 若num太小，则对vector无效；对string是一个非绑定的缩减请求；
* vector重新分配耗时，且迭代器等失效，该函数解决此类问题；
* 可用容器：vector、strings；

3.6 comparison(const container& c1, const container& c2)

bool comparison(const container& c1, const container& c2)
* 返回两个同型容器的比较结果；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

3.7 count(const T& value)

size_type container::count(const T& value) const
* 返回与value相等的元素个数；
* 可用容器：sets、mulitsets、maps、multimaps；

3.8 find(const T& value)

iterator container::find(const T& value) 
const_iterator container::find(const T& value)  const
* 查找等于value的第一个元素的位置，若没有返回end()；
* 复杂度：对数；
* 可用容器：sets、mulitsets、maps、multimaps；

3.9 lower_bound(const T& value)

iterator container::lower_bound(const T& value) 
const_iterator container::lower_bound(const T& value)  const
* 根据排序准则，可安插value副本的第一个位置，失败返回end()；
* 复杂度：对数；
* 可用容器：sets、mulitsets、maps、multimaps；

3.10 upper_bound(const T& value)

iterator container::upper_bound(const T& value) 
const_iterator container::upper_bound(const T& value)  const
* 根据排序准则，可安插value副本的最后一个位置，失败返回end()；
* 复杂度：对数；
* 可用容器：sets、mulitsets、maps、multimaps；

3.11 equal_range(const T& value)

pair<iterator, iterator> container::equal_range(const T& value) 
pair<const_iterator , const_iterator >container::equal_range(const T& value)  const
* 返回一个区间，根据排序准则，可安插value副本的第一个位置和最后一个位置；
* 复杂度：对数；
* 可用容器：sets、mulitsets、maps、multimaps；

3.12 key_comp()

key_compare container::key_comp() 
* 返回一个比较准则；
* 可用容器：sets、mulitsets、maps、multimaps；

3.13 value_comp()

value_compare container::value_comp() 
* 返回一个比较准则的对象；
* 在sets中，相当于key_comp()；map中用来比较俩个key；
* 可用容器：sets、mulitsets、maps、multimaps；

四、赋值

4.1 operator = (const container& c)

container& container::operator = (const container& c)
* 将c的所有元素赋值给现有容器；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

4.2 assign(size_type num, const T& value)

void container::assign(size_type num, const T& value)
* 将num个value赋值给现有容器（替换现有元素）；
* 可用容器：sets、mulitsets、maps、multimaps；

4.3 assign(InputIterator beg, InputIterator end)

template<class InputIterator>
void container::assign(InputIterator beg, InputIterator end)
* 将num个value赋值给现有容器（替换现有元素）；
* 可用容器：sets、mulitsets、maps、multimaps；

4.4 swap(container& c)

void container::swap(container& c)
* 两个容器互换元素、排序准则；
* 时间复杂度为常数，若替换则使用该方法；
* 关联式容器，比较准则复制/赋值不出异常，则不抛异常；其余不抛异常；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

4.5 swap(container& c1， container& c2)

void container::swap(container& c1， container& c2)
* 相当于c1.swap(c2)；
* 关联式容器，比较准则复制/赋值不出异常，则不抛异常；其余不抛异常；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

五、元素存取

5.1 at(size_type idx)

reference container::at(size_type idx)
const_reference container::at(size_type idx) const
* 二者都返回索引idx所代表的元素；
* 若无效索引，则会导致out_of_range；
* 后续的修改或内存重新分配，可能会导致返回的reference无效；
* 可用容器：vector、deques、strings；

5.2 operator[] (size_type idx)

reference container::operator[] (size_type idx)
const_reference container::operator[] (size_type idx) const
* 二者都返回索引idx所代表的元素；
* 后续的修改或内存重新分配，可能会导致返回的reference无效；
* 可用容器：vector、deques、strings；

5.3 operator[] (size_type idx)

T& map::operator[] (const key_type& key)
* 关联式数组的operator[]；
* 在map中，会返回key所对应的value，若不存在该key，则会自动生成；
* 可用容器：map；

5.4 front()

reference container::front()
const_reference container::front() const
* 都返回第一个元素；
* 若没有元素，则会导致未定义；
* 可用容器：vector、deques、lists；

5.5 back()

reference container::back()
const_reference container::back() const
* 都返回最后一个元素；
* 若没有元素，则会导致未定义；
* 可用容器：vector、deques、lists；

六、迭代器返回

6.1 begin()

iterator container::begin()
const_iterator container::begin() const
* 返回一个迭代器，指向容器起始处；
* 若容器为空，则相当于end()；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

6.2 end()

iterator container::end()
const_iterator container::end() const
* 返回一个迭代器，指向容器尾端；
* 若容器为空，则相当于begin()；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

6.3 rbegin()

iterator container::rbegin()
const_iterator container::rbegin() const
* 返回一个逆向迭代器，返回逆向迭代的第一个元素；
* 若容器为空，则相当于end()；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

6.4 rend()

iterator container::rend()
const_iterator container::rend() const
* 返回一个逆向迭代器，返回逆向迭代的最一个元素的下一个位置；
* 若容器为空，则相当于begin()；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

七、插入和移除

7.1 insert(const T& value)

iterator container::insert(const T& value)
pair<iterator, bool>container::insert(const T& value) const
* 安插一个value副本于关联式容器；
* 若不成功，则影响
* 可用容器：sets、mulitsets、maps、multimaps、strings；

7.2 insert(iterator pos, const T& value)

iterator container::insert(iterator pos, const T& value)
* 在迭代器pos的位置上安插一个value副本；
* 返回新元素的位置；
* vector和deques可能导致iterator和reference无效
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

7.3 insert(iterator pos, size_type num, const T& value)

void container::insert(iterator pos, size_type num, const T& value)
* 在迭代器pos的位置上安插num个value副本；
* vector和deques可能导致iterator和reference无效
* 可用容器：vector、deques、lists、strings；

7.4 insert(InputIterator beg, InputIterator end)

template<class InputIterator>
void container::insert(InputIterator beg, InputIterator end)
* 将区间[beg, end)内所有元素的副本安插于关联式容器内；
* 可用容器：sets、mulitsets、maps、multimaps、strings；

7.5 insert(iterator pos, InputIterator beg, InputIterator end)

template<class InputIterator>
void container::insert(iterator pos, InputIterator beg, InputIterator end)
* 将区间[beg, end)内所有元素的副本安插于pos的位置；
* vector和deques可能导致iterator和reference无效；
* 可用容器：vector、deques、lists、strings；

7.6 push_front(const T& value)

void container::push_front(const T& value)
* 插入第一个元素；
* deques可能导致iterator无效，而reference有效；
* 函数失败不产生影响；
* 可用容器：deques、lists；

7.7 push_back(const T& value)

void container::push_back(const T& value)
* 插入最后一个元素；
* vector若造成内存重新分配，可能导致iterator和reference无效
* deque造成iterator失效，而reference有效；
* 函数失败不产生影响；
* 可用容器：vector、deques、lists、strings；

7.8 remove(const T& value)

void list::remove(const T& value)
void list::remove_if(UnaryPredicate op)
* remove()会移除所有value， 而remove_if可进行判断；
* 都会调用被移除元素的析构函数；
* 若元素的比较动作没有异常，则不抛出异常；
* 可用容器：lists；

7.9 erase(const T& value)

size_type container::erase(const T& value)
* 从关联式移除所有value，且返回移除个数；
* 调用被移除元素的析构函数；
* 则不抛出异常；
* 可用容器：sets、mulitsets、maps、multimaps；

7.10 erase(iterator pos)

void container::erase(iterator pos)
iterator container::erase(iterator pos)
* 将迭代器pos所指位置上的元素移除；
* 调用被移除元素的析构函数；
* vector和deques可能导致iterator和reference无效；
* 序列式采用第二，关联式采用第一；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

7.11 erase(iterator beg, iterator end)

void container::erase(iterator beg, iterator end)
iterator container::erase(iterator beg, iterator end)
* 移除区间[beg, end)内所有元素；
* 调用被移除元素的析构函数；
* vector和deques可能导致iterator和reference无效；
* 序列式采用第二，关联式采用第一；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

7.12 pop_front()

void container::pop_front()
* 删除第一个元素；
* 若容器为空，则会导致未定义；
* 此函数不抛出异常；
* 可用容器：deques、lists；

7.13 pop_back()

void container::pop_front()
* 删除最后一个元素；
* 若容器为空，则会导致未定义；
* 此函数不抛出异常；
* 可用容器：vecotr、deques、lists；

7.14 resize(size_type num)

void container::resize(size_type num)
void container::resize(size_type num, T value)
* 容器大小改为num；
* 若num<newNum，则元素会被移除；
* vector和deques可能导致iterator和reference无效；
* 此函数不抛出异常；
* 可用容器：vecotr、deques、lists、strings；

7.15 clear()

void container::clear()
* 移除所有元素；
* 容器所有的iterator和reference无效；
* 此函数不抛出异常；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

八、List特有成员

7.15 unique()

void list::unique()
void list::unique(BinaryPredicate op)
* 移除相邻的重复元素；

7.15 splice(iterator pos, list& source)

void list::splice(iterator pos, list& source)
* 将source的所有元素都移动到*this的pos的位置，且source清空；
* 若两者相同，则导致未定义行为；
* 本函数不抛出异常；

7.15 splice(iterator pos, list& source, iterator sourcePos)

void list::splice(iterator pos, list& source, iterator sourcePos)
* 将source的sourcePos的元素移动到*this的pos的位置；
* 若两者相同，则将在list内部被移动；
* 本函数不抛出异常；

7.15 splice(iterator pos, list& source, iterator sourceBeg, iterator sourceEnd)

void list::splice(iterator pos, list& source, iterator sourceBeg, iterator sourceEnd)
* 将source list中，将位于[Beg,End)的元素移动到*this，source中元素会被移除；
* 若两者相同，则将在list内部被移动；
* 本函数不抛出异常；

7.15 sort()

void list::sort()
void list::sort(CompFunc op)
* 对lists内的所有元素进行排序；

7.15 merge()

void list::merge(list& source)
void list::merge(list& source, CompFunc op)
* 将lists source内的所有元素并入*this，后source变为空容器；

7.15 reverse()

void list::reverse()
* 将lists中的元素颠倒次序；
* 本函数不抛出异常；

八、配置器

8.1 allocator_type

container::allocator_type
* 配置器型别；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

8.2 get_allocator()

allocator_type container::get_allocator() const
* 返回容器的内存模型；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

8.3 container(const Allocator& alloc)

explicit container::container(const Allocator& alloc) 
* 产生一个新的空白容器，使用alloc作为内存模型；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

8.4 container(const CompFunc& op, const Allocator& alloc)

container::container(const CompFunc& op, const Allocator& alloc)  
* 产生一个新的空白容器，使用alloc作为内存模型，并以op为排序准则；
* 可用容器：sets、mulitsets、maps、multimaps；

8.5 container(size_type num, const T& value, const Allocator& alloc)

container::container(size_type num, const T& value, const Allocator& alloc)  
* 产生一个有num个元素的容器，使用alloc作为内存模型，生成的元素都是value的副本；
* 可用容器：vector、deques、lists、strings；

8.6 container(InputIterator beg, InputIterator end, const Allocator& alloc)

container::container(InputIterator beg, InputIterator end, const Allocator& alloc)  
* 产生一个容器，以区间[beg, end)内的所有元素为初值，并使用alloc作为内存模型；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

8.7 container(const CompFunc& op, const Allocator& alloc)

container::container(InputIterator beg, InputIterator end, const Allocator& alloc)  
* 产生一个容器，以区间[beg, end)内的所有元素为初值，并使用alloc作为内存模型；
* 可用容器：vector、deques、lists、sets、mulitsets、maps、multimaps、strings；

8.8 container(InputIterator beg, InputIterator end, const CompFunc& op, const Allocator& alloc)

container::container(InputIterator beg, InputIterator end, const Allocator& alloc)  
* 产生一个以op为排序准则的容器，以区间[beg, end)内的所有元素为初值，并使用alloc作为内存模型；
* 可用容器：sets、mulitsets、maps、multimaps；