STL 超详细介绍!!!

目录

1 STL 简介

2.1 C++ Vector(向量容器)

2.2 C++ List(双向链表)

2.3 C++ Deque(双向队列)

2.4 三者比较

3 关联容器

3.1 特点

3.2 C++ Sets & MultiSets

3.3 C++ Maps & MultiMaps

4 容器适配器

4.1 特点

4.2 C++ Stacks(堆栈)

4.3 C++ Queues(队列)

4.4 C++ Priority Queues(优先队列)

5 迭代器

5.1 解释

5.2 功能特点

6 C++标准库总结

6.1 容器

6.2 算法

6.3 函数对象

6.4 迭代器

6.5 分配器

6.6 数值


1 STL 简介

http://www.cplusplus.com/reference/stl/ 更加详细的资料
C++ STL (Standard Template Library 标准模板库 ) 是通用类模板和算法的集
合,它提供给程序员一些标准的数据结构的实现如 queues( 队列 ), lists( 链表 ),
stacks( ) .
C++ STL 提供给程序员以下三类数据结构的实现:
标准容器类
顺序性容器
vector 从后面快速的插入与删除,直接访问任何元素
deque 从前面或后面快速的插入与删除,直接访问任何元素
list 双链表,从任何地方快速插入与删除
关联容器
set 快速查找,不允许重复值
multiset 快速查找,允许重复值
map 一对多映射,基于关键字快速查找,不允许重复值
multimap 一对多映射,基于关键字快速查找,允许重复值
容器适配器
stack 后进先出
queue 先进先出
priority_queue 最高优先级元素总是第一个出列
程序员使用复杂数据结构的最困难的部分已经由 STL 完成 . 如果程序员想使用包
int 数据的 stack, 他只要写出如下的代码 :
stack myStack;
接下来 , 他只要简单的调用 push() pop() 函数来操作栈 . 借助 C++ 模板的
威力 , 他可以指定任何的数据类型,不仅仅是 int 类型 . STL stack 实现了栈的功
能,而不管容纳的是什么数据类型 .
2 顺序性容器

2.1 C++ Vector(向量容器)

是一个线性顺序结构。相当于数组,但其大小可以不预先指定,并且自动扩
展。它可以像数组一样被操作,由于它的特性我们完全可以将 vector 看作动态数
组。
在创建一个 vector 后,它会自动在内存中分配一块连续的内存空间进行数据 3
存储,初始的空间大小可以预先指定也可以由 vector 默认指定,这个大小即
capacity ()函数的返回值。当存储的数据超过分配的空间时 vector 会重新分配
一块内存块,但这样的分配是很耗时的,在重新分配空间时它会做这样的动作:
首先, vector 会申请一块更大的内存块;
然后,将原来的数据拷贝到新的内存块中;
其次,销毁掉原内存块中的对象(调用对象的析构函数);
最后,将原来的内存空间释放掉。
如果 vector 保存的数据量很大时,这样的操作一定会导致糟糕的性能(这也
vector 被设计成比较容易拷贝的值类型的原因)。所以说 vector 不是在什么情
况下性能都好,只有在预先知道它大小的情况下 vector 的性能才是最优的。
vector 的特点:
(1) 指定一块如同数组一样的连续存储,但空间可以动态扩展。即它可以像数组
一样操作,并且可以进行动态操作。通常体现在 push_back() pop_back()
(2) 随机访问方便,它像数组一样被访问,即支持 [ ] 操作符和 vector.at()
(3) 节省空间,因为它是连续存储,在存储数据的区域都是没有被浪费的,但是
要明确一点 vector 大多情况下并不是满存的,在未存储的区域实际是浪费的。
(4) 在内部进行插入、删除操作效率非常低,这样的操作基本上是被禁止的。
Vector 被设计成只能在后端进行追加和删除操作,其原因是 vector 内部的实现
是按照顺序表的原理。
(5) 只能在 vector 的最后进行 push pop ,不能在 vector 的头进行 push pop
(6) 当动态添加的数据超过 vector 默认分配的大小时要进行内存的重新分配、拷
贝与释放,这个操作非常消耗性能。 所以要 vector 达到最优的性能,最好在创
vector 时就指定其空间大小。
Vectors 包含着一系列连续存储的元素 , 其行为和数组类似。访问 Vector 中的
任意元素或从末尾添加元素都可以在常量级时间复杂度内完成,而查找特定值的
元素所处的位置或是在 Vector 中插入元素则是线性时间复杂度。
1.Constructors 构造函数
vector v1; // 构造一个空的 vector
vector v1( 5, 42 ); // 构造了一个包含 5 个值为 42 的元素的 Vector
2.Operators vector 进行赋值或比较
C++ Vectors 能够使用标准运算符 : ==, !=, <=, >=, <, >.
要访问 vector 中的某特定位置的元素可以使用 [] 操作符 .
两个 vectors 被认为是相等的 , 如果 :
1. 它们具有相同的容量
2. 所有相同位置的元素相等 .
vectors 之间大小的比较是按照词典规则 .
3.assign() Vector 中的元素赋值
语法:
void assign( input_iterator start, input_iterator end );
// 将区间 [start, end) 的元素赋到当前 vector
void assign( size_type num, const TYPE &val );
// num 个值为 val 的元素到 vector , 这个函数将会清除掉为 vector 赋值以前的内容 . 4
4.at() 返回指定位置的元素
语法:
TYPE at( size_type loc );// 差不多等同 v[i]; 但比 v[i] 安全 ;
5.back() 返回最末一个元素
6.begin() 返回第一个元素的迭代器
7.capacity() 返回 vector 所能容纳的元素数量 ( 在不重新分配内存的情况下)
8.clear() 清空所有元素
9.empty() 判断 Vector 是否为空(返回 true 时为空)
10.end() 返回最末元素的迭代器 ( 译注 : 实指向最末元素的下一个位置 )
11.erase() 删除指定元素
语法:
iterator erase( iterator loc );// 删除 loc 处的元素
iterator erase( iterator start, iterator end );// 删除 start end 之间的元素
12.front() 返回第一个元素的引用
13.get_allocator() 返回 vector 的内存分配器
14.insert() 插入元素到 Vector
语法:
iterator insert( iterator loc, const TYPE &val );
// 在指定位置 loc 前插入值为 val 的元素 , 返回指向这个元素的迭代器 ,
void insert( iterator loc, size_type num, const TYPE &val );
// 在指定位置 loc 前插入 num 个值为 val 的元素
void insert( iterator loc, input_iterator start, input_iterator end );
// 在指定位置 loc 前插入区间 [start, end) 的所有元素
15.max_size() 返回 Vector 所能容纳元素的最大数量(上限)
16.pop_back() 移除最后一个元素
17.push_back() Vector 最后添加一个元素
18.rbegin() 返回 Vector 尾部的逆迭代器
19.rend() 返回 Vector 起始的逆迭代器
20.reserve() 设置 Vector 最小的元素容纳数量
// 为当前 vector 预留至少共容纳 size 个元素的空间
21.resize() 改变 Vector 元素数量的大小
语法 :
void resize( size_type size, TYPE val );
// 改变当前 vector 的大小为 size, 且对新创建的元素赋值 val
22.size() 返回 Vector 元素数量的大小
23.swap() 交换两个 Vector
语法:
void swap( vector &from );

