2020+C++STL系统总结
文章目录
- 1.STL六大组件简介
- 2.容器简介
- 3.算法
- 4.迭代器
- 5.常用容器
- (1)string容器
- (2)vector容器
- (3)deque容器
- (4)stack容器
- (5)queue容器
- (6)list容器
- (7)set/multiset容器
- (8)map/multimap容器
- 6.STL容器元素深/浅拷贝问题
- (1)STL容器使用时机
- 7.常用的算法
- (1)函数对象概念
- (2)谓词概念
- (3)内建函数对象概念
- (4)算法概述
- (5)常用的遍历算法
- (6)常用的查找算法
- (7)常用的排序算法
- (8)常用的拷贝和替换算法
- (9)常用的算数生成算法
- (10)常用的集合算法
温馨提示：
STL是一个标准，有标准有不同的实现：
HP STL
vc++ : P.J.Plauger STL
gcc : SGI STL
Borland c++: rouge wave STL
1.STL六大组件简介
STL提供了六大组件，彼此之间可以组合套用，这六大组件分别是:容器、算法、迭代器、仿函数、适配器、空间配置器。
容器：各种数据结构，如vector、list、deque、set、map等,用来存放数据，从实现角度来看，STL容器是一种class template。
算法：各种常用的算法，如sort、find、copy、for_each。从实现的角度来看，STL算法是一种function tempalte.
迭代器：扮演了容器与算法之间的胶合剂，共有五种类型，从实现角度来看，迭代器是一种将operator* , operator-> , operator++,operator–等指针相关操作予以重载的class template. 所有STL容器都附带有自己专属的迭代器，只有容器的设计者才知道如何遍历自己的元素。原生指针(native pointer)也是一种迭代器。
仿函数：行为类似函数，可作为算法的某种策略。从实现角度来看，仿函数是一种重载了operator()的class 或者class template
适配器：一种用来修饰容器或者仿函数或迭代器接口的东西。
空间配置器：负责空间的配置与管理。从实现角度看，配置器是一个实现了动态空间配置、空间管理、空间释放的class tempalte.
STL六大组件的交互关系，容器通过空间配置器取得数据存储空间，算法通过迭代器存储容器中的内容，仿函数可以协助算法完成不同的策略的变化，适配器可以修饰仿函数。
2.容器简介
常用的数据结构不在乎，数组(array),链表(list),tree(树)，栈(stack),队列(queue),集合(set),映射表(map),根据数据在容器中的排列特性，这些数据分为序列式容器和关联式容器两种。
- Ø 序列式容器就是容器元素在容器中的位置是由元素进入容器的时间和地点来决定。Vector容器、Deque容器、List容器、Stack容器、Queue容器。
- Ø 关联式容器是指容器已经有了一定的规则，容器元素在容器中的位置由我的规则来决定。Set/multiset容器 Map/multimap容器
3.算法
算法分为:质变算法和非质变算法。
- 质变算法：是指运算过程中会更改区间内的元素的内容。例如拷贝，替换，删除等等
- 非质变算法：是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极值等等
4.迭代器
<< Design Patterns>>一书中提供了23中设计模式的完整描述，其中iterator模式定义如下：提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式。
迭代器的种类:
| 输入迭代器 | 提供对数据的只读访问 | 只读，支持++、==、！= |
|---|---|---|
| 输出迭代器 | 提供对数据的只写访问 | 只写，支持++ |
| 前向迭代器 | 提供读写操作，并能向前推进迭代器 | 读写，支持++、==、！= |
| 双向迭代器 | 提供读写操作，并能向前和向后操作 | 读写，支持++、–， |
| 随机访问迭代器 | 提供读写操作，并能在数据中随机移动 | 读写，支持++、–、[n]、-n、<、<=、>、>= |
5.常用容器
(1)string容器
-
string 构造函数
string();//创建一个空的字符串 例如: string str; string(const string& str);//使用一个string对象初始化另一个string对象 string(const char* s);//使用字符串s初始化 string(int n, char c);//使用n个字符c初始化 -
string基本赋值操作
string& operator=(const char* s);//char*类型字符串 赋值给当前的字符串 string& operator=(const string &s);//把字符串s赋给当前的字符串 string& operator=(char c);//字符赋值给当前的字符串 string& assign(const char *s);//把字符串s赋给当前的字符串 string& assign(const char *s, int n);//把字符串s的前n个字符赋给当前的字符串 string& assign(const string &s);//把字符串s赋给当前字符串 string& assign(int n, char c);//用n个字符c赋给当前字符串 string& assign(const string &s, int start, int n);//将s从start开始n个字符赋值给字符串 -
string存取字符操作
char& operator[](int n);//通过[]方式取字符 char& at(int n);//通过at方法获取字符 -
string拼接操作
string& operator+=(const string& str);//重载+=操作符 string& operator+=(const char* str);//重载+=操作符 string& operator+=(const char c);//重载+=操作符 string& append(const char *s);//把字符串s连接到当前字符串结尾 string& append(const char *s, int n);//把字符串s的前n个字符连接到当前字符串结尾 string& append(const string &s);//同operator+=() string& append(const string &s, int pos, int n);//把字符串s中从pos开始的n个字符连接到当前字符串结尾 string& append(int n, char c);//在当前字符串结尾添加n个字符c -
string查找和替换
int find(const string& str, int pos = 0) const; //查找str第一次出现位置,从pos开始查找 int find(const char* s, int pos = 0) const; //查找s第一次出现位置,从pos开始查找 int find(const char* s, int pos, int n) const; //从pos位置查找s的前n个字符第一次位置 int find(const char c, int pos = 0) const; //查找字符c第一次出现位置 int rfind(const string& str, int pos = npos) const;//查找str最后一次位置,从pos开始查找 int rfind(const char* s, int pos = npos) const;//查找s最后一次出现位置,从pos开始查找 int rfind(const char* s, int pos, int n) const;//从pos查找s的前n个字符最后一次位置 int rfind(const char c, int pos = 0) const; //查找字符c最后一次出现位置 string& replace(int pos, int n, const string& str); //替换从pos开始n个字符为字符串str string& replace(int pos, int n, const char* s); //替换从pos开始的n个字符为字符串s -
string比较操作
/* compare函数在>时返回 1，<时返回 -1，==时返回 0。 比较区分大小写，比较时参考字典顺序，排越前面的越小。 大写的A比小写的a小。 */ int compare(const string &s) const;//与字符串s比较 int compare(const char *s) const;//与字符串s比较 -
string子串
string substr(int pos = 0, int n = npos) const;//返回由pos开始的n个字符组成的字符串 -
string插入和删除操作
string& insert(int pos, const char* s); //插入字符串 string& insert(int pos, const string& str); //插入字符串 string& insert(int pos, int n, char c);//在指定位置插入n个字符c string& erase(int pos, int n = npos);//删除从Pos开始的n个字符 -
string和c-style字符串转换
//string 转 char* string str = "joker"; const char* cstr = str.c_str(); //char* 转 string char* s = "joker"; string sstr(s);
(2)vector容器
vector提供的是随机访问迭代器(Random Access Iterators).
温馨提示：
所谓动态增加大小，并不是在原空间之后续接新空间(因为无法保证原空间之后尚有可配置的空间)，而是一块更大的内存空间，然后将原数据拷贝新空间，并释放原空间。因此，对vector的任何操作，一旦引起空间的重新配置，指向原vector的所有迭代器就都失效了。这是程序员容易犯的一个错误，务必小心。
-
vector构造函数
vectorv; //采用模板实现类实现，默认构造函数 vector(v.begin(), v.end());//将v[begin(), end())区间中的元素拷贝给本身。 vector(n, elem);//构造函数将n个elem拷贝给本身。 vector(const vector &vec);//拷贝构造函数。 //例子 使用第二个构造函数 我们可以... int arr[] = {2,3,4,1,9}; vector v1(arr, arr + sizeof(arr) / sizeof(int)); -
vector常用赋值操作
assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。 assign(n, elem);//将n个elem拷贝赋值给本身。 vector& operator=(const vector &vec);//重载等号操作符 swap(vec);// 将vec与本身的元素互换。 -
vector大小操作
size();//返回容器中元素的个数 empty();//判断容器是否为空 resize(int num);//重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。 resize(int num, elem);//重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长>度的元素被删除。 capacity();//容器的容量 reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问。 -
vector数据存取操作
at(int idx); //返回索引idx所指的数据，如果idx越界，抛出out_of_range异常。 operator[];//返回索引idx所指的数据，越界时，运行直接报错 front();//返回容器中第一个数据元素 back();//返回容器中最后一个数据元素 -
vector插入和删除操作
insert(const_iterator pos, int count,ele);//迭代器指向位置pos插入count个元素ele. push_back(ele); //尾部插入元素ele pop_back();//删除最后一个元素 erase(const_iterator start, const_iterator end);//删除迭代器从start到end之间的元素 erase(const_iterator pos);//删除迭代器指向的元素 clear();//删除容器中所有元素 -
巧用swap，收缩内存空间
vector(v).swap(v); //匿名对象 如果容器v的size减小，但是capacity过大，想要释放大容量，采用匿名对象，调用拷贝构造函数用v初始化，然后匿名对象与v交换，之后size和capacity就一样大了，而匿名对象被析构。从而达到了收缩内存空间的目的。
(3)deque容器
Vector容器是单向开口的连续内存空间，deque则是一种双向开口的连续线性空间。所谓的双向开口，意思是可以在头尾两端分别做元素的插入和删除操作，当然，vector容器也可以在头尾两端插入元素，但是在其头部操作效率奇差，无法被接受。
deque没有容量的概念，因为它是动态的以分段连续空间组合而成，随时可以增加一段新的空间并链接起来
虽然deque容器也提供了Random Access Iterator,但是它的迭代器并不是普通的指针，其复杂度和vector不是一个量级，这当然影响各个运算的层面。因此，除非有必要，我们应该尽可能的使用vector，而不是deque。对deque进行的排序操作，为了最高效率，可将deque先完整的复制到一个vector中，对vector容器进行排序，再复制回deque.
-
deque构造函数
dequedeqT;//默认构造形式 deque(beg, end);//构造函数将[beg, end)区间中的元素拷贝给本身。 deque(n, elem);//构造函数将n个elem拷贝给本身。 deque(const deque &deq);//拷贝构造函数。 -
deque赋值操作
assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。 assign(n, elem);//将n个elem拷贝赋值给本身。 deque& operator=(const deque &deq); //重载等号操作符 swap(deq);// 将deq与本身的元素互换 -
deque大小操作
deque.size();//返回容器中元素的个数 deque.empty();//判断容器是否为空 deque.resize(num);//重新指定容器的长度为num,若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。 deque.resize(num, elem); //重新指定容器的长度为num,若容器变长，则以elem值填充新位置,如果容器变短，则末尾超出容器长度的元素被删除。 -
deque双端插入和删除操作
push_back(elem);//在容器尾部添加一个数据 push_front(elem);//在容器头部插入一个数据 pop_back();//删除容器最后一个数据 pop_front();//删除容器第一个数据 -
deque元素访问
at(idx);//返回索引idx所指的数据，如果idx越界，抛出out_of_range。 operator[];//返回索引idx所指的数据，如果idx越界，不抛出异常，直接出错。 front();//返回第一个数据。 back();//返回最后一个数据 -
deque插入操作
insert(pos,elem);//在pos位置插入一个elem元素的拷贝，返回新数据的位置。 insert(pos,n,elem);//在pos位置插入n个elem数据，无返回值。 insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值。 -
deque删除操作
clear();//移除容器的所有数据 erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。 erase(pos);//删除pos位置的数据，返回下一个数据的位置。
(4)stack容器
-
stack构造函数
stackstkT;//stack采用模板类实现， stack对象的默认构造形式： stack(const stack &stk);//拷贝构造函数 -
stack赋值操作
stack& operator=(const stack &stk);//重载等号操作符 -
stack数据存取操作
push(elem);//向栈顶添加元素 pop();//从栈顶移除第一个元素 top();//返回栈顶元素 -
stack大小操作
empty();//判断堆栈是否为空 size();//返回堆栈的大小
(5)queue容器
-
queue构造函数
queuequeT;//queue采用模板类实现，queue对象的默认构造形式： queue(const queue &que);//拷贝构造函数 -
queue存取、插入和删除操作
push(elem);//往队尾添加元素 pop();//从队头移除第一个元素 back();//返回最后一个元素 front();//返回第一个元素 -
queue赋值操作
queue& operator=(const queue &que);//重载等号操作符 -
queue大小操作
empty();//判断队列是否为空 size();//返回队列的大小
(6)list容器
相较于vector的连续线性空间，list就显得负责许多，它的好处是每次插入或者删除一个元素，就是配置或者释放一个元素的空间。因此，list对于空间的运用有绝对的精准，一点也不浪费。而且，对于任何位置的元素插入或元素的移除，list永远是常数时间。
List和vector是两个最常被使用的容器。
list是一个双向链表，迭代器必须能够具备前移、后移的能力，所以list容器提供的是Bidirectional Iterators(双向迭代器)
List有一个重要的性质，插入操作和删除操作都不会造 成原有list迭代
器的失效。这在vector是不成立的，因为vector的插入操作可能造成记忆
体重新配置，导致原有的迭代器全部失效，甚至List元素的删除，也只有
被删除的那个元素的迭代器失效，其他迭代器不受任何影响。
-
list构造函数
listlstT;//list采用采用模板类实现,对象的默认构造形式： list(beg,end);//构造函数将[beg, end)区间中的元素拷贝给本身。 list(n,elem);//构造函数将n个elem拷贝给本身。 list(const list &lst);//拷贝构造函数。 -
list数据元素插入和删除操作
push_back(elem);//在容器尾部加入一个元素 pop_back();//删除容器中最后一个元素 push_front(elem);//在容器开头插入一个元素 pop_front();//从容器开头移除第一个元素 insert(pos,elem);//在pos位置插elem元素的拷贝，返回新数据的位置。 insert(pos,n,elem);//在pos位置插入n个elem数据，无返回值。 insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值。 clear();//移除容器的所有数据 erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置。 erase(pos);//删除pos位置的数据，返回下一个数据的位置。 remove(elem);//删除容器中所有与elem值匹配的元素。 -
list大小操作
size();//返回容器中元素的个数 empty();//判断容器是否为空 resize(num);//重新指定容器的长度为num， 若容器变长，则以默认值填充新位置。 如果容器变短，则末尾超出容器长度的元素被删除。 resize(num, elem);//重新指定容器的长度为num， 若容器变长，则以elem值填充新位置。 如果容器变短，则末尾超出容器长度的元素被删除。 -
list赋值操作
assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。 assign(n, elem);//将n个elem拷贝赋值给本身。 list& operator=(const list &lst);//重载等号操作符 swap(lst);//将lst与本身的元素互换。 -
list数据的存取
front();//返回第一个元素。 back();//返回最后一个元素。 -
list反转排序
reverse();//反转链表，比如lst包含1,3,5元素，运行此方法后，lst就包含5,3,1元素。 sort(); //list排序
(7)set/multiset容器
Set的特性是，所有元素都会根据元素的键值自动被排序。Set的元素不像map那样可以同时拥有实值和键值，set的元素即是键值又是实值。Set不允许两个元素有相同的键值。
我们可以通过set的迭代器改变set元素的值吗？不行，因为set元素值就是其键值，关系到set元素的排序规则。如果任意改变set元素值，会严重破坏set组织。换句话说，set的iterator是一种const_iterator.
set拥有和list某些相同的性质，当对容器中的元素进行插入操作或者删除操作的时候，操作之前所有的迭代器，在操作完成之后依然有效，被删除的那个元素的迭代器必然是一个例外。
multiset特性及用法和set完全相同，唯一的差别在于它允许键值重复。set和multiset的底层实现是红黑树，红黑树为平衡二叉树的一种。
-
set构造函数
setst;//set默认构造函数： mulitset mst; //multiset默认构造函数: set(const set &st);//拷贝构造函数 -
set赋值操作
set& operator=(const set &st);//重载等号操作符 swap(st);//交换两个集合容器 -
set大小操作
size();//返回容器中元素的数目 empty();//判断容器是否为空 -
set插入和删除操作
insert(elem);//在容器中插入元素。 clear();//清除所有元素 erase(pos);//删除pos迭代器所指的元素，返回下一个元素的迭代器。 erase(beg, end);//删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。 erase(elem);//删除容器中值为elem的元素。 -
set查找操作
find(key);//查找键key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end(); count(key);//查找键key的元素个数 lower_bound(keyElem);//返回第一个key>=keyElem元素的迭代器。 upper_bound(keyElem);//返回第一个key>keyElem元素的迭代器。 equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器。
对组(pair)将一对值组合成一个值，这一对值可以具有不同的数据类型，两个值可以分别用pair的两个公有属性first和second访问。
类模板：template
struct pair.
(8)map/multimap容器
Map的特性是，所有元素都会根据元素的键值自动排序。Map所有的元素都是pair,同时拥有实值和键值，pair的第一元素被视为键值，第二元素被视为实值，map不允许两个元素有相同的键值。
我们可以通过map的迭代器改变map的键值吗？答案是不行，因为map的键值关系到map元素的排列规则，任意改变map键值将会严重破坏map组织。如果想要修改元素的实值，那么是可以的。
Map和list拥有相同的某些性质，当对它的容器元素进行新增操作或者删除操作时，操作之前的所有迭代器，在操作完成之后依然有效，当然被删除的那个元素的迭代器必然是个例外。
Multimap和map的操作类似，唯一区别multimap键值可重复。
Map和multimap都是以红黑树为底层实现机制。
-
map构造函数
map -
map赋值操作
map& operator=(const map &mp);//重载等号操作符 swap(mp);//交换两个集合容器 -
map大小操作
size();//返回容器中元素的数目 empty();//判断容器是否为空 -
map插入数据元素操作
map.insert(...); //往容器插入元素，返回pair -
map删除操作
clear();//删除所有元素 erase(pos);//删除pos迭代器所指的元素，返回下一个元素的迭代器。 erase(beg,end);//删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。 erase(keyElem);//删除容器中key为keyElem的对组。 -
map查找操作
find(key);//查找键key是否存在,若存在，返回该键的元素的迭代器；/若不存在，返回map.end(); count(keyElem);//返回容器中key为keyElem的对组个数。对map来说，要么是0，要么是1。对multimap来说，值可能大于1。 lower_bound(keyElem);//返回第一个key<=keyElem元素的迭代器。 upper_bound(keyElem);//返回第一个key>keyElem元素的迭代器。 equal_range(keyElem);//返回容器中key与keyElem相等的上下限的两个迭代器。
6.STL容器元素深/浅拷贝问题
STL容器所提供的都是值(value)寓意，而非引用(reference)寓意，也就是说当我们给容器中插入元素的时候，容器内部实施了拷贝动作，将我们要插入的元素再另行拷贝一份放入到容器中，而不是将原数据元素直接放进容器中，也就是说我们提供的元素必须能够被拷贝。
(1)STL容器使用时机
| vector | deque | list | set | multiset | map | multimap | |
|---|---|---|---|---|---|---|---|
| 典型内存结构 | 单端数组 | 双端数组 | 双向链表 | 二叉树 | 二叉树 | 二叉树 | 二叉树 |
| 可随机存取 | 是 | 是 | 否 | 否 | 否 | 对key而言：不是 | 否 |
| 元素搜寻速度 | 慢 | 慢 | 非常慢 | 快 | 快 | 对key而言：快 | 对key而言：快 |
| 元素安插移除 | 尾端 | 头尾两端 | 任何位置 | - | - | - | - |
- vector的使用场景：比如软件历史操作记录的存储，我们经常要查看历史记录，比如上一次的记录，上上次的记录，但却不会去删除记录，因为记录是事实的描述。
- deque的使用场景：比如排队购票系统，对排队者的存储可以采用deque，支持头端的快速移除，尾端的快速添加。如果采用vector，则头端移除时，会移动大量的数据，速度慢。
vector与deque的比较：
一：vector.at()比deque.at()效率高，比如vector.at(0)是固定的，deque的开始位置 却是不固定的。
二：如果有大量释放操作的话，vector花的时间更少，这跟二者的内部实现有关。
三：deque支持头部的快速插入与快速移除，这是deque的优点。
- list的使用场景：比如公交车乘客的存储，随时可能有乘客下车，支持频繁的不确实位置元素的移除插入。
- set的使用场景：比如对手机游戏的个人得分记录的存储，存储要求从高分到低分的顺序排列。
- map的使用场景：比如按ID号存储十万个用户，想要快速要通过ID查找对应的用户。二叉树的查找效率，这时就体现出来了。如果是vector容器，最坏的情况下可能要遍历完整个容器才能找到该用户。
7.常用的算法
(1)函数对象概念
重载函数调用操作符的类，其对象常称为函数对象（function object），即它们是行为类似函数的对象，也叫仿函数(functor),其实就是重载“()”操作符，使得类对象可以像函数那样调用。
函数对象的作用主要是什么？STL提供的算法往往都有两个版本，其中一个版本表现出最常用的某种运算，另一版本则允许用户通过template参数的形式来指定所要采取的策略。
温馨提示：
1.函数对象(仿函数)是一个类，不是一个函数。
2.函数对象(仿函数)重载了”() ”操作符使得它可以像函数一样调用。
分类:假定某个类有一个重载的operator()，而且重载的operator()要求获取一个参数，我们就将这个类称为“一元仿函数”（unary functor）；相反，如果重载的operator()要求获取两个参数，就将这个类称为“二元仿函数”（binary functor）。
(2)谓词概念
谓词是指普通函数或重载的operator()返回值是bool类型的函数对象(仿函数)。如果operator接受一个参数，那么叫做一元谓词,如果接受两个参数，那么叫做二元谓词，谓词可作为一个判断式。
(3)内建函数对象概念
STL内建了一些函数对象。分为:算数类函数对象,关系运算类函数对象，逻辑运算类仿函数。这些仿函数所产生的对象，用法和一般函数完全相同，当然我们还可以产生无名的临时对象来履行函数功能。使用内建函数对象，需要引入头文件 #include。
-
6个算数类函数对象,除了negate是一元运算，其他都是二元运算。
templateT plus //加法仿函数 template T minus //减法仿函数 template T multiplies //乘法仿函数 template T divides //除法仿函数 template T modulus //取模仿函数 template T negate //取反仿函数 -
6个关系运算类函数对象,每一种都是二元运算。
templatebool equal_to //等于 template bool not_equal_to //不等于 template bool greater //大于 template bool greater_equal //大于等于 template bool less //小于 template bool less_equal //小于等于 -
逻辑运算类运算函数,not为一元运算，其余为二元运算。
templatebool logical_and //逻辑与 template bool logical_or //逻辑或 template bool logical_not //逻辑非
(4)算法概述
算法主要是由头文件 组成。
是所有STL头文件中最大的一个,其中常用的功能涉及到比较，交换，查找,遍历，复制，修改，反转，排序，合并等…
体积很小，只包括在几个序列容器上进行的简单运算的模板函数.
定义了一些模板类,用以声明函数对象。
(5)常用的遍历算法
/*
遍历算法 遍历容器元素
@param beg 开始迭代器
@param end 结束迭代器
@param _callback 函数回调或者函数对象
@return 函数对象
*/
for_each(iterator beg, iterator end, _callback);
/*
transform算法 将指定容器区间元素搬运到另一容器中
注意 : transform 不会给目标容器分配内存，所以需要我们提前分配好内存
@param beg1 源容器开始迭代器
@param end1 源容器结束迭代器
@param beg2 目标容器开始迭代器
@param _cakkback 回调函数或者函数对象
@return 返回目标容器迭代器
*/
transform(iterator beg1, iterator end1, iterator beg2, _callbakc)
(6)常用的查找算法
/*
find算法 查找元素
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param value 查找的元素
@return 返回查找元素的位置
*/
find(iterator beg, iterator end, value)
/*
binary_search算法 二分查找法
注意: 在无序序列中不可用
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param value 查找的元素
@return bool 查找返回true 否则false
*/
bool binary_search(iterator beg, iterator end, value);
/*
find_if算法 条件查找
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param callback 回调函数或者谓词(返回bool类型的函数对象)
@return bool 查找返回true 否则false
*/
find_if(iterator beg, iterator end, _callback);
/*
count算法 统计元素出现次数
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param value回调函数或者谓词(返回bool类型的函数对象)
@return int返回元素个数
*/
count(iterator beg, iterator end, value);
/*
count算法 统计元素出现次数
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param callback 回调函数或者谓词(返回bool类型的函数对象)
@return int返回元素个数
*/
count_if(iterator beg, iterator end, _callback);
(7)常用的排序算法
/*
merge算法 容器元素合并，并存储到另一容器中
@param beg1 容器1开始迭代器
@param end1 容器1结束迭代器
@param beg2 容器2开始迭代器
@param end2 容器2结束迭代器
@param dest 目标容器开始迭代器
*/
merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest)
/*
sort算法 容器元素排序
注意:两个容器必须是有序的
@param beg 容器1开始迭代器
@param end 容器1结束迭代器
@param _callback 回调函数或者谓词(返回bool类型的函数对象)
*/
sort(iterator beg, iterator end, _callback)
/*
sort算法 对指定范围内的元素随机调整次序
@param beg 容器开始迭代器
@param end 容器结束迭代器
*/
random_shuffle(iterator beg, iterator end)
/*
reverse算法 反转指定范围的元素
@param beg 容器开始迭代器
@param end 容器结束迭代器
*/
reverse(iterator beg, iterator end)
(8)常用的拷贝和替换算法
/*
copy算法 将容器内指定范围的元素拷贝到另一容器中
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param dest 目标容器结束迭代器
*/
copy(iterator beg, iterator end, iterator dest)
/*
replace算法 将容器内指定范围的旧元素修改为新元素
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param oldvalue 旧元素
@param oldvalue 新元素
*/
replace(iterator beg, iterator end, oldvalue, newvalue)
/*
replace_if算法 将容器内指定范围满足条件的元素替换为新元素
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param callback函数回调或者谓词(返回Bool类型的函数对象)
@param oldvalue 新元素
*/
replace_if(iterator beg, iterator end, _callback, newvalue)
/*
swap算法 互换两个容器的元素
@param c1容器1
@param c2容器2
*/
swap(container c1, container c2)
(9)常用的算数生成算法
/*
accumulate算法 计算容器元素累计总和
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param value累加值
*/
accumulate(iterator beg, iterator end, value)
/*
fill算法 向容器中添加元素
@param beg 容器开始迭代器
@param end 容器结束迭代器
@param value t填充元素
*/
fill(iterator beg, iterator end, value)
(10)常用的集合算法
/*
set_intersection算法 求两个set集合的交集
注意:两个集合必须是有序序列
@param beg1 容器1开始迭代器
@param end1 容器1结束迭代器
@param beg2 容器2开始迭代器
@param end2 容器2结束迭代器
@param dest 目标容器开始迭代器
@return 目标容器的最后一个元素的迭代器地址
*/
set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest)
/*
set_union算法 求两个set集合的并集
注意:两个集合必须是有序序列
@param beg1 容器1开始迭代器
@param end1 容器1结束迭代器
@param beg2 容器2开始迭代器
@param end2 容器2结束迭代器
@param dest 目标容器开始迭代器
@return 目标容器的最后一个元素的迭代器地址
*/
set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest)
/*
set_difference算法 求两个set集合的差集
注意:两个集合必须是有序序列
@param beg1 容器1开始迭代器
@param end1 容器1结束迭代器
@param beg2 容器2开始迭代器
@param end2 容器2结束迭代器
@param dest 目标容器开始迭代器
@return 目标容器的最后一个元素的迭代器地址
*/
set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest)