STL—容器知识总结

一、所有容器架构关系图

二、容器详解

（一）vector

1、特点：

 （1）存储方式：动态、连续线性空间。

 （2）支持随机访问，每个元素所需要的时间为常量。
 （3）在末尾增加或删除元素所需要时间与元素数目无关，在中间或开头增加或删除元素效率很低，所需时间随元素数目呈线性变化。

（4）只能在vector 的尾部进行push 和pop ，不能在vector 的头进行push 和pop 。

（5）可动态增加或减少元素，内存管理自动完成。当把超过capacity()-size()个元素的插 入vector中时，内存会重新分配，但容量扩张必须经历“重新配置、元素移动、释放空间”等过程，程序员可以使用reserve()成员函数来管理内存。
    注意：对vector的任何操作，一旦引起空间的重新配置，指向原vector的所有迭代器就都失效了。但用reserve()成员函数预先分配需要的内存空间，既可以保护迭代器使之不会失效，又可以提高运行效率。

2、vector成员函数

函数

表述

c.assign(beg,end)

c.assign(n,elem)

将[beg; end)区间中的数据赋值给c。

将n个elem的拷贝赋值给c。

c.at(idx)

传回索引idx所指的数据，如果idx越界，抛出out_of_range。

c.back()

传回最后一个数据，不检查这个数据是否存在。

c.begin()

传回迭代器重的可一个数据。

c.capacity()

返回容器中数据个数。

c.clear()

移除容器中所有数据。

c.empty()

判断容器是否为空。

c.end()

指向迭代器中的最后一个数据地址。

c.erase(pos)

c.erase(beg,end)

删除pos位置的数据，传回下一个数据的位置。

删除[beg,end)区间的数据，传回下一个数据的位置。

c.front()

传回第一个数据。

get_allocator

使用构造函数返回一个拷贝。

c.insert(pos,elem)

c.insert(pos,n,elem)

c.insert(pos,beg,end)

在pos位置插入一个elem拷贝，传回新数据位置。

在pos位置插入n个elem数据。无返回值。

在pos位置插入在[beg,end)区间的数据。无返回值。

c.max_size()

返回容器中最大数据的数量。

c.pop_back()

删除最后一个数据。

c.push_back(elem)

在尾部加入一个数据。

c.rbegin()

传回一个逆向队列的第一个数据。

c.rend()

传回一个逆向队列的最后一个数据的下一个位置。

c.resize(num)

重新指定队列的长度。

c.reserve()

保留适当的容量。

c.size()

返回容器中实际数据的个数。

c1.swap(c2)

swap(c1,c2)

将c1和c2元素互换。

同上操作。

vector<Elem> c

vector <Elem> c1(c2)

vector <Elem> c(n)

vector <Elem> c(n, elem)

vector <Elem> c(beg,end)

c.~ vector <Elem>()

创建一个空的vector。

复制一个vector。

创建一个vector，含有n个数据，数据均已缺省构造产生。

创建一个含有n个elem拷贝的vector。

创建一个以[beg;end)区间的vector。

销毁所有数据，释放内存。

（二）list

1、特点

（1）不保证连续存储，每次插入删除操作，就分配或释放一个元素空间。

（2）SGI list是一个环状双向链表，

（3）对任何元素的插入和删除都是常数时间

（4）不支持随机访问，相对vector占用更多的内存

2、list成员函数

List<Elem> c

List<Elem> c1(c2)

List<Elem> c(n)

List <Elem> c(n,elem)

List<Elem> c(beg;end)

c.~list<Elem> ()

产生一个空的list

产生一个与c2同型的list（每个元素都被复制）

产生拥有n个元素的list，这些元素都以default方式构造初始化

产生拥有n个元素的list，每个元素都是elem的副本

产生一个list并以[beg;end]取件内的元素为初值

销毁所有元素，释放空间

c.size()

c.empty()

c.max_size()

c1==c2

c1!=c2

c1<c2

c1>c2

c1<=c2

c1>=c2

传回元素的个数

判断容器大小是否为零。等同于size()==0,但可能更快

传回元素的最大可能数量

判断是否c1等于c2

判断是否c1不等于c2. 等同于C2==C1

判断是否c1小于c2

判断是否c1大于c2。等同于C2<C1

判断是否小于c1等于c2。等同于!(C2<C1)

判断是否大于c1等于c2. 等同于!(C2<C1)

c1=c2

c.assign(n,elem)

c.assign(beg,end)

c.swap(c2)

swap(c1,c2)

