STL容器和算法的函数表

该篇分为十一部分，分别是：vector类的主要成员、deque类的主要成员、list类的主要成员、
   stack类的主要成员、queue类的主要成员、priority_queue类的组要成员、set类的主要成员、multiset类的主要成员、map类的主要成员、multimap类的主要成员、STL算法函数

（一）vector类的主要成员
vector<T>是可变长的向量,比较灵活
 value_type;//对象类型T，存储在vector中    [定义地方：容器]
 pointer;//指向T的指针                [容器]
 reference;//T的引用                  [容器]
 const_reference;//T的常量引用            [容器]
 size_type;//正整数类型                [容器]
 difference_type;//整数类型              [容器]
 iterator ;//访问vector的迭代器                [容器]
 const_iterator;//访问vector的常量迭代器          [容器]
 reverse_iterator;//访问vector的反向迭代器          [Reversible容器]
 const_reverse_iterator;//访问vector的反向迭代器      [Reversible容器]
 iterator begin();//返回vector的头指针            [容器]
 iterator end();//返回vector的尾指针                [容器]
 const_iterator begin() const;//返回vector的常量头指针      [容器]
 const_iterator end() const;//返回vector的常量尾指针        [容器]
 reverse_iterator rbegin();//返回反向vector的反向头指针      [Reversible容器]
 reverse_iterator rend();//返回反向vector的反向尾指针        [Reversible容器]
 const reverse_iterator rbegin() const;//返回反向vector的反向常量头指针 [Reversible容器]
 const_reverse_iterator rend() const();//返回反向vector的反向常量尾指针 [Reversible容器]
 size_type size() const;//返回vector的元素数量                  [容器]
 size_type max_size() const;// 返回最大可允许的vector元素数量值        [容器]
size_type capacity() const;//返回当前所能容纳的最多元素个数      [vector]
bool empty() const;//判断vector是否为空                  [容器]
reference operator[](size_type n);//返回第n个元素      [Random Access容器]
const_reerence operator[](size_typen)const; //返回第n个元素    [Random Access容器]
vector();//创建一个空vector                            [容器]
vector(size_type n);//创建一个vector，元素数量为n          [Sequence]
vector(size_type n, const T&t);//创建一个vector，元素数量为n，大小都为t[Sequence]
vector(const vector &);//拷贝构造函数                [容器]
template<classInputIterator>vector(InputIterator, InputIterator); [Sequence]
       //采用拷贝的方法创建一个vector，指定了范围
~vector();// vector的析构函数                      [容器]
vector& operator=(constvector&);//=运算符重载            [容器]
void reserve(size_t n);//为vector预先分配n个元素          [vector]
reference front();// 返回第一个元素                  [Sequence]
const_reference front() const;//返回第一个元素            [Sequence]
reference back();//返回最后一个元素              [Back Insertion Sequence]
const_reference back() const;//返回最后一个元素      [Back Insertion Sequence]
void push_back(const T&);//在vector尾部插入一个元素    [Back Insertion Sequence]
void pop_back();//删除最后一个元素              [Back Insertion Sequence]
void swap(vector&);//交换两个vector的内容              [容器]
iterator insert(iterator pos, constT& x);//在pos前出入x        [Sequence]
template<classInputIterator>void insert(iterator pos, InputIteratorf, InputIterator I);
   //在位置pos位置前插入范围为[fisrt, last]的元素            [Sequence]
void insert(iterator pos, size_typen, const T& x);//在位置pos前出入n个x [Sequence]
iterator erase(iterator pos);//删除在位置pos的元素            [Sequence]
iterator erase(iterator first,iterator last);//删除在[first, last]之间的元素      [Sequence]
void clear();//删除所有的元素                            [Sequence]
void resize(size_type n, t = T());//插入或删除使元素个数为n插入的值为t[Sequence]
bool operator==(const vector&,const vector&);//重载==运算符      [Forward容器]
bool operator<(const vector&,const vector&);//小于逻辑运算符    [Forward容器]

vector类的私有成员：
size_type capacity() const;//返回当前所能容纳的最多元素个数，其值不小于size（）
void reserve(size_type n);//如果n小于或等于capacity()，本函数没有作用。否则，它申请分配内存如果申请成功，capacity()值应>=n:如果申请失败，capacity()不变
                