2.2 C++ List(双向链表)

是一个线性链表结构,它的数据由若干个节点构成,每一个节点都包括一个
信息块(即实际存储的数据)、一个前驱指针和一个后驱指针。它无需分配指定
的内存大小且可以任意伸缩,这是因为它存储在非连续的内存空间中,并且由指 5
针将有序的元素链接起来。
由于其结构的原因, list 随机检索的性能非常的不好,因为它不像 vector
样直接找到元素的地址,而是要从头一个一个的顺序查找,这样目标元素越靠后,
它的检索时间就越长。检索时间与目标元素的位置成正比。
虽然随机检索的速度不够快,但是它可以迅速地在任何节点进行插入和删除
操作。因为 list 的每个节点保存着它在链表中的位置,插入或删除一个元素仅对
最多三个元素有所影响,不像 vector 会对操作点之后的所有元素的存储地址都有
所影响,这一点是 vector 不可比拟的。
list 的特点:
(1) 不使用连续的内存空间这样可以随意地进行动态操作;
(2) 可以在内部任何位置快速地插入或删除,当然也可以在两端进行 push pop
(3) 不能进行内部的随机访问,即不支持 [ ] 操作符和 vector.at()
Lists 将元素按顺序储存在链表中,与向量 (vectors) 相比,它允许快速的插入
和删除,但是随机访问却比较慢 .
1.assign() list 赋值
语法 :
void assign( input_iterator start, input_iterator end );
// 以迭代器 start end 指示的范围为 list 赋值
void assign( size_type num, const TYPE &val );
// 赋值 num 个以 val 为值的元素。
2.back() 返回最后一个元素的引用
3.begin() 返回指向第一个元素的迭代器
4.clear() 删除所有元素
5.empty() 如果 list 是空的则返回 true
6.end() 返回末尾的迭代器
7.erase() 删除一个元素
语法:
iterator erase( iterator loc );// 删除 loc 处的元素
iterator erase( iterator start, iterator end ); // 删除 start end 之间的元素
8.front() 返回第一个元素的引用
9.get_allocator() 返回 list 的配置器
10.insert() 插入一个元素到 list
语法:
iterator insert( iterator loc, const TYPE &val );
// 在指定位置 loc 前插入值为 val 的元素 , 返回指向这个元素的迭代器 ,
void insert( iterator loc, size_type num, const TYPE &val );
// 定位置 loc 前插入 num 个值为 val 的元素
void insert( iterator loc, input_iterator start, input_iterator end );
// 在指定位置 loc 前插入区间 [start, end) 的所有元素
11.max_size() 返回 list 能容纳的最大元素数量
12.merge() 合并两个 list
语法 : 6
void merge( list &lst );// 把自己和 lst 链表连接在一起
void merge( list &lst, Comp compfunction );
// 指定 compfunction ,则将指定函数作为比较的依据。
13.pop_back() 删除最后一个元素
14.pop_front() 删除第一个元素
15.push_back() list 的末尾添加一个元素
16.push_front() list 的头部添加一个元素
17.rbegin() 返回指向第一个元素的逆向迭代器
18.remove() list 删除元素
语法 :
void remove( const TYPE &val );
// 删除链表中所有值为 val 的元素
19.remove_if() 按指定条件删除元素
20.rend() 指向 list 末尾的逆向迭代器
21.resize() 改变 list 的大小
语法 :
void resize( size_type num, TYPE val );
// list 的大小改变到 num 。被加入的多余的元素都被赋值为 val22.
22.reverse() list 的元素倒转
23.size() 返回 list 中的元素个数
24.sort() list 排序
语法 :
void sort();// 为链表排序,默认是升序
void sort( Comp compfunction );// 采用指定函数 compfunction 来判定两个元素的大小。
25.splice() 合并两个 list
语法 :
void splice( iterator pos, list &lst );// lst 连接到 pos 的位置
void splice( iterator pos, list &lst, iterator del );// 插入 lst del 所指元素到现链表的 pos
void splice( iterator pos, list &lst, iterator start, iterator end );// start end 指定范围。
26.swap() 交换两个 list
语法:
void swap( list &lst );// 交换 lst 和现链表中的元素
27.unique() 删除 list 中重复的元素
语法 :
void unique();// 删除链表中所有重复的元素
void unique( BinPred pr );// 指定 pr ,则使用 pr 来判定是否删除。

2.3 C++ Deque(双向队列)

是一种优化了的、对序列两端元素进行添加和删除操作的基本序列容器。它
允许较为快速地随机访问,但它不像 vector 把所有的对象保存在一块连续的内存
块,而是采用多个连续的存储块,并且在一个映射结构中保存对这些块及其顺序
的跟踪。向 deque 两端添加或删除元素的开销很小。它不需要重新分配空间,所 7
以向末端增加元素比 vector 更有效。
实际上, deque 是对 vector list 优缺点的结合,它是处于两者之间的一种
容器。
deque 的特点:
(1) 随机访问方便,即支持 [ ] 操作符和 vector.at() ,但性能没有 vector 好;
(2) 可以在内部进行插入和删除操作,但性能不及 list
(3) 可以在两端进行 push pop
(4) 相对于 verctor 占用更多的内存。
双向队列和向量很相似,但是它允许在容器头部快速插入和删除(就像在尾部一
样)。
1.Constructors 创建一个新双向队列
语法 :
deque();// 创建一个空双向队列
deque( size_type size );// 创建一个大小为 size 的双向队列
deque( size_type num, const TYPE &val ); // 放置 num val 的拷贝到队列中
deque( const deque &from );// from 创建一个内容一样的双向队列
deque( input_iterator start, input_iterator end );
// start end - 创建一个队列,保存从 start end 的元素。
2.Operators 比较和赋值双向队列
// 可以使用 [] 操作符访问双向队列中单个的元素
3.assign() 设置双向队列的值
语法 :
void assign( input_iterator start, input_iterator end);
//start end 指示的范围为双向队列赋值
void assign( Size num, const TYPE &val );// 设置成 num val
4.at() 返回指定的元素
语法 :
reference at( size_type pos ); 返回一个引用,指向双向队列中位置 pos 上的元素
5.back() 返回最后一个元素
语法 :
reference back();// 返回一个引用,指向双向队列中最后一个元素
6.begin() 返回指向第一个元素的迭代器
语法 :
iterator begin();// 返回一个迭代器,指向双向队列的第一个元素
7.clear() 删除所有元素
8.empty() 返回真如果双向队列为空
9.end() 返回指向尾部的迭代器
10.erase() 删除一个元素
语法 :
iterator erase( iterator pos ); // 删除 pos 位置上的元素
iterator erase( iterator start, iterator end ); // 删除 start end 之间的所有元素
// 返回指向被删除元素的后一个元素
11.front() 返回第一个元素的引用 8
12.get_allocator() 返回双向队列的配置器
13.insert() 插入一个元素到双向队列中
语法 :
iterator insert( iterator pos, size_type num, const TYPE &val ); //pos 前插入 num val
void insert( iterator pos, input_iterator start, input_iterator end );
// 插入从 start end 范围内的元素到 pos 前面
14.max_size() 返回双向队列能容纳的最大元素个数
15.pop_back() 删除尾部的元素
16.pop_front() 删除头部的元素
17.push_back() 在尾部加入一个元素
18.push_front() 在头部加入一个元素
19.rbegin() 返回指向尾部的逆向迭代器
20.rend() 返回指向头部的逆向迭代器
21.resize() 改变双向队列的大小
22.size() 返回双向队列中元素的个数
23.swap() 和另一个双向队列交换元素
语法:
void swap( deque &target );// 交换 target 和现双向队列中元素

