STL总结（不定期更新...）

点击打开链接

一、容器

1、vector

vector<type> v;

v.begin() //得到数组头的指针
v.end() //得到数组的最后一个单元+1的指针
v.size() //当前使用数据的大小
v.max_size() //得到vector最大可以是多大
v.resize(num)    // 改变当前使用数据的大小，如果它比当前使用的大，否则填充默认值
v.empty() //判断vector是否为空，空返回true，否则返回false
v.reserve() //请求更改容量
v.front() //返回第一个元素
v.back() //返回最后一个元素
v.push_back(type)  //往最后一个元素后面插入一个元素
v.pop_back() //删除最后一个元素
v.insert(pos,elem)  //在pos位置插入一个elem拷贝
v.erase(pos)        //删除pos位置的数据
v.erase(beg,end) //删除[beg,end)区间的数据
v.swap() //与另一个vector交换数据
v.clear() //把vector清空
v.at(pos) //得到编号位置的数据

2、set/multiset

set<type> s;

multiset<type> s;

s.begin() //返回set容器的第一个元素
s.end() //返回set容器的最后一个元素
s.clear() //删除set容器中的所有的元素
s.empty() //判断set容器是否为空
s.max_size() //返回set容器可能包含的元素最大个数
s.size() //返回当前set容器中的元素个数
s.rbegin() //返回的值和end()相同
s.rend() //返回的值和rbegin()相同
s.count() //用来查找set中某个某个键值出现的次数。这个函数在set并不是很实用，因为一个键值在set只可能出现0或1次，这样就变成了判断某一键值是否在set出现过了。
s.equal_range() //返回一对定位器，分别表示第一个大于或等于给定关键值的元素和 第一个大于给定关键值的元素，这个返回值是一个pair类型，如果这一对定位器中哪个返       回失败，就会等于end()的值。
s.erase(iterator)  //删除定位器iterator指向的值
s.erase(first,second) //删除定位器first和second之间的值
s.erase(key_value) //删除键值key_value的值
s.insert(key_value) //将key_value插入到set中 ，返回值是pair<set<int>::iterator,bool>，bool标志着插入是否成功，而iterator代表插入的位置，若key_value已经在set中，则     iterator表示的key_value在set中的位置。
s.insert(first,second) //将定位器first到second之间的元素插入到set中，返回值是void.
s.lower_bound(key_value) //返回第一个大于等于key_value的定位器
s.upper_bound(key_value) //返回最后一个大于等于key_value的定位器
s.find(elem) //返回“元素值为elem”的第一个元素，如果找不到就返回end()
s.key_comp() //返回一个用于元素间值比较的函数

小结：set中的删除操作是不进行任何的错误检查的，比如定位器的是否合法等等，所以用的时候自己一定要注意。

3、map/multimap  点击打开链接

C++中map容器提供一个键值对容器，map与multimap差别仅仅在于multiple允许一个键对应多个值。

map<type1,type2> m;

m.begin() //返回指向map头部的迭代器
m.clear(） //删除所有元素
m.count() //返回指定元素出现的次数
m.empty() //如果map为空则返回true
m.end() //返回指向map末尾的迭代器
m.equal_range() //返回特殊条目的迭代器对
m.erase（iterator it) //通过一个条目对象删除
m.erase（iterator first，iterator last）//删除一个范围
m.find() //查找一个元素，传入的参数是要查找的key，返回一个迭代器
m.get_allocator() //返回map的配置器
m.insert() //插入元素
m.key_comp() //返回比较元素key的函数
m.lower_bound() //返回键值>=给定元素的第一个位置
m.max_size() //返回可以容纳的最大元素个数
m.rbegin() //返回一个指向map尾部的逆向迭代器
m.rend() //返回一个指向map头部的逆向迭代器
m.size() //返回map中元素的个数
m.swap() //交换两个map
m.upper_bound() //返回键值>给定元素的第一个位置
m.value_comp() //返回比较元素value的函数

Map中的元素是自动按key升序排序,所以不能对map用sort函数

4、queue

queue<type> q;

q.empty() //判断栈是否为空
q.size() //返回队列元素的个数
q.back() //返回队尾元素
q.front()//返回队头元素
q.pop()//弹出队头
q.push(type)//入队到队尾
q.swap()//交换两个队列

5、stack

stack<type> s;