（二）deque类的主要成员
deque<T> 是一种双端队列容器，完成了标准的C++数据结构中队列的所有功能
 value_type;//对象类型T，存储在deque中    [定义地方：容器]
 pointer;//指向T的指针                [容器]
 reference;//T的引用                  [容器]
 const_reference;//T的常量引用            [容器]
 size_type;//正整数类型                [容器]
 difference_type;//整数类型              [容器]
 iterator ;//访问deque的迭代器                [容器]
 const_iterator;//访问deque的常量迭代器          [容器]
 reverse_iterator;//访问deque的反向迭代器          [Reversible容器]
 const_reverse_iterator;//访问deque的反向迭代器      [Reversible容器]
 iterator begin();//返回deque的头指针            [容器]
 iterator end();//返回deque的尾指针                [容器]
 const_iterator begin() const;//返回deque的常量头指针      [容器]
 const_iterator end() const;//返回deque的常量尾指针        [容器]
 reverse_iterator rbegin();//返回反向deque的反向头指针      [Reversible容器]
 reverse_iterator rend();//返回反向deque的反向尾指针        [Reversible容器]
 size_type size() const;//返回deque的元素数量                  [容器]
 size_type max_size() const;// 返回最大可允许的deque元素数量值        [容器]
bool empty() const;//判断deque是否为空                  [容器]
reference operator[](size_type n);//返回第n个元素      [Random Access容器]
const_reerence operator[](size_typen)const; //返回第n个元素[Random Access容器]
deque();//创建一个空deque                            [容器]
deque(size_type n);//创建一个deque，元素数量为n          [Sequence]
deque(size_type n, const T&t);//创建一个deque，元素数量为n，大小都为t[Sequence]
deque(const deque &);//拷贝构造函数                [容器]
template<classInputIterator>deque(InputIterator, InputIterator); [Sequence]
   //采用拷贝的方法创建一个deque，指定了范围
~deque();// deque的析构函数                      [容器]
deque& operator=(constdeque&);//=运算符重载            [容器]
reference front();// 返回第一个元素                  [Sequence]
const_reference front() const;//返回第一个元素            [Sequence]
reference back();//返回最后一个元素              [Back Insertion Sequence]
const_reference back() const;//返回最后一个元素      [Back Insertion Sequence]
void push_back(const T&);//在deque尾部插入一个元素    [Back Insertion Sequence]
void pop_back();//删除最后一个元素              [Back Insertion Sequence]
void swap(deque&);//交换两个deque的内容              [容器]
iterator insert(iterator pos, constT& x);//在pos前出入x        [Sequence]
template<classInputIterator>void insert(iterator pos, InputIteratorf, InputIterator I);
   //在位置pos位置前插入范围为[fisrt, last]的元素            [Sequence]
void insert(iterator pos, size_typen, const T& x);//在位置pos前出入n个x   [Sequence]
iterator erase(iterator pos);//删除在位置pos的元素                [Sequence]
iterator erase(iterator first,iterator last);//删除在[first, last]之间的元素      [Sequence]
void clear();//删除所有的元素                            [Sequence]
void resize(size_type n, t = T());//插入或删除使元素个数为n插入的值为t [Sequence]
bool operator==(const deque&,const deque&);//重载==运算符      [Forward容器]
 bool operator<(const deque&, constdeque&);//小于逻辑运算符     [Forward容器]

所有的deque成员都在其祖先中定义，deque自身没有定义任何新的变量或函数，除了上面的成员之后还可以查看随机接入容器（randomaccess 容器），前向插入序（Front insertion sequence）和反向插入序列(Back insertion sequence)中定义的新变量。

（三）list类的主要成员
list<T>是一个双向链表容器，完成了标准C++数据结构中链表的所有功能
 value_type;//对象类型T，存储在list中    [定义地方：容器]
 pointer;//指向T的指针                [容器]
 reference;//T的引用                  [容器]
 const_reference;//T的常量引用            [容器]
 size_type;//正整数类型                [容器]
 difference_type;//整数类型              [容器]
 iterator ;//访问list的迭代器                [容器]
 const_iterator;//访问list的常量迭代器          [容器]
 reverse_iterator;//访问list的反向迭代器          [Reversible容器]
 const_reverse_iterator;//访问list的反向迭代器      [Reversible容器]
 iterator begin();//返回list的头指针            [容器]
 iterator end();//返回list的尾指针                [容器]
 const_iterator begin() const;//返回list的常量头指针      [容器]
 const_iterator end() const;//返回list的常量尾指针        [容器]
 reverse_iterator rbegin();//返回反向list的反向头指针      [Reversible容器]
 reverse_iterator rend();//返回反向list的反向尾指针        [Reversible容器]
 size_type size() const;//返回list的元素数量                  [容器]
 size_type max_size() const;// 返回最大可允许的list元素数量值        [容器]
       bool empty() const;//判断list是否为空                  [容器]
       reference operator[](size_type n); //返回第n个元素     [Random Access容器]
       const_reerence operator[](size_type n)const; //返回第n个元素[RandomAccess容器]
       list();//创建一个空list                            [容器]
       list(size_type n);//创建一个list，元素数量为n          [Sequence]
       list(size_type n, const T& t);//创建一个list，元素数量为n，大小都为t [Sequence]
       list(const list &);//拷贝构造函数                [容器]
       template<class InputIterator>list(InputIterator,InputIterator);    [Sequence]