2.4 三者比较

vector 是一段连续的内存块,而 deque 是多个连续的内存块, list 是所有
数据元素分开保存,可以是任何两个元素没有连续。
vector 的查询性能最好,并且在末端增加数据也很好,除非它重新申请内存
段;适合高效地随机存储。
list 是一个链表,任何一个元素都可以是不连续的,但它都有两个指向上一
元素和下一元素的指针。所以它对插入、删除元素性能是最好的,而查询性能非
常差;适合大量地插入和删除操作而不关心随机存取的需求。
deque 是介于两者之间,它兼顾了数组和链表的优点,它是分块的链表和多
个数组的联合。所以它有被 list 好的查询性能,有被 vector 好的插入、删除性能。
如果你需要随即存取又关心两端数据的插入和删除,那么 deque 是最佳之选。

3 关联容器

3.1 特点

set, multiset, map, multimap 是一种非线性的树结构,具体的说采用的是一种
比较高效的特殊的平衡检索二叉树—— 红黑树结构。(至于什么是红黑树,我也
不太理解,只能理解到它是一种二叉树结构)
因为关联容器的这四种容器类都使用同一原理,所以他们核心的算法是一致
的,但是它们在应用上又有一些差别,先描述一下它们之间的差别。 9
set 又称集合,实际上就是一组元素的集合,但其中所包含的元素的值是唯
一的,且是按一定顺序排列的,集合中的每个元素被称作集合中的实例。因为其
内部是通过链表的方式来组织,所以在插入的时候比 vector 快,但在查找和末尾
添加上比 vector 慢。
multiset 是多重集合,其实现方式和 set 是相似的,只是它不要求集合中的
元素是唯一的,也就是说集合中的同一个元素可以出现多次。
map 提供一种“键 - 值”关系的一对一的数据存储能力。其“键”在容器中
不可重复,且按一定顺序排列(其实我们可以将 set 也看成是一种键 - 值关系的
存储,只是它只有键没有值。它是 map 的一种特殊形式)。由于其是按链表的方
式存储,它也继承了链表的优缺点。
multimap map 的原理基本相似,它允许“键”在容器中可以不唯一。
关联容器的特点是明显的,相对于顺序容器,有以下几个主要特点:
1 、其内部实现是采用非线性的二叉树结构,具体的说是红黑树的结构原理
实现的;
2 set map 保证了元素的唯一性, mulset mulmap 扩展了这一属性,
可以允许元素不唯一;
3 、元素是有序的集合,默认在插入的时候按升序排列。
基于以上特点,
1 、关联容器对元素的插入和删除操作比 vector 要快,因为 vector 是顺序存
储,而关联容器是链式存储;比 list 要慢,是因为即使它们同是链式结构,但 list
是线性的,而关联容器是二叉树结构,其改变一个元素涉及到其它元素的变动比
list 要多,并且它是排序的,每次插入和删除都需要对元素重新排序;
2 、关联容器对元素的检索操作比 vector 慢,但是比 list 要快很多。 vector
顺序的连续存储,当然是比不上的,但相对链式的 list 要快很多是因为 list 是逐
个搜索,它搜索的时间是跟容器的大小成正比,而关联容器 查找的复杂度基本
Log(N) ,比如如果有 1000 个记录,最多查找 10 次, 1,000,000 个记录,最多
查找 20 次。容器越大,关联容器相对 list 的优越性就越能体现;
3 、在使用上 set 区别于 vector,deque,list 的最大特点就是 set 是内部排序的,
这在查询上虽然逊色于 vector ,但是却大大的强于 list
4 、在使用上 map 的功能是不可取代的,它保存了“键 - 值”关系的数据,
而这种键值关系采用了类数组的方式。数组是用数字类型的下标来索引元素的位
置,而 map 是用字符型关键字来索引元素的位置。在使用上 map 也提供了一种
类数组操作的方式,即它可以通过下标来检索数据,这是其他容器做不到的,当
然也包括 set 。( STL 中只有 vector map 可以通过类数组的方式操作元素,即
如同 ele[1] 方式)

3.2 C++ Sets & MultiSets