s.top() //返回栈顶数据
s.push(type) //在栈顶增加一个元素
s.pop() //弹出栈顶
s.empty() //判断栈是否为空
s.size() //返回栈中元素的个数

6、list 点击打开链接

list<type> l;

Lists将元素按顺序储存在链表中. 与 向量(vectors)相比, 它允许快速的插入和删除，但是随机访问却比较慢.

l.assign() //给list赋值 
l.back() //返回最后一个元素 
l.begin() //返回指向第一个元素的迭代器 
l.clear() //删除所有元素 
l.empty() //如果list是空的则返回true 
l.end() //返回末尾的迭代器 
l.erase() //删除一个元素 
l.front() //返回第一个元素 
l.get_allocator() //返回list的配置器 
l.insert() //插入一个元素到list中 
l.max_size() //返回list能容纳的最大元素数量 
l.merge() //合并两个list 
l.pop_back() //删除最后一个元素 
l.pop_front() //删除第一个元素 
l.push_back() //在list的末尾添加一个元素 
l.push_front() //在list的头部添加一个元素 
l.rbegin() //返回指向第一个元素的逆向迭代器 
l.remove() //从list删除元素 
l.remove_if() //按指定条件删除元素 
l.rend() //指向list末尾的逆向迭代器 
l.resize() //改变list的大小 
l.reverse() //把list的元素倒转 
l.size() //返回list中的元素个数 
l.sort() //给list排序 
l.splice() //合并两个list 
l.swap() //交换两个list 
l.unique() //删除list中重复的元素

7、string 点击打开链接  点击打开链接

begin //得到指向字符串开头的Iterator
end //得到指向字符串结尾的Iterator
rbegin //得到指向反向字符串开头的Iterator
rend //得到指向反向字符串结尾的Iterator
size //得到字符串的大小
length //和size函数功能相同
max_size //字符串可能的最大大小
capacity //在不重新分配内存的情况下，字符串可能的大小
empty //判断是否为空
operator[] //取第几个元素，相当于数组
c_str //取得C风格的const char* 字符串
data //取得字符串内容地址
operator= //赋值操作符
reserve //预留空间
swap //交换函数
append //追加字符
push_back //追加字符
operator+= //+= 操作符
erase //删除字符串
clear //清空字符容器中所有内容
resize //重新分配空间
copy //字符串到空间
find //查找
rfind //反向查找
find_first_of //查找包含子串中的任何字符，返回第一个位置
find_first_not_of //查找不包含子串中的任何字符，返回第一个位置
find_last_of //查找包含子串中的任何字符，返回最后一个位置
find_last_not_of //查找不包含子串中的任何字符，返回最后一个位置
substr //得到字串
compare //比较字符串
operator+ //字符串链接
operator== //判断是否相等
operator!= //判断是否不等于
operator< //判断是否小于
operator>> //从输入流中读入字符串
operator<< //字符串写入输出流
getline //从输入流中读入一行
isalnum(c)  //如果c是字母或数字，返回 true
isalpha(c)  //如果c是字母，返回true
iscntrl(c)  //c是控制符，返回true
isdigit(c)  //如果c是数组，返回true
isgraph(c)  //如果c不是空格，则可打印，，则为true
islower(c)  //如果c是小写字母，则为true
isupper(c)  //如果c是大写字符，则为true
isprint(c)  //如果c是可打印的字符，则为true
ispunct(c)  //如果c是标点符号，则为true
isspace(c) //如果c是空白字符，则为true
isxdigit(c) //如果c是十六进制数，则为true
tolower(c) //如果c是大写字符，则返回其小写字母，否则直接返回c
toupper(c)  //跟tolower相反
insert( it , p )  //把字符串p插入到it的位置
insert(p,n,t)   //迭代器p元素之前插入n个t的副本
insert(p,b,e)   //迭代器p元素之前插入迭代器b到e之间的所有元素
insert(p,s2,poe2,len)  //在下标p之前插入s2下标从poe2开始长度为len的元素
insert(pos,cp,len)  //下标pos之前插入cp数组的前len个元素。
assign(b,e)  //用迭代器b到e范围内的元素替换s
assign(n,t)  //用n个t的副本替换s
assign(s1,pos2,len) //从s1的下标pos2开始连续替换len个。
replace ( 3 , 3 , " good " )    //从第三个起连续三个替换为good
substr(i,j)   //截取s串中从i到j的子串
erase( 3 ) //删除第四个元素
erase ( 0 , 4 )  //第一到第五个元素
find ( " cat " )  //超找第一个出现的字符串”cat“，返回其下标值，查不到返回 4294967295，也可查找字符；
compare ( " good " )  //”good“比较相等返回0，比"good"大返回1，小则返回-1

8、priority queues 点击打开链接

priority_queue<Type, Container, Functional> p;

Type 为数据类型， Container 为保存数据的容器，Functional 为元素比较方式。
Container 必须是用数组实现的容器，比如 vector, deque 但不能用 list.

STL里面默认用的是 vector. 比较方式默认用 operator< , 所以如果你把后面俩个参数缺省的话，优先队列就是大顶堆，队头元素最大。

如果要用到小顶堆，则一般要把模板的三个参数都带进去。
STL里面定义了一个仿函数 greater<>，对于基本类型可以用这个仿函数声明小顶堆priority_queue<int, vector<int>, greater<int> >qi2;

对于自定义类型，则必须自己重载 operator< 或者自己写仿函数。

还有一点要注意的是priority_queue中的三个参数，后两个可以省去，因为有默认参数，不过如果，有第三个参数的话，必定要写第二个参数。

top() //返回队头的数据
push(type) //在队尾增加一个元素
pop() //队列头部数据出队
empty() //判断队列是否为空
size() //返回队列中元素的个数

9、bitset 点击打开链接 

bitset<n> b;            //b有n位，每位都为0  
bitset<n> b(u);             //b是unsigned long型u的一个副本  
bitset<n> b(s);             //b是string对象s中含有的位串的副本  
bitset<n> b(s, pos, n);     //b是s中从位置pos开始的n个位的副本  

在定义bitset时，要明确bitset含有多少位，须在尖括号内给出它的长度值。

以0位开始的位串是低阶位（low-order bit），以31位结束的位串是高阶位(high-order bit)。

当用unsigned long值作为bitset对象的初始值时，该值将转化为二进制的位模式。而bitset对象中的位集作为这种位模式的副本。如果bitset类型长度大于unsigned long值的二进制位数，则其余的高阶位置为0；如果bitet类型长度小于unsigned long值的二进制位数，则只使用unsigned值中的低阶位，超过bitet类型长度的高阶位将被丢弃。

当用string对象初始化bitset对象时，string对象直接表示为位模式。从string对象读入位集的顺序是从右向左，即：string对象的最右边字符（即下标最大的那个字符）用来初始化bitset对象的低阶位（即下标为0的位）。

10、hash_set/hash_map/hash_multiset/hash_multimap 点击打开链接 点击打开链接 //要注意编译器的版本来使用

 /************************************************************************************
 *      hash_set哈希集合容器的基础说明：
 ************************************************************************************
 *
 * hash_set哈希集合容器:使用hashtable数据结构的具有高效数据检索的关联容器
 * 
 * 不提供反向迭代器，只有前向迭代器iterator和const_iterator
 * 不允许插入重复的元素键值
 * Hashed Associative Container  Simple Associative Container   Unique Associative Container
 *
 * 目前还不是C++的标准容器，只是SGI C++ STL的一个扩展容器
 * 使用hash_set必须使用宏语句#include <hash_set>          
 * 
 **************************************************************************************/

/************************************************************************************
 *       hash_map映照容器的基础说明：
 ************************************************************************************
 *
 * hash_map哈希映照容器:使用hash表的数据结构,插入的元素键值不允许重复
 * hash_map的所有元素都是pair:第一元素为键值(key),不能修改;第二元素为实值(value),可被修改
 * 
 * 不提供反向迭代器,只有前向迭代器iterator和const_iterator
 * 可定义出操作符[]
 * 
 * Hashed Associative Container  Pair Associative Container   Unique Associative Container
 *
 * 目前还不是C++的标准容器，只是SGI C++ STL的一个扩展容器
 * 使用hash_map必须使用宏语句#include <hash_map>   
 * 可与map作比较: hash_map检索时使用的键值比较次数少，容器需占用较多的空间，用迭代器遍历出来的元素是非排序的；
 *     map则使用链表的二分法进行检索，空间使用率高，遍历出来的元素是排序的，而且可提供反向迭代器。
 * 
 **************************************************************************************/

二、迭代器

点击打开链接

三、算法  点击打开链接

accumlate // iterator 对标志的序列中的元素之和，加到一个由 init 指定的初始值上。重载的版本不再做加法，而是传进来的二元操作符被应用到元素上。 
adjacent_different //创建一个新序列，该序列的每个新值都代表了当前元素与上一个元素的差。重载版本用指定的二元操作计算相邻元素的差。 
adjacent_find //在 iterator 对标志的元素范围内，查找一对相邻的重复元素，如果找到返回一个 ForwardIterator ，指向这对元素的第一个元素。否则返回 last 。重载版本使用输入的二元操作符代替相等的判断。 
binary_search //在有序序列中查找 value ，如果找到返回 true 。重载的版本使用指定的比较函数对象或者函数指针来判断相等。 
copy //复制序列。 
copy_backward //除了元素以相反的顺序被拷贝外，别的和 copy 相同。 
count //利用等于操作符，把标志范围类的元素与输入的值进行比较，并返回相等元素的个数。 
count_if //对于标志范围类的元素，应用输入的操作符，并返回结果为 true 的次数。 
equal //如果两个序列在范围内的元素都相等，则 equal 返回 true 。重载版本使用输入的操作符代替了默认的等于操作符。 
equal_range //返回一对 iterator ，第一个 iterator 表示由 lower_bound 返回的 iterator ，第二个表示由 upper_bound 返回的iterator 值。 
fill //将输入的值的拷贝赋给范围内的每个元素。 
fill_n //将输入的值赋值给 first 到 frist+n 范围内的元素。 
find //利用底层元素的等于操作符，对范围内的元素与输入的值进行比较。当匹配时，结束搜索，返回该元素的一个 InputIterator 。
find_if //使用输入的函数替代了等于操作符执行了 find 。 
find_end //在范围内查找“由输入的另外一个 iterator 对标志的第二个序列”的最后一次出现。重载版本中使用了用户输入的操作符替代等于操作。 
find_first_of //在范围内查找“由输入的另外一个 iterator 对标志的第二个序列”中的任意一个元素的第一次出现。重载版本中使用了用户自定义的操作符。 
for_each //依次对范围内的所有元素执行输入的函数。 
generate //通过对输入的函数 gen 的连续调用来填充指定的范围。 
generate_n //填充 n 个元素。 
includes //判断 [first1, last1) 的一个元素是否被包含在另外一个序列中。使用底层元素的 <= 操作符，重载版本使用用户输入的函数。 
inner_product //对两个序列做内积 ( 对应的元素相乘，再求和 ) ，并将内积加到一个输入的的初始值上。重载版本使用了用户定义的操作。 
inner_merge //合并两个排过序的连续序列，结果序列覆盖了两端范围，重载版本使用输入的操作进行排序。 
iter_swap //交换两个 ForwardIterator 的值。 
lexicographical_compare //比较两个序列。重载版本使用了用户自定义的比较操作。 
lower_bound //返回一个 iterator ，它指向在范围内的有序序列中可以插入指定值而不破坏容器顺序的第一个位置。重载函数使用了自定义的比较操作。 
max //返回两个元素中的较大的一个，重载版本使用了自定义的比较操作。 
max_element //返回一个 iterator ，指出序列中最大的元素。重载版本使用自定义的比较操作。 
min //两个元素中的较小者。重载版本使用自定义的比较操作。 
min_element //类似与 max_element ，不过返回最小的元素。 
merge //合并两个有序序列，并存放到另外一个序列中。重载版本使用自定义的比较。 
mismatch //并行的比较两个序列，指出第一个不匹配的位置，它返回一对 iterator ，标志第一个不匹配的元素位置。如果都匹配，返回每个容器的 last 。重载版本使用自定义的比较操作。 
next_permutation //取出当前范围内的排列，并将其重新排序为下一个排列。重载版本使用自定义的比较操作。 
nth_element //将范围内的序列重新排序，使所有小于第 n 个元素的元素都出现在它前面，而大于它的都出现在后面，重载版本使用了自定义的比较操作。 
partial_sort //对整个序列做部分排序，被排序元素的个数正好可以被放到范围内。重载版本使用自定义的比较操作。 
partial_sort_copy //与 partial_sort 相同，除了将经过排序的序列复制到另外一个容器。 
partial_sum //创建一个新的元素序列，其中每个元素的值代表了范围内该位置之前所有元素之和。重载版本使用了自定义操作替代加法。 
partition //对范围内元素重新排序，使用输入的函数，把计算结果为 true 的元素都放在结果为 false 的元素之前。 
prev_permutation //取出范围内的序列并将它重新排序为上一个序列。如果不存在上一个序列则返回 false 。重载版本使用自定义的比较操作。 
random_shuffle //对范围内的元素随机调整次序。重载版本输入一个随机数产生操作。 
remove //删除在范围内的所有等于指定的元素，注意，该函数并不真正删除元素。内置数组不适合使用 remove 和 remove_if 函数。 
remove_copy //将所有不匹配的元素都复制到一个指定容器，返回的 OutputIterator 指向被拷贝的末元素的下一个位置。 
remove_if //删除所有范围内输入操作结果为 true 的元素。 
remove_copy_if //将所有不匹配的元素拷贝到一个指定容器。 
replace //将范围内的所有等于 old_value 的元素都用 new_value 替代。 
replace_copy //与 replace 类似，不过将结果写入另外一个容器。 
replace_if //将范围内的所有操作结果为 true 的元素用新值替代。 
replace_copy_if //类似与 replace_if ，不过将结果写入另外一个容器。 
reverse //将范围内元素重新按反序排列。 
reverse_copy //类似与 reverse ，不过将结果写入另外一个容器。 
rotate //将范围内的元素移到容器末尾，由 middle 指向的元素成为容器第一个元素。 
rotate_copy //类似与 rotate ，不过将结果写入另外一个容器。 
search //给出了两个范围，返回一个 iterator ，指向在范围内第一次出现子序列的位置。重载版本使用自定义的比较操作。 
search_n //在范围内查找 value 出现 n 次的子序列。重载版本使用自定义的比较操作。 
set_difference //构造一个排过序的序列，其中的元素出现在第一个序列中，但是不包含在第二个序列中。重载版本使用自定义的比较操作。 
set_intersection //构造一个排过序的序列，其中的元素在两个序列中都存在。重载版本使用自定义的比较操作。 
set_symmetric_difference //构造一个排过序的序列，其中的元素在第一个序列中出现，但是不出现在第二个序列中。重载版本使用自定义的比较操作。 
set_union //构造一个排过序的序列，它包含两个序列中的所有的不重复元素。重载版本使用自定义的比较操作。 
sort //以升序重新排列范围内的元素，重载版本使用了自定义的比较操作。 
stable_partition //与 partition 类似，不过它不保证保留容器中的相对顺序。 
stable_sort //类似与 sort ，不过保留相等元素之间的顺序关系。 
swap //交换存储在两个对象中的值。 
swap_range //将在范围内的元素与另外一个序列的元素值进行交换。 
transform //将输入的操作作用在范围内的每个元素上，并产生一个新的序列。重载版本将操作作用在一对元素上，另外一个元素来自输入的另外一个序列。结果输出到指定的容器。 
unique //清除序列中重复的元素，和 remove 类似，它也不能真正的删除元素。重载版本使用了自定义的操作。 
unique_copy //类似与 unique ，不过它把结果输出到另外一个容器。 
upper_bound //返回一个 iterator ，它指向在范围内的有序序列中插入 value 而不破坏容器顺序的最后一个位置，该位置标志了一个大于 value 的值。重载版本使用了输入的比较操作。 
//堆算法 C++ 标准库提供的是 max-heap 。一共由以下 4 个泛型堆算法。 
make_heap //把范围内的元素生成一个堆。重载版本使用自定义的比较操作。 
pop_heap //并不是真正的把最大元素从堆中弹出，而是重新排序堆。它把 first 和 last-1 交换，然后重新做成一个堆。可以使用容器的 back 来访问被“弹出“的元素或者使用 pop_back 来真正的删除。重载版本使用自定义的比较操作。 
push_heap //假设 first 到 last-1 是一个有效的堆，要被加入堆的元素在位置 last-1 ，重新生成堆。在指向该函数前，必须先把元素插入容器后。重载版本使用指定的比较。 
sort_heap //对范围内的序列重新排序，它假设该序列是个有序的堆。重载版本使用自定义的比较操作。