//采用拷贝的方法创建一个list，指定了范围
       ~list();// list的析构函数                      [容器]
       list& operator=(const list&);//=运算符重载            [容器]
       reference front();// 返回第一个元素                [Sequence]
       const_reference front() const;//返回第一个元素        [Sequence]
       reference back();//返回最后一个元素              [Back Insertion Sequence]
       const_reference back() const;//返回最后一个元素      [Back Insertion Sequence]
       void push_back(const T&);//在list尾部插入一个元素    [Back Insertion Sequence]
       void pop_back();//删除最后一个元素              [Back Insertion Sequence]
       void swap(list&);//交换两个list的内容              [容器]
       iterator insert(iterator pos, const T& x);//在pos前出入x        [Sequence]
       template<class InputIterator>void insert(iteratorpos, InputIteratorf, InputIterator I);
     //在位置pos位置前插入范围为[fisrt, last]的元素            [Sequence]
    void insert(iterator pos, size_type n, const T&x);//在位置pos前出入n个x[Sequence]
       iterator erase(iterator pos);//删除在位置pos的元素          [Sequence]
       iterator erase(iterator first, iterator last);//删除在[first, last]之间的元素      [Sequence]
       void clear();//删除所有的元素                            [Sequence]
      void resize(size_type n, t = T());//插入或删除使元素个数为n插入的值为t[Sequence]
       bool operator==(const list&, const list&);//重载==运算符     [Forward容器]
       bool operator<(const list&, const list&);//小于逻辑运算符      [Forward容器]

list类的私有变量：
       void splice(iterator position, list<T,Alloc>&x);//把list对象x和当前的list对象*this链接起来，链接的起始位置由position指定，即在position前插入一个list对象x
       void splice(iterator position, list<T,Alloc>&x,iterator i);//把list对象x和当前的list对象*this链接起来，链接的位置由position指定，即在position前插入一个list对象x，另外，把由迭代器i指定的元素插入到当前链表中。
       void splice(iterator position,list<T,Alloc>&x, iterator f, iterator l);//与上面的差异是，把由从迭代器f指定的起始元素到由迭代器l指定的结尾元素插入当前链表中。
       void remove(const T& val);//从链表中删除所有值为val的元素
       template<class Predicate>void remove_if(Predicatep);//删除链表中判断p为真的元素
       void unique();//删除所有重复的元素以建立一个具有唯一元素值的链表
       template<class Binary Predicate>voidunique(BinaryPredicate p);//根据指定的条件，删除所有重复的元素以建立具有唯一元素值的链表
       void merge(list<T, Alloc>& x);//把当前的链表*this和x合并，合并后x为空，把x中的元素插入到了当前链表中，不允许两个链表相同
       template<class BinaryPredicate> voidmerge(list<T, Alloc>& x, BinaryPredicate Comp);//根据给顶的条件把当前链表*this和x合并，合并后x为空，把x中的元素插入到了当前链表中，不允许两个链表相同
       void reverse();//反转链表中的元素顺序
       void sort();//根据默认的条件对链表进行排序
       template<class BinaryPredicate> voidsort(BinaryPredicate comp);//根据给定条件进行排序

（四）stack类的主要成员
stack <T>是一种栈容器，完成了标准C++数据结构中栈的所有功能。
       stack();//默认的构造函数，生成一个空的堆栈
       stack(const stack&);//拷贝构造函数
       stack& operator=(const stack &);//赋值运算符重载

stack 的私有成员：
       value_type;//stack中存放的对象类型，它和stack中的T类型相同
       size_type;//正整数类型，它和Sequence::size_type类型一样
       bool empty()const;//判断堆栈是否为空，如果空返回true，否则返回false。
       size_type size() const;//返回堆栈中的元素个数
       value_type& top();//返回堆栈顶部的引用，这是一个可变化的值。堆栈非空情况下调用。
       const value_type& top() const;//返回堆栈顶部的参考值。
       void push(const value_type& x);//把元素x插入到堆栈的顶部，这时堆栈的长度加1。
       void pop();//删除堆栈顶部的值，前提是堆栈非空，删除操作成功后，堆栈长度减1。
       bool operator==(const stack&, const stack&);//比较两个堆栈是否相等
       bool operator<(const stack&, const stack&);//比较两个堆栈是否第一个堆栈小于第二个。