集合 (Set) 是一种包含已排序对象的关联容器。多元集合 (MultiSets) 和集合
(Sets) 相像,只不过支持重复对象 , 其用法与 set 基本相同。
1.begin() 返回指向第一个元素的迭代器
2.clear() 清除所有元素
3.count() 返回某个值元素的个数 10
4.empty() 如果集合为空,返回 true
5.end() 返回指向最后一个元素的迭代器
6.equal_range() 返回第一个 >= 关键字的迭代器和 > 关键字的迭代器
语法:
pair equal_range( const key_type &key );
//key 是用于排序的关键字
Set ctr;
例如:
Pair::iterator,set::iterarot>p;
For(i=0;i<=5;i++) ctr.insert(i);
P=ctr.equal_range(2);
那么 *p.first==2;*p.second==3;
7.erase() 删除集合中的元素
语法 :
iterator erase( iterator i ); // 删除 i 位置元素
iterator erase( iterator start, iterator end );
// 删除从 start 开始到 end(end 为第一个不被删除的值 ) 结束的元素
size_type erase( const key_type &key );
// 删除等于 key 值的所有元素(返回被删除的元素的个数)
// 前两个返回第一个不被删除的双向定位器 , 不存在返回末尾
// 第三个返回删除个数
8.find() 返回一个指向被查找到元素的迭代器
语法 :
iterator find( const key_type &key );
// 查找等于 key 值的元素,并返回指向该元素的迭代器 ;
// 如果没有找到 , 返回指向集合最后一个元素的迭代器
9.get_allocator() 返回集合的分配器
10.insert() 在集合中插入元素
语法 :
iterator insert( iterator i, const TYPE &val ); // 在迭代器 i 前插入 val
void insert( input_iterator start, input_iterator end );
// 将迭代器 start 开始到 end end 不被插入)结束返回内的元素插入到集合中
pair insert( const TYPE &val );
// 插入 val 元素,返回指向该元素的迭代器和一个布尔值来说明 val 是否成功被插入
// 应该注意的是在集合 (Sets 中不能插入两个相同的元素 )
11.lower_bound() 返回指向大于(或等于)某值的第一个元素的迭代器
语法 :
iterator lower_bound( const key_type &key );
// 返回一个指向大于或者等于 key 值的第一个元素的迭代器
12.key_comp() 返回一个用于元素间值比较的函数
语法 :
key_compare key_comp();
// 返回一个用于元素间值比较的函数对象
13.max_size() 返回集合能容纳的元素的最大限值 11
14.rbegin() 返回指向集合中最后一个元素的反向迭代器
示例:
Set ctr;
Set::reverse_iterator rcp;
For(rcp=ctr.rbegin();rcp!=ctr.rend();rcp++)
Cout<<*rcp<<” ”;
15.rend() 返回指向集合中第一个元素的反向迭代器
16.size() 集合中元素的数目
17.swap() 交换两个集合变量
语法 :
void swap( set &object ); // 交换当前集合和 object 集合中的元素
18.upper_bound() 返回大于某个值元素的迭代器
语法 :
iterator upwer_bound( const key_type &key );
// 返回一个指向大于 key 值的第一个元素的迭代器
19.value_comp() 返回一个用于比较元素间的值的函数
语法 :
iterator upper_bound( const key_type &key );// 返回一个用于比较元素间的值的函数对象

3.3 C++ Maps & MultiMaps

C++ Maps 是一种关联式容器,包含“关键字 / 值”对。
C++ Multimaps maps 很相似,但是 MultiMaps 允许重复的元素。
1.begin() 返回指向 map 头部的迭代器
2.clear() 删除所有元素
3.count() 返回指定元素出现的次数
语法 :
size_type count( const KEY_TYPE &key );
// 返回 map 中键值等于 key 的元素的个数
4.empty() 如果 map 为空则返回 true
5.end() 返回指向 map 末尾的迭代器
6.equal_range() 返回特殊条目的迭代器对
语法 :
pair equal_range( const KEY_TYPE &key );
返回两个迭代器 , 指向第一个键值为 key 的元素和指向最后一个键值为 key 的元素
7.erase() 删除一个元素
语法 :
void erase( iterator i ); // 删除 i 元素
void erase( iterator start, iterator end ); // 删除从 start 开始到 end (不包括 end )结束的元素
size_type erase( const key_type &key );
// 删除等于 key 值的所有元素(返回被删除的元素的个数)
8.find() 查找一个元素
语法 :
iterator find( const key_type &key ); 12
// 查找等于 key 值的元素,并返回指向该元素的迭代器 ;
// 如果没有找到 , 返回指向集合最后一个元素的迭代器 .
9.get_allocator() 返回 map 的配置器
10.insert() 插入元素
语法 :
iterator insert( iterator pos, const pair &val );
// 插入 val pos 的后面,然后返回一个指向这个元素的迭代器
void insert( input_iterator start, input_iterator end );
// 插入 start end 的元素到 map
pair insert( const pair &val );
// 只有在 val 不存在时插入 val 。返回指向被插入元素的迭代器和描述是否插入的 bool
11.key_comp() 返回比较元素 key 的函数
语法 :
key_compare key_comp();
// 返回一个用于元素间值比较的函数对象
12.lower_bound() 返回键值 >= 给定元素的第一个位置
语法 :
iterator lower_bound( const key_type &key );
// 返回一个指向大于或者等于 key 值的第一个元素的迭代器
13.max_size() 返回可以容纳的最大元素个数
14.rbegin() 返回一个指向 map 尾部的逆向迭代器
15.rend() 返回一个指向 map 头部的逆向迭代器
16.size() 返回 map 中元素的个数
17.swap() 交换两个 map
语法 :
void swap( map &obj );
//swap() 交换 obj 和现 map 中的元素
18.upper_bound() 返回键值 > 给定元素的第一个位置
语法 :
iterator upwer_bound( const key_type &key );
// 返回一个指向大于 key 值的第一个元素的迭代器
19.value_comp() 返回比较元素 value 的函数
语法 :
value_compare value_comp();
// 返回一个用于比较元素 value 的函数