将c2的全部元素都指派给c1

将elem的n个拷贝指派给c

减区间[beg;end]的元素指派给c

将c1和c2的元素互换

同上，刺猬权与函式

c.front()

c.back()

传回第一个元素，不检查元素存在与否

传回最后一个元素。不检查元素存在与否

c.begin()

c.end()

c.rbegin()

c.rend()

传回一个双向迭代器，指向迭代器的最后元素的下一位

传回一个双向迭代器，指向迭代器的最后元素的下一位

传回一个逆向迭代器，指向迭代器的第一个元素

传回一个逆向迭代器，指向迭代器的最后元素的下一位

c.insert(pos,elem)

c.insert(pos,n,elem)

c.insert(pos,beg,end)

c.push_back(elem)

c.pop_back()

c.push_front(elem)

c.pop_front()

c.remove(val)

c.remove_if(op)

c.erase(pos)

c.erase(beg,end)

c.resize(num)

c.resize(num,elem)

c.clear()

在迭代器pos所值位置上安插一个elem副本，并返回新元素的位置

在迭代器pos所值位置上安插n个elem副本，无返回值

在迭代器pos所值位置上安插[beg;end]区间内所有的副本，无返回值

在尾部追加一个elem副本

一出最后一个元素（但不传回）

在头部插入一个elem副本

移除第一个元素（但不传回）

移除所有值为val的元素

移除所有造成op(elem)结果为true的元素

移除迭代器pos所指元素，传回下一元素的位置

益处取件[beg;end]内的所有元素，传回下一元素位置

将容器容量变为num。如果size()变大，则以default构建初始化所有新增元素

将容器容量变为num。如果size()变大，则以elem副本作为新增元素初值

移除全部元素，将整个容器清空

（三）deque

1、特点

（1）双向开口的连续线性空间，可在头为两端分别做元素的插入和删除操作

（2）与vector的区别：一是deque允许于常数时间内对其头端进行元素的插入和删除操作；二是deque没有容量的观念（capacity（）和reserve（）），它是动态的以分段连续空间组合而成，随时可以增加一段新的空间，并链接起来。

（3）支持随机存储，但是性能没有vector好，可在内部进行插入删除，但性能不及list

2、deque成员函数

deque<Elem> c

Deque<Elem> c1(c2)

Deque<Elem> c(n)

Deque<Elem> c(n,elem)

Deque<Elem> c(beg,end)

c.~deque<Elem> ()

产生一个空的deque

针对某个deque产生一个同型的副本（所有元素都被拷贝）

产生一个deque，含有n个元素，这些元素均调用default构造函数产生

产生一个deque，含有n个元素，这些元素均是elem的副本

产生一个deque，以区间[beg;end]内的元素为初值

销毁所有元素，释放空间

c.size()

c.empty()

c.max_size()

c1==c2

c1!=c2

c1<c2

c1>c2

c1<=c2

c1>=c2

c.at(idx)

c[idx]

c.front()

c.back()

c.begin()

c.end()

c.rbegin()

c.rend()

传回容器的实际元素个数

判断容器大小是否为0.等同于size()==0,但可能更快

传回可容纳的最大元素数量

判断c1是否等于c2

判断c1是否不等于c2。等同于!(c1==c2)

判断c1是否小于c2

判断c1是否大于c2

判断c1是否小于等于c2

判断c1是否大于等于c2

传回索引idx所标示的元素。如果idx越界，抛出out_of_range错误

传回索引idx所标示的元素，不进行范围检查

传回第一个元素，不检查元素是否存在

传回最后一个元素，不检查元素是否存在

传回一个随机迭代器，指向第一个元素

传回一个随机迭代器，指向最后一个元素的下一个位置

传回一个逆向迭代器，指向逆向迭代器的第一个元素

传回一个逆向迭代器，指向逆向迭代器的最后一个元素的下一个位置

c1=c2

c.assign(n,elem)

c.assign(beg,end)

c1.swap(c2)

swap(c1,c2)

c.insert(pos,elem)

c.insert(pos,n,elem)

c.insert(pos,beg,end)

c.push_back(elem)

c.pop_back()

c.push_front(elem)

c.pop_front()

c.erase(pos)

c.erase(beg,end)

c.resize(num)

c.resize(num,elem)

c.clear()

将c2的所有元素指派给c1

将n个elem副本指派给c

将区间[beg;end]中的元素指派给c

将c1和c2的元素交换

同上，此为全域函式