（五）queue类的主要成员
queue<T>是一种队列容器，完成了标准C++数据结构中队列的所有功能。
       queue();//默认的构造函数，生成一个空的堆栈
       queue(const queue &);//拷贝构造函数
       queue & operator=(const queue&);//赋值运算符重载

queue 的私有成员：
       value_type;//queue中存放的对象类型，它和queue中的T类型相同
       size_type;//正整数类型，他和Sequence::size_type类型一样
       bool empty() const;//判断队列是否为空，空则返回true，否则返回false
       size_type size() const;//返回队列中的元素个数
       value_type& back();//返回队列中最后一个的值
       const value_type& back() const;//返回队列中最后一个值，该值不可变
       value_type& front();//返回第一个值的引用，本函数的前提是队列非空
       const value_type& front() const;//返回队列中的第一个值，改值不可变
       void push(const value_type& x);//把元素x插入到队列的尾部，队列长度加1
       void pop();//删除队列的第一个值，前提条件是队列非空，删除后队列长度减1
       bool operator==(const queue&, const queue&);//比较两个队列是否相等
       bool operator<(const queue&, const queue&);//比较两个队列是否第一个队列小于第二个。

（六）priority_queue的主要成员
priority_queue<T>是一种按值排序的队列容器
priority_queue();//默认构造函数，生成一个空的排序队列
priority_queue(const queue&);//拷贝构造函数
priority_queue& operator=(constpriority_queue &);//赋值运算符重载

priority_queue 的私有成员：
value_type;//priority_queue中存放的对象类型，它和priority_queue中的T类型相同
priority_queue(const Compare&comp);//构造生成一个空的priority_queue对象，使用comp作为priority_queue的comparison
priority_queue(const value_type*first, const value_type* last);//带有两个参数的构造函数，使用默认的Comparison作为第三个参数
size_type;//正整数类型，和Sequence::size_type类型一样。
bool empty() const;//判断优先级队列是否为空，为空返回true，否则返回false
size_type size() const;//返回优先级队列中的元素个数
const value_type& top()const();//返回优先级队列中第一个元素的参考值。
void push(const value_type&x);//把元素x插入到优先级队列的尾部，队列的长度加1
void pop();//删除优先级队列的第一个值，前提是队列非空，删除后队列长度减1

（七）set类的主要成员
set<T>是一种集合容器。
iterator begin(); //指向set的头指针
const_iterator begin() const;//返回set的常量头指针
void clear();//删除所有元素
size_type count(const key_type&x)const; //返回键为x的元素的个数
bool empty() const; //返回是否为空
iterator end();//指向set的尾指针
const_iterator end() const();//返回set的常量尾指针
void erase(iterator position);//删除在位置position的元素
size_type erase(const key_type&x);//删除索引为x的元素
void erase(iterator first, iteratorlast);//删除在[first，last]间的元素
pair<iterator,iterator>equal_range(const key_type& x)const;//返回一个迭代器对(指向键不小于x的第一个元素的迭代器，指向键大于x的第一个元素的迭代器)
iterator find(const key_type&x)const;//返回索引为x的元素的指针
allocator_type get_allocator()const;//返回构造函数的一个拷贝
pair<iterator,bool>insert(constvalue_type& x);//返回<指向元素x的迭代器，是否插入成功>
template<class InputIterator>voidinsert(InputIterator first,InputIterator last);//插入值在[first,last]间的一个序列。
interator lower_bound(constkey_type& x)const; //返指向键不小于x的第一个元素的迭代器
size_type max_size()const;//返回该set可以控制的最大长度
reverse_iterator rbegin();//返回反向set的反向头指针
const_reverse_iterator rbegin()const;//返回反向set的反向常量头指针
reverse_iterator rend();//返回反响set的反向尾指针
 void resize(size_type Sz, T C=T());//插入或删除使元素的个数为n，插入的元素为C
const_reverse_iterator rend()const;//返回反向set的反向尾指针
explicit set(const Compare& comp= Compare(), const Allocator = Allocator());
template<classInputIterator>set(InputIterator first, InputIterator last, const      Compare& Comp = Compare(), const Allocator& X =Allocator());//构造函数类型，如
set<int>::allocator_types1_Alloc;
s1_Alloc = s1.get_allocator();
set <int> s2(s1.begin(),s1.end(), less<int>, s1_alloc);