4 容器适配器

4.1 特点

STL 中包含三种适配器:栈 stack 、队列 queue 和优先级 priority_queue
适配器是容器的接口,它本身不能直接保存元素,它保存元素的机制是调用 13
另一种顺序容器去实现,即可以把适配器看作“它保存一个容器,这个容器再保
存所有元素”。
STL 中提供的三种适配器可以由某一种顺序容器去实现。默认下 stack
queue 基于 deque 容器实现, priority_queue 则基于 vector 容器实现。当然在创
建一个适配器时也可以指定具体的实现容器,创建适配器时在第二个参数上指定
具体的顺序容器可以覆盖适配器的默认实现。
由于适配器的特点,一个适配器不是可以由任一个顺序容器都可以实现的。
stack 的特点是后进先出,所以它关联的基本容器可以是任意一种顺序容
器,因为这些容器类型结构都可以提供栈的操作有求,它们都提供了 push_back
pop_back back 操作。
队列 queue 的特点是先进先出,适配器要求其关联的基础容器必须提供
pop_front 操作,因此其不能建立在 vector 容器上。

4.2 C++ Stacks(堆栈)

C++ Stack (堆栈) 是一个容器类的改编,为程序员提供了堆栈的全部功能,—
—也就是说实现了一个先进后出( FILO )的数据结构。
1.empty() 堆栈为空则返回真
2.pop() 移除栈顶元素
3.push() 在栈顶增加元素
4.size() 返回栈中元素数目
5.top() 返回栈顶元素

4.3 C++ Queues(队列)

C++ 队列是一种容器适配器,它给予程序员一种先进先出 (FIFO) 的数据结构。
1.back() 返回一个引用,指向最后一个元素
2.empty() 如果队列空则返回真
3.front() 返回第一个元素
4.pop() 删除第一个元素
5.push() 在末尾加入一个元素
6.size() 返回队列中元素的个数

4.4 C++ Priority Queues(优先队列)

C++ 优先队列类似队列,但是在这个数据结构中的元素按照一定的断言排列有
序。
1.empty() 如果优先队列为空,则返回真
2.pop() 删除第一个元素 14
3.push() 加入一个元素
4.size() 返回优先队列中拥有的元素的个数
5.top() 返回优先队列中有最高优先级的元素

5 迭代器

5.1 解释

迭代器是一种对象,它能够用来遍历 STL 容器中的部分或全部元素,每个迭
代器对象代表容器中的确定的地址。迭代器修改了常规指针的接口,所谓迭代器
是一种概念上的抽象:那些行为上象迭代器的东西都可以叫做迭代器。然而迭代
器有很多不同的能力,它可以把抽象容器和通用算法有机的统一起来。
迭代器提供一些基本操作符: * ++ == 、! = = 。这些操作和 C/C++“ 操作
array 元素 时的指针接口一致。不同之处在于,迭代器是个所谓的 smart pointers
具有遍历复杂数据结构的能力。其下层运行机制取决于其所遍历的数据结构。因
此,每一种容器型别都必须提供自己的迭代器。事实上每一种容器都将其迭代器
以嵌套的方式定义于内部。因此各种迭代器的接口相同,型别却不同。这直接导
出了泛型程序设计的概念:所有操作行为都使用相同接口,虽然它们的型别不同。

5.2 功能特点

迭代器使开发人员不必整个实现类接口。只需提供一个迭代器,即可遍历类
中的数据结构,可被用来访问一个容器类的所包函的全部元素,其行为像一个指
针,但是只可被进行增加 (++) 或减少 (--) 操作。举一个例子,你可用一个迭代器
来实现对 vector 容器中所含元素的遍历。
如下代码对 vector 容器对象生成和使用了迭代器:
vector the_vector;
vector::iterator the_iterator;
for( int i=0; i < 10; i++ )
the_vector.push_back(i);
int total = 0;
the_iterator = the_vector.begin();
while( the_iterator != the_vector.end() ) {
total += *the_iterator;
the_iterator++;
}cout << "Total=" << total << endl;
提示:通过对一个迭代器的解引用操作( * ),可以访问到容器所包含的元素。

6 C++标准库总结

6.1 容器

6.1.1 序列
vector=========================
list===========================
deque==========================
6.1.2 序列适配器
stack:top,push,pop=============
queue:front,back,push,pop======
priority_queue:top,push,pop====
6.1.3 关联容器
map============================
multimap=======================
set============================
multiset=======================
6.1.4 拟容器
string=========================
valarray=======================
bitset=========================