在pos位置插入一个elem副本，并传回新元素的位置

在pos位置插入elem的n个腹板，无返回值

在pos位置插入在区间[beg;end]所有元素的副本，无返回值

在尾部添加elem的一个副本

移除最后一个元素（但不回传）

在头部插入elem的一个副班

移除头部元素（但不回传）

移除pos位置上的元素，传回下一元素位置

移除[beg;end]区间内的所有元素，传回下一元素位置

将大小（元素个数）为改num。若size()增长了，新增元素都以default构建产生出来

将大小（元素个数）改为num。若size()增长了，新增元素都是elemde副本

移除所有元素，将元素清空

（四）slist

1、特点

（1）SGI STL提供的单链表，除了起点位置外，其他位置采用插入和删除操作都属不智之举。

（2）slist不提供push_back(),只提供push_front（），因此slist的元素次序会和元素插入进来的次序相反

（3）slist和list的区别是，前者的迭代器属于单向的Forward iterator，后者的迭代器属于双向的Bidirectional iterator。

2、成员函数

没有push_back（）操作

（五）Stack

1、特点

（1）先进后出，缺省情况下，以deque作为stack的底部，也可以以list为底部结构并封闭其头端开口。

（2）是一种配接器，没有迭代器

（六）queue

1、特点

（1）先进先出，缺省情况下，以deque作为queue的底部，也可以以list为底部结构并封闭其头端开口

（2）是一种配接器，没有迭代器，不允许有遍历行为

（七）heap

1、特点

（1）以完全二叉树的形式来存储元素，扮演priority queue的助手。

（2）可动态改变大小。

（3）没有迭代器，不提供遍历功能。

2、heap算法

Make_heap(beg,end)

构造堆

Push_heap(beg,end)

对插入元素后的vector，进行堆的重构造

Pop_heap(beg,end)

对删除元素后的vector，进行堆的重构造

Sort_heap(beg,end)

对堆进行排序

 

（八）priority queue

1、特点

（1）缺省情况下，有一个max-heap完成

（2）一个配节器，不提供迭代器，没有遍历功能。

（九）set和multiset

1、特点

（1）底层结构是非线性的红黑树

（2）所有元素都会根据元素的键值自动被排序，其实值就是键值，键值就是实值

（3）set iterator 是一种 constant iterator

（4）multiset的特性跟set完全相同，唯一差别就是它允许键值重复，其插入操作采用的是底层机制RB-tree的insert_equal()而非insert_unique().

注意：面对关联容器，应该使用其所提供的find函数来搜寻元素，会比使用STL算法的find（）函数更有效（STL算法find（）函数只是循序搜索）

2、成员函数

Set c

Set c(op)

Set c1(c2)

Set c(beg,end)

Set c(beg,end,op)

c.~set()

产生一个空的set/multiset，其中不含任何元素

以op为排序准则，产生一个空的set/multiset

产生某个set/multiset的副本，所有元素均被复制

以区间[beg;end]内的元素产生一个set/multiset

以op为排序准则，利用[beg;end]内的元素生成一个set/multiset

销毁所有元素，释放空间

Set<elem>

Set<Elem,op>

Multiset<Elem>

Multiset<Elem,op>

一个set，以less<>(operator<)为排序准则

一个set，yiop为排序准则

一个multiset，以less<>(operator<)为排序准则

一个multiset，以op为排序准则

c.size()

c.empty()

c.maxsize()

c1==c2

c1!=c2

c1<c2

c1>c2

c1<=c2

c1>=c2

传回容器的大小

判断容器的大小是否为0，等同于size()==0，但可能更快

传回可容纳的最大元素数量

判断是否c1等于c2

判断是否c1不等于c2，等同于!(c1==c2)

判断是否c1小于c2

判断是否c1大于c2

判断是否c1小于等于c2，等同于!(c2<c1)

判断是否c1大于等于c2，等同于!(c1<c2)

Count(elem)

Find(elem)

Lower_bound(elem)

Upper_bound(elem)

Equal_range(elem)

传回元素值为elem的元素的个数

传回元素值为elem的第一个元素，如果找不到就返回end()

传回elem第一个可以安插的位置，也就是 元素值>=elem 的第一个元素的位置

传回elem最后个可以安插的位置，也就是 元素值>elem 的第一个元素的位置

传回elem第一个和最后一个可以安插的位置，也就是 元素值=elem 的区间

C1=c2

C1.swap(c2)

Swap(c1,c2)

将c2中所有的元素指派给c1

将c1和c2的元素互换