set(const set<Key,Compare,Allocator>& X); 
~set();//析构函数
size_type size() const;//返回set的大小
void swap(set& X);//与setX交换内容
iterator upper_bound(constkey_type& x)const;//返回指向键大于x的第一个元素的迭代器

（八）multiset的主要函数
multiset <T>是一种允许出现重复元素的集合容器
以下只列函数名（以上面那些基本一样，可根据上面的函数获取更详细信息）
   begin, clear, count, empty, end, equal_range, erase,find ,get_allocator, insert, key_comp,lower_bound, max_size, rbegin, rend,size, swap, upper_bound, value_comp
operator!=, operator==,operator<, operator<=, operator>, operator>=,swap

（九）map的主要函数
map <key, val > 是一种关联数组容器
begin, clear, count, empty, end,equal_range, erase, find, get_alloctor, insert, key_comp, lower_bound,max_size, operator[], rbegin, rend, size,swap,upper_bound, value_comp
operator!=, operator==,operator<, operator<=, operator>, operator>=, swap

（十）multimap的主要函数
multimap <T>是一种允许出现重复key值的关联数组容器
begin, clear, count, empty, end,equal_range, erase, find, get_alloctor, insert, key_comp, lower_bound,max_size, rbegin, rend, size, swap, upper_bound, value_comp

（十一）STL的算法函数
 template<class InIt, class T>Taccumulate(InIt first, InIt last, T val);//元素累加
       template<class InIt, class OutIt>OutItadjacent_difference(InIt first, InIt last,OutIt result); //相邻元素的差额
========================由于量太多，以下只列函数名=========================
       adjacent_find();//搜寻相邻的重复元素
       binary_search();//二元搜寻
       copy();//复制
       copy_backward();//逆向复制
       count();//计数
       count_if();//在特定的条件下计数
       equal();//判断相等与否
       equal_range();//判断相等与否（返回一个上下限区间的范围）
       fill();//改填元素的值
       fill_n();//改填元素的值，n次
       find();//搜寻
       find_if();//在特定的条件下搜寻
       find_end();//搜寻某个子序列的最后一次出现的地点
       find_first_of();//搜寻某些元素的首次出现地点
       for_each();//对范围内的每一个元素施行操作
       generate();//以指定动作的运算结果填充特定范围内的元素
       generate_n();//以指定动作的运算结果填充n个元素的内容
       includes();//包含于
       inner_product();//内积
       inplace_merge();//合并并取代（覆写）
       iter_swap();//元素互换
       lexicographical_compare();//以字典排列方式做比较
       lower_bound();//下限
       max();//最大值
       max_element();//最大值所在位置
       min();//最小值
       min_element();//最小值所在位置
       merge();//合并两个序列
       mismatch();//找出不吻合点
       next_permutation();//获得下一个排列组合
       nth_element();//重新安排序列中第n个元素的左右两端
       parital_soft();//局部排序
       partial_sort_copy();//局部排序并复制到它处
       partial_sum();//局部总和
       partition();//切割
       prev_permutation();//获得前一个排列组合
       random_shuffle();//随机重排
       remove();//移除某种元素（但不删除）
       remove_copy();//移除某种元素并将结果复制到另一个container
       remove_if();//有条件地移除某种元素
       remove_copy_if();//有条件地移除某种元素并将结果复制到另一个container
       replace();//取代某种元素
       replace_copy();//取代某种元素，并将结果复制到另一个container
       replace_copy_if();//有条件地取代，并将结果复制到另一个container
       reverse();//颠倒元素次序
       reverse_copy();//颠倒元素次序并将结果复制到另一个container
       rotate();//旋转
       rotate_copy();//旋转并将结果复制到另一个container
       search();//搜寻某个子序列
       search_n();//搜寻[连续发生n次]的子序列
       set_difference();//差集
       set_intersection();//交集
       set_symmetric_difference();//对称差集
       set_union();//联集
       sort();//排序
       stable_partition();//切割并保持元素相对次序
       stable_sort();//排序并保持等值元素的相对次序
       swap();//置换（对调）
       swap_range();//置换（指定范围）
       transform();//以两个序列为基础，交互作用产生第三个序列
       unique();//将重复的元素折叠缩编，使成唯一
       unique_copy();//将重复的元素折叠缩编，使成唯一，并复制到他处
       upper_bound();//上限
       make_heap();//制造一个heap
       pop_heap();//从heap内取出一个元素
       push_heap();//将一个元素推进heap内
       sort_heap();//对heap排序