6.2 算法

http://www.cplusplus.com/reference/algorithm/ 详细
6.2.1 非修改性序列操作
for_each()===================== 对序列中每个元素执行操作
find()========================= 在序列中找某个值的第一个出现
find_if()====================== 在序列中找符合某谓词的第一个元素
find_first_of()================ 在序列中找另一序列里的值
adjust_find()================== 找出相邻的一对值
count()======================== 在序列中统计某个值出现的次数
count_if()===================== 在序列中统计与某谓词匹配的次数
mismatch()===================== 找使两序列相异的第一个元素
equal()======================== 如果两个序列对应元素都相同则为真
search()======================= 找出一序列作为子序列的第一个出现位置
find_end()===================== 找出一序列作为子序列的最后一个出现位置
search_n()===================== 找出一序列作为子序列的第 n 个出现位置
6.2.2 修改性的序列操作
transform()==================== 将操作应用于序列中的每个元素
copy()========================= 从序列的第一个元素起进行复制
copy_backward()================ 从序列的最后元素起进行复制
swap()========================= 交换两个元素
iter_swap()==================== 交换由迭代器所指的两个元素
swap_ranges()================== 交换两个序列中的元素
replace()====================== 用一个给定值替换一些元素
replace_if()=================== 替换满足谓词的一些元素
replace_copy()================= 复制序列时用一个给定值替换元素
replace_copy_if()============== 复制序列时替换满足谓词的元素
fill()========================= 用一个给定值取代所有元素
fill_n()======================= 用一个给定值取代前 n 个元素
generate()===================== 用一个操作的结果取代所有元素
generate_n()=================== 用一个操作的结果取代前 n 个元素
remove()======================= 删除具有给定值的元素
remove_if()==================== 删除满足谓词的元素
remove_copy()================== 复制序列时删除给定值的元素
remove_copy_if()=============== 复制序列时删除满足谓词的元素
unique()======================= 删除相邻的重复元素
unique_copy()================== 复制序列时删除相邻的重复元素
reexample()====================== 反转元素的次序
reexample_copy()================= 复制序列时反转元素的次序
rotate()======================= 循环移动元素
rotate_copy()================== 复制序列时循环移动元素
random_shuffle()=============== 采用均匀分布随机移动元素
6.2.3 序列排序
sort()========================= 以很好的平均次序排序
stable_sort()================== 排序且维持相同元素原有的顺序
partial_sort()================= 将序列的前一部分排好序
partial_sort_copy()============ 复制的同时将序列的前一部分排好序
nth_element()================== 将第 n 个元素放到它的正确位置
lower_bound()================== 找到某个值的第一个出现
upper_bound()================== 找到大于某个值的第一个出现
equal_range()================== 找出具有给定值的一个子序列
binary_search()================ 在排好序的序列中确定给定元素是否存在
merge()======================== 归并两个排好序的序列
inplace_merge()================ 归并两个接续的排好序的序列
partition()==================== 将满足某谓词的元素都放到前面
stable_partition()============= 将满足某谓词的元素都放到前面且维持原顺序
6.2.4 集合算法
include()====================== 如果一个序列是另一个的子序列则为真
set_union()==================== 构造一个已排序的并集 17
set_intersection()============= 构造一个已排序的交集
set_difference()=============== 构造一个已排序序列,包含在第一个序列但不在第二
个序列的元素
set_symmetric_difference()===== 构造一个已排序序列,包括所有只在两个序列之一中的
元素
6.2.5 堆操作
make_heap()==================== 将序列高速得能够作为堆使用
push_heap()==================== 向堆中加入一个元素
pop_heap()===================== 从堆中去除元素
sort_heap()==================== 对堆排序
6.2.6 最大和最小
min()========================== 两个值中较小的
max()========================== 两个值中较大的
min_element()================== 序列中的最小元素
max_element()================== 序列中的最大元素
lexicographic_compare()======== 两个序列中按字典序的第一个在前
6.2.7 排列
next_permutation()============= 按字典序的下一个排列
prev_permutation()============= 按字典序的前一个排列
6.2.8 通用数值算法
accumulate()=================== 积累在一个序列中运算的结果 ( 向量的元素求各的
推广 )
inner_product()================ 积累在两个序列中运算的结果 ( 内积 )
partial_sum()================== 通过在序列上的运算产生序列 ( 增量变化 )
adjacent_difference()========== 通过在序列上的运算产生序列 ( partial_sum 相反 )
6.2.9 C 风格算法
qsort()======================== 快速排序,元素不能有用户定义的构造,拷贝赋
值和析构函数
bsearch()====================== 二分法查找,元素不能有用户定义的构造,拷贝
赋值和析构函数

6.3 函数对象