同上

c.begin()

c.end()

c.rbegin()

c.rend()

传回一个双向迭代器(将元素视为常数)，指向第一个元素

传回一个双向迭代器(将元素市委常数)，指向最后一个元素的下一个位置

传回一个逆向迭代器，指向逆向访问时的第一个元素

传回一个逆向迭代器，指向逆向访问时的最后一个元素的下一个位置

c.insert(elem)

c.insert(pos,elem)

c.insert(beg,end)

c.erase(elem)

c.erase(pos)

c.erase(beg,end)

c.clear()

插入一个elem，传回新元素的位置(不论成功与否，对sets而言)

插入一个elem，传回新元素的位置(pos是个提示，指出安插动作的搜寻起点，提示恰当，可大提高速度)

将区间[beg;end]内的所有元素的副本安插到c中

移除与elem相等的所有元素，传回被移除元素的个数

移除迭代器pos所值位置上的元素，无返回值

移除区间[beg;end]内的所有元素，无返回值

移除全部元素，将整个容器清空

（十）map和multimap

1、特点

（1）底层结构是非线性的红黑树

（2）所有元素都是pair，同时拥有实值(value)和键值(key)

（3）可以通过map迭代器修真元素的实值，但是不能修正其键值，因为map元素的键值关系到map元素的排列因此map的iterator既不是constant iterator，也不是mutable iterator。

（4）multimap的特性跟map完全相同，唯一差别就是它允许键值重复，其插入操作采用的是底层机制RB-tree的insert_equal()而非insert_unique().

2、成员函数

Map c

Map c(op)

Map c1(c2)

Map c(beg,end)

Map c(beg,end,op)

c.~map()

产生一个空的map/multimap,其中不含任何元素

以op为排序准则，产生一个空的map/multimap

产生某个map/multimap的副本，所有元素均被复制

以区间[beg;end]内的元素产生一个map/multimap

以op为排序准则，利用[beg;end]内的元素生成一个map/mutimap.

销毁所有的元素，释放空间

Map<key,elem>

Map<key,elem,op>

Multimap<key,elem>

Multimap<key,elem,op>

一个map，以less<>(operator<)为排序准则

一个map，以op为排序准则

一个multimap，以less<>(operator<)为排序准则

一个multimap，以op为排序准则

c.size()

c.empty()

c.max_size()

c1==c2

c1!=c2

c1<c2

c1>c2

c1<=c2

c1>=c2

传回容器的大小

判断容器的大小是否为0。等同于size()==0，但可能更快

传回可容纳的最大元素数量

判断是否c1等于c2

判断是否c1不等于c2

判断是否c1小于c2

判断是否c1=大于c2

判断是否c1小于等于c2

判断是否c1大于等于c2

Count(key)

Find(key)

Lower_bound(key)

Upper_bound(key)

Equal_range(key)

传回键值等于key的元素的个数

传回键值等于key的第一个元素，找不到就返回end

传回键值为key质元素的第一个可按插位置，也就是键值>=key的第一个元素的位置

传回键值为key之元素的最后一个可安插位置，也就是键值>key的第一个袁术的位置

传回键值为key之元素的第一个卡安插位置和最后一个可安插位置，也就是键值==可以的元素的区间

C1=c2

C1.swap(c2)

Swap(c1,c2)

将c2中所有元素指派给c1

将c1和c2的元素互换

同上

c.begin()

c.end()

c.rbegin()

c.rend()

传回一个双向迭代器(key被视为常数)，指向第一个元素

传回一个双向迭代器(key被视常数)，指向最后一个元素的下一个位置

传回一个逆向迭代器，指向逆向访问时的第一个元素

传回一个逆向迭代器，指向逆向访问时的最后一个元素的下一个位置

c.insert(elem)

c.insert(pos,elem)

c.insert(beg,end)

c.erase(elem)

c.erase(pos)

c.erase(beg,end)

c.clear()

插入一个elem，传回新元素的位置(不论成功与否，对maps而言)

插入一个elem，传回新元素的位置(pos是个提示，指出安插动作的搜寻起点，提示恰当，可大提高速度)

将区间[beg;end]内的所有元素的副本安插到c中(无返回值)

移除实值与与elem相等的所有元素，传回被移除元素的个数

移除迭代器pos所值位置上的元素，无返回值

移除区间[beg;end]内的所有元素，无返回值

移除全部元素，将整个容器清空

 

参考文献

[1]http://blog.csdn.net/phoebin/article/details/3864590