6.3.1 基类
template struct unary_function
template struct binary_function
6.3.2 谓词
返回 bool 的函数对象。 18
equal_to======================= 二元, arg1 == arg2
not_equal_to=================== 二元, arg1 != arg2
greater======================== 二元, arg1 > arg2
less=========================== 二元, arg1 < arg2
greater_equal================== 二元, arg1 >= arg2
less_equal===================== 二元, arg1 <= arg2
logical_and==================== 二元, arg1 && arg2
logical_or===================== 二元, arg1 || arg2
logical_not==================== 一元, !arg
6.3.3 算术函数对象
plus=========================== 二元, arg1 + arg2
minus========================== 二元, arg1 - arg2
multiplies===================== 二元, arg1 * arg2
divides======================== 二元, arg1 / arg2
modulus======================== 二元, arg1 % arg2
negate========================= 一元, -arg
6.3.4 约束器,适配器和否定器
bind2nd(y)
binder2nd================== y 作为第二个参数调用二元函数
bind1st(x)
binder1st================== x 作为第一个参数调用二元函数
mem_fun()
mem_fun_t================== 通过指针调用 0 元成员函数
mem_fun1_t================= 通过指针调用一元成员函数
const_mem_fun_t============ 通过指针调用 0 const 成员函数
const_mem_fun1_t=========== 通过指针调用一元 const 成员函数
mem_fun_ref()
mem_fun_ref_t============== 通过引用调用 0 元成员函数
mem_fun1_ref_t============= 通过引用调用一元成员函数
const_mem_fun_ref_t======== 通过引用调用 0 const 成员函数
const_mem_fun1_ref_t======= 通过引用调用一元 const 成员函数
ptr_fun()
pointer_to_unary_function== 调用一元函数指针
ptr_fun()
pointer_to_binary_function= 调用二元函数指针
not1()
unary_negate=============== 否定一元谓词
not2()
binary_negate============== 否定二元谓词 19

6.4 迭代器

6.4.1 分类
Output: *p= , ++
Input: =*p , -> , ++ , == , !=
Forward: *p= , =*p , -> , ++ , == , !=
Bidirectional: *p= , =*p -> , [] , ++ , -- , == , !=
Random: += , -= , *p= , =*p -> , [] , ++ , -- , + , - , == , != , < , > , <= , >=
6.4.2 插入器
template back_insert_iterator back_inserter(Cont& c);
template front_insert_iterator front_inserter(Cont& c);
template insert_iterator back_inserter(Cont& c, Out p);
6.4.3 反向迭代器
reexample_iterator===============rbegin(), rend()
6.4.4 流迭代器
ostream_iterator=============== 用于向 ostream 写入
istream_iterator=============== 用于向 istream 读出
ostreambuf_iterator============ 用于向流缓冲区写入
istreambuf_iterator============ 用于向流缓冲区读出

6.5 分配器

template class std::allocator

6.6 数值

6.6.1 数值的限制
numeric_limits<>
CHAR_BIT
INT_MAX
...
DBL_MIN_EXP
FLT_RADIX
LDBL_MAX
...
6.6.2 标准数学函数
double abs(double)============= 绝对值 ( 不在 C ) ,同 fabs() 20
double fabs(double)============ 绝对值
double ceil(double d)========== 不小于 d 的最小整数
double floor(double d)========= 不大于 d 的最大整数
double sqrt(double d)==========d 在平方根, d 必须非负
double pow(double d, double e)=d e 次幂
double pow(double d, int i)====d i 次幂
double cos(double)============= 余弦
double sin(double)============= 正弦
double tan(double)============= 正切
double acos(double)============ 反余弦
double asin(double)============ 反正弦
double atan(double)============ 反正切
double atan2(double x,double y) //atan(x/y)
double sinh(double)============ 双曲正弦
double cosh(double)============ 双曲余弦
double tanh(double)============ 双曲正切
double exp(double)============= 指数,以 e 为底
double log(double d)=========== 自动对数 ( e 为底 ),d 必须大于 0
double log10(double d)=========10 底对数, d 必须大于 0
double modf(double d,double*p)= 返回 d 的小数部分,整数部分存入 *p
double frexp(double d, int* p)= 找出 [0.5,1) 中的 x,y, 使 d=x*pow(2,y), 返回 x 并将 y 存入 *p
double fmod(double d,double m)= 浮点数余数,符号与 d 相同
double ldexp(double d, int i)==d*pow(2,i)
int abs(int)=================== 绝对值
long abs(long)================= 绝对值 ( 不在 C )
long labs(long)================ 绝对值
struct div_t { implementation_defined quot, rem; }
struct ldiv_t { implementation_defined quot, rem; }
div_t div(int n, int d)======== d n ,返回 ( 商,余数 )
ldiv_t div(long n, long d)===== d n ,返回 ( 商,余数 )( 不在 C )
ldiv_t ldiv(long n, long d)==== d n ,返回 ( 商,余数 )
6.6.3 向量算术
valarray
6.6.4 复数算术
template class std::complex;
6.6.5 通用数值算法
6.2.8

你可能感兴趣的:(数据结构,算法,c++)