C++编程思想(卷二)：STL算法目录

迭代器的各种形式概述：
InputIterator：一个只允许单个向序列读入元素的输入迭代器，前向传递使用operator++和operator*。也可以通过operator==和operator!=检测输入迭代器。
OutputIterator：一个只允许单个向序列写入元素的输出迭代器，前向传递使用operator++和operator*。不可以通过operator==和operator!=检测输出迭代器。OutputIterator可以与ostream一起使用，同时也普遍使用“插入”迭代器back_inserter()。
ForwardIterator：仅用operator++前向移动，但是可以同时进行读和写，并且可以在相通的范围内比较这些迭代器是否相等。
BidirectionalIterator：一个可以后向移动的ForwardIterator，另外还增加了operator--运算。
RandomAccessIterator：支持一个常规指针所做的全部运算：可以通过增加和减少某个整数值，来向前和向后跳跃移动，还可以用operator[]作为下标索引，可以从一个迭代器中减去另一个迭代器，也可以用operator<和operator>来比较迭代器看哪个更大等。

填充和生成：
fill()对[first,last)范围内的每个元素赋值value，fill_n()对由first开始的n个元素赋值value。
void fill(ForwardIterator first, ForwardIterator last, const T& value);
void fill_n(OutputIterator first, Size n, const T& value);

generate()为[first,last)范围内的每个元素进行一个gen()调用，可以假定为每个元素产生一个不同的值。
generate_n()对gen()调用n次，并且将返回值赋给由first开始的n个元素。
void generate(ForwardIterator first, ForwardIterator last, Generator gen);
void generate_n(OutputIterator first, Size n, Generator gen);

计数：
所有的容器都含有一个成员函数size()，它可以告之该容器包含有多少个元素。size()的返回类型是迭代器的difference_type（通常是ptrdiff_t）。

count()算法中产生[first,last)范围内其值等于value（当用operator==测试时）的元素的个数。
count_if()算法产生[first,last)范围内能使pred返回true的元素的个数。
IntegralValue count(InputIterator first, InputIterator last, const EqualityComparable& value);
IntegralValue count_if(InputIterator first, InputIterator last, Predicate pred);

操作序列：
copy()算法从范围[first,last)复制序列到destination，每次赋值后都增加destination，由于使用了赋值操作，因此不能直接向空容器或容器末尾插入元素，而必须把destination迭代器封装在insert_iterator里（典型地使用back_inserter()或inserter()）。
OutputIterator copy(InputIterator first, InputIterator last, OutputIterator destination);

copy_backward()算法以相反的顺序复制元素，第1个目的元素是destinationEnd - 1，并且每次赋值后都减少destinationEnd。目的序列范围的空间必须已经存在。
BidirectionalIterator2 copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last, BidirectionalIterator2 destinationEnd);

reverse()倒置原序列范围的元素。
reverse_copy()保持原序列范围元素顺序不变，而将倒置的元素复制到destination，返回结果序列范围的超越末尾的迭代器。
void reverse(BidirectionalIterator first, BidirectionalIterator last);
OutputIterator reverse_copy(BidirectionalIterator first, BidirectionalIterator last, OutputIterator destination);

swap_ranges()通过交换对应的元素来交换相等大小的两个范围的内容
ForwardIterator2 swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2);

轮换函数：
rotate()把[first,middle)范围中的内容移动到该序列的末尾，并且将[middle,last)范围中的内容移到序列的开始位置。
rotate_copy()不改变原始序列范围，且将轮换后版本的元素复制到destination，返回结束范围的超越末尾的迭代器。
void rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last);
OutputIterator rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last, OutputIterator destination);

后继和前驱排列函数：
如果没有多个后继排列，元素以升序排列，next_permutation()返回false。
如果没有多个前驱排列，元素以降序排列，prev_permutation()返回false。
bool next_permutation(BidirectionalIterator first, BidirectionalIterator last);
bool next_permutation(BidirectionalIterator first, BidirectionalIterator last, StrictWeakOrdering binary_pred);
bool prev_permutation(BidirectionalIterator first, BidirectionalIterator last);
bool prev_permutation(BidirectionalIterator first, BidirectionalIterator last, StrictWeakOrdering binary_pred);

random_shuffle()随机地重排范围内的元素。
void random_shuffle(RandomAccessIterator first, RandomAccessIterator last);    //使用内部随机数发生器
void random_shuffle(RandomAccessIterator first, RandomAccessIterator last RandomNumberGenerator& rand);    //使用用户提供的随机数发生器

调用partition()后，每个结果子序列的元素顺序并没有被指定。
调用stable_partition()后，划分点前后这些元素的相对顺序与划分处理前相同。
BidirectionalIterator partition(BidirectionalIterator first, BidirectionalIterator last, Predicate pred);
BidirectionalIterator stable_partition(BidirectionalIterator first, BidirectionalIterator last, Predicate pred);

查找和替换：
find()在某个范围内的序列元素中查找value。返回一个迭代器，该迭代器指向在范围[first,last)内value第1次出现的位置，如果value不在范围内，find()返回last。这是线性查找。
InputIterator find(InputIterator first, InputIterator last, const EqualityComparable& value);

find_if()在指定的序列范围内执行线性查找。然而，代替查找value，find_if()寻找一个满足pred的元素，当查找到这样的元素时Predicate pred返回true。如果不能找到这样的元素则返回last。
InputIterator find_if(InputIterator first, InputIterator last, Predicate pred);

adjacent_find()在指定的序列范围内执行线性查找两个邻近的相等元素。
形式一查找两个相等的元素（通过operator==）。
形式二查找两个邻近的元素，当找到这两个元素并一起传递给binary_pred时，产生true结果。如果找到这样的一对元素，则返回指向两个元素中第1个元素的迭代器，否则返回last。
ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last);
ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last, BinaryPredicate binary_pred);

find_first_of()在第2个范围内查找与第1个范围内的某个元素相等的元素。
形式一使用operator==。
形式二使用提供的判定函数。
ForwardIterator1 find_first_of(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2);
ForwardIterator1 find_first_of(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, binaryPredicate binary_pred);

search()检查第2个序列范围是否出现在第1个序列的范围内（顺序也完全一致），如果是则返回一个迭代器，该迭代器指向在第1个范围序列中第2个范围序列出现的开始位置。如果没有找到就返回last1。
形式一使用operator==。
形式二检测被比较的每对元素是否能使binary_pred返回true。
ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2);
ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate binary_pred);

find_end()查找第2个范围的序列是否在第1个范围内作为子集出现，查找该子集最后出现的位置，并且返回指向该子集的第一个元素的迭代器。
ForwardIterator1 find_end(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2);
ForwardIterator1 find_end(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate binary_pred);

search_n()：
形式一在[first,last)范围内查找一组共count个连续的值，这些值都与value相等。如果不能找到这样的一组数值就返回last。找到符合条件的串后返回的迭代器指向其首部。
形式二在[first,last)范围内查找一组共count个连续的值，当将所有这些值与value传递给binary_pred时满足条件后返回true。如果不能找到这样的一组数值就返回last。找到符合条件的串后返回的迭代器指向其尾部。
ForwardIterator search_n(ForwardIterator first, ForwardIterator last, Size count, const T& value);
ForwardIterator search_n(ForwardIterator first, ForwardIterator last, Size count, const T& value, BinaryPredicate binary_pred);

min_element()返回一个迭代器，该迭代器指向范围内“最小的”值首次出现的位置。如果范围内为空则返回last。
形式一用 operator< 执行比较，且返回值为r，其意义是：对范围[first,r)中每个元素e,*e < *r 都为假。
形式二用binary_pred比较，且返回值为r，其意义是：对于范围[first,r)中每个元素e，binary_pred(*e, *r)都为假。
ForwardIterator min_element(ForwardIterator first, ForwardIterator last);
ForwardIterator min_element(ForwardIterator first, ForwardIterator last, BinaryPredicate binary_pred);

max_element()返回一个迭代器，该迭代器指向范围内“最大的”值首次出现的位置。如果范围内为空则返回last。
形式一用 operator< 执行比较，且返回值为r，其意义是：对范围[first,r)中每个元素e,*r < *e 都为假。
形式二用binary_pred比较，且返回值为r，其意义是：对于范围[first,r)中每个元素e，binary_pred(*r, *e)都为假。
ForwardIterator max_element(ForwardIterator first, ForwardIterator last);
ForwardIterator max_element(ForwardIterator first, ForwardIterator last, BinaryPredicate binary_pred);

替换函数：都从头到尾在范围[first,last)内进行查找，找到与标准匹配的值并用new_value替换它们。
replace()和replace_copy()都是仅仅查找old_value并对其进行替换。
replace_if()和replace_copy_if()查找妈祖判定函数pred的值。
函数的“复制”形式不修改原始范围，而是将作为替代的一个副本赋给result，更换它的值。
void replace(ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value);
void replace_if(ForwardIterator first, ForwardIterator last, Predicate pred, const T& new_value);
OutputIterator replace_copy(InputIterator first, InputIterator last, OutputIterator result, const T& old_value, const T& new_value);
OutputIterator replace_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred, const T& new_value);

比较范围：
如果两个范围完全相同（有相同的元素和相同的顺序）,equal()函数返回真。
形式一中由operator==执行比较。
形式二由binary_pred来决定两个元素是否相同。
bool equal(InputIterator first1, InputIterator last1, InputIterator first2);
bool equal(InputIterator first1, InputIterator last1, InputIterator first2 BinaryPredicate binary_pred);

lexicographical_compare()判断第1个范围是否“字典编纂顺序的小于”第2个范围，小于则返回true，否则返回false。
形式一中由operator< 执行比较。
形式二中使用判定函数binary_pred。
bool lexicographical_compare(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);
bool lexicographical_compare(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, BinaryPredicate binary_pred);

mismatch()告诉比较从哪里开始不同。如果没有出现不匹配，返回值是与第2个范围结合在一起的超越末尾的迭代器last1。
pair模板类是一个struct，该struct含有两个用成员名first和second表示的元素，在<utility>头文件中定义。
形式一使用operator==。
形式二使用binary_pred。
pair<InputIterator1, InputIterator2> mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
pair<InputIterator1, InputIterator2> mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate binary_pred);

删除元素：
因为STL的通用性，这里对删除的概念有一点限制。
    STL“删除”函数重新排列该序列，就是将“已被删除的”元素排在序列的末尾，“未删除的”元素排在序列的开头。然后函数返回一个指向序列的“新末尾”元素的迭代器，这个“新末尾”元素是不含被删除元素的序列的末尾，也是被删除元素序列的开头。换句话说，如果new_last是从“删除”函数返回的迭代器，则范围[first,new_last)是不包含任何被删除元素的序列，而范围[new_last,last)是被删除元素组成的序列。

    每一种“删除”形式都从头至尾遍历范围[first,last)，找到符合删除标准的值，并且复制未被删除的元素（这个元素是随机的）覆盖已被删除的元素。未被删除的元素的原始排列顺序仍然保持。返回值是指向超越范围末尾的迭代器，该范围不包含任何已被删除的元素。
   “if”版本的删除把每一个元素传递给判定函数pred()，来决定是否应该删除（如果pred()返回true，则删除该元素）。“copy”版本的删除不需要修改原始序列，而取而代之是复制未被删除的值到一个开始于result的新范围，并返回指向新范围的超越末尾的迭代器。
remove()的返回值是称为new_last的迭代器。
ForwardIterator remove(ForwardIterator first, ForwardIterator last, const T& value);
ForwardIterator remove_if(ForwardIterator first, ForwardIterator last, Predicate pred);
OutputIterator remove_copy(InputIterator first, InputIterator last, OutputIterator result, const T& value);
OutputIterator remove_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred);

“unique”函数的每一个版本都从头至尾遍历范围[first,last)，找到相邻的相等值，并且通过复制覆盖它们来“删除”这些副本。未被删除的元素的原始仍然保持不变。返回值是指向该范围的超越末尾的迭代器，该范围相邻副本已被删除。“copy”版本的不改变原始序列，而取而代之是复制未被删除的值到一个开始于result的新范围，并返回指向新范围的超越末尾的迭代器。
ForwardIterator unique(ForwardIterator first, ForwardIterator last);
ForwardIterator unique(ForwardIterator first, ForwardIterator last, BinaryPredicate binary_pred);
OutputIterator unique_copy(InputIterator first, InputIterator last, OutputIterator result);
OutputIterator unique_copy(InputIterator first, InputIterator last, OutputIterator result, BinaryPredicate binary_pred);

对已排序的序列进行排序和运算：
对已排好序的序列进行包括排序或运算的每个算法都有两种版本。第1种版本使用对象自己的operator< 来执行比较。第2种版本用operator()(a,b)来决定a和b的相对顺序。
1.排序
升序排列
void sort(RandomAccessIterator first, RandomAccessIterator last);
void sort(RandomAccessIterator first, RandomAccessIterator last, StrictWeakOrdering binary_pred);

升序排列，保持相等元素的原始顺序（假设元素可以是相等的但不是相同的）
void stable_sort(RandomAccessIterator first, RandomAccessIterator last);
void stable_sort(RandomAccessIterator first, RandomAccessIterator last, StrictWeakOrdering binary_pred);

对一定数量的元素排序，这些元素可以放入范围[first,middle)中，排序结束，在范围[middle,last)中其余的那些元素并不保证它们的顺序。
void partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last);
void partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last, StrictWeakOrdering binary_pred);

partial_sort()的复制版本：
RandomAccessIterator partial_sort_copy(InputIterator first, InputIterator last, RandomAccessIterator result_first, RandomAccessIterator result_last);
RandomAccessIterator partial_sort_copy(InputIterator first, InputIterator last, RandomAccessIterator result_first, RandomAccessIterator result_last, StrictWeakOrdering binary_pred);

nth_element()部分处理（排序）范围内的元素，它比partial_sort()要少处理得多。nth_element()唯一保证的是无论选择什么位置，该位置都会称为一个分界点。但任何一个子范围都不会是一个以特定的顺序排好序的序列，这不像partial_sort()，它的第1个范围已排好序。如果需要的是很弱的排序处理，这个算法要比partial_sort()快得多。
void nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last);
void nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last, StrictWeakOrdering binary_pred);

2.在已排序的范围中找出指定元素
判定value是否出现在已排序的范围[first,last)中。
bool binary_search(ForwardIterator first, ForwardIterator last, const T& value);
bool binary_search(ForwardIterator first, ForwardIterator last, const T& value, StrictWeakOrdering binary_pred);

返回的迭代器指出value在已排序的范围[first,last)中第1次出现的位置。如果value没有出现，返回的迭代器则指出它在该序列中应该出现的位置。
ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last, const T& value);
ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last, const T& value, StrictWeakOrdering binary_pred);

返回的迭代器指出在已排序的范围[first,last)中超越value最后出现的一个位置。如果value没有出现，返回的迭代器则指出它在该序列中应该出现的位置。
ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last, const T& value);
ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last, const T& value, StrictWeakOrdering binary_pred);

3.合并已排序的序列
merge()从[first1,last1)和[first2,last2)中复制元素到result，在结果范围的序列以升序排列。是一个稳定算法。
OutputIterator merge(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result);
OutputIterator merge(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, StrictWeakOrdering binary_pred);

假定[first,middle)和[middle,last)是在相同的序列中已排好序的两个范围。合并这两个范围序列到一个结果序列，该结果序列范围[first,last)包含将两个排好序的范围结合成一个有序的范围。
void inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last);
void inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last, StrictWeakOrdering binary_pred);

4.在已排序的序列上进行集合运算
如果[first2,last2)是[first1,last1)的一个子集，返回true。
bool includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2);
bool includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, StrictWeakOrdering binary_pred);

在result范围中创建两个已排序范围的数学并集，返回值指向输出范围的末尾。
OutputIterator set_union(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result);
OutputIterator set_union(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, StrictWeakOrdering binary_pred);

在result中产生两个输入集合的交集，返回值指向输出范围的末尾，即在两个输入集合中都出现数值的集合。
OutputIterator set_intersection(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result);
OutputIterator set_intersection(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, StrictWeakOrdering binary_pred);

在result中产生数学上集合的差，返回值指向输出结果范围的末尾。所有出现在[first1,last1)中，但不在[first2,last2)中出现的元素都放入结果集合。
OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result);
OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, StrictWeakOrdering binary_pred);

在result集合构成中，包括：
1.所有在集合1中而不在集合2中的元素。
2.所有在集合2中而不在集合1中的元素。
返回值指向输出范围的末尾。
OutputIterator set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result);
OutputIterator set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, StrictWeakOrdering binary_pred);

堆运算：
将一个任意序列范围转化成堆。
void make_heap(RandomAccessIterator first, RandomAccessIterator last);
void make_heap(RandomAccessIterator first, RandomAccessIterator last, StrictWeakOrdering binary_pred);

向由范围[fist,last-1)决定的堆中增加元素*(last-1)。即将最后一个元素放入堆中合适的位置。
void push_heap(RandomAccessIterator first, RandomAccessIterator last);
void push_heap(RandomAccessIterator first, RandomAccessIterator last, StrictWeakOrdering binary_pred);

将最大的元素（在运算前实际上在*first中）放入位置*(last-1)并且重新组织剩余的范围，使其仍然在堆的顺序中。
void pop_heap(RandomAccessIterator first, RandomAccessIterator last);
void pop_heap(RandomAccessIterator first, RandomAccessIterator last, StrictWeakOrdering binary_pred);

使一个以堆顺序排列的序列转化成普通的排列顺序，这样它就不在是一个堆。这是一个不稳定的排序。
void sort_heap(RandomAccessIterator first, RandomAccessIterator last);
void sort_heap(RandomAccessIterator first, RandomAccessIterator last, StrictWeakOrdering binary_pred);

对某一范围内的所有元素进行运算：
这些算法遍历整个范围并对每个元素执行运算。
transform()将每个运算的结果放入一个目的序列（也可以是原始序列）。

for_each()对[first,last)中的每个元素应用函数对象f，并丢弃运算的返回值。
UnaryFunction for_each(InputIterator first, InputIterator last, UnaryFunction f);
模板定义：
template<class InputIterator, class Function>
Function for_each(InputIterator first, InputIterator last, Function f) {
    while(first != last) { f(*first++); }
    return f;
}

transform()对范围[first,last)中的每个元素应用函数对象f，并将结果复制（使用operator=）到*result，每次复制后增加result的内容。返回值是超越末尾的迭代器。
形式一调用了f(*first)。第1个范围表示一个输入序列。
形式二调用了f(*first1,*first2)，第2个输入范围的长度由第1个输入范围的长度决定。
OutputIterator transform(InputIterator first, InputIterator last, OutputIterator result, UnaryFunction f);
OutputIterator transform(InputIterator1 first, InputIterator1 last, InputIterator2 first2, OutputIterator result, BinaryFunction f);

数值算法：
这些算法都包含在头文件<numeric>中
合计，对于由迭代器i指向的[first,last)中的每一个元素，执行运算result=result+*i或f(result,*i)。
T accumulate(InputIterator first, InputIterator last, T result);
T accumulate(InputIterator first, InputIterator last, T result, BinaryFunction f);

计算两个范围[first1,last1)和[first2,first2+(last1-first1))的一个广义内积。即用第1个序列中的元素乘以第2个序列中“平行的”元素并对其积进行累加来产生返回值。
参数init是内积的初始值。
T inner_product(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, T init);
T inner_product(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, T init, BinaryFunction1 op1, BinaryFunction2 op2);

计算一个广义部分和。创建一个新的在result开始的序列。新序列中每个元素都是[first,last)范围中从第1个元素到当前选择的元素之间所有元素的累加和。
返回值指向输出范围[result,result+(last-first))的末尾。
例如，原始序列是{1, 1, 2, 2, 3}, 结果序列是{1, 1 + 1, 1 + 1 + 2, 1 + 1 + 2 + 2, 1 + 1 + 2 + 2 + 3}, 即{1, 2, 4, 6, 9}。
OutputIterator partial_sum(InputIterator first, InputIterator last, OutputIterator result);
OutputIterator partial_sum(InputIterator first, InputIterator last, OutputIterator result, BinaryFunction op);

计算全部范围[first,last)中的相邻元素的差。即在新序列中，每个元素的值是原始序列中当前元素与前面的元素的差值（第1个值不变）。
返回值指向输出范围[result,result+(last-first))的末尾。
例如，原始序列是{1, 1, 2, 2, 3},结果序列是{1, 1 – 1, 2 – 1, 2 – 2, 3 – 2}, 即{1, 0, 1, 0, 1}。
OutputIterator adjacent_difference(InputIterator first, InputIterator last, OutputIterator result);
OutputIterator adjacent_difference(InputIterator first, InputIterator last, OutputIterator result, BinaryFunction op);

通用实用程序：
pair是一个简单的将两个对象（可能不同类型的对象）封装成一个对象的方法。当需要从一个函数返回多个对象时使用它是很典型的情况，也可以用来创建一个持有pair对象的容器，或将多个对象作为一个参数进行传递。通过p.first和p.second来访问指定的元素，这里p是pair对象。
如果想“在执行中”创建一个pair，典型的方法是使用模板函数make_pair()，它会自动推断出它接收到的参数的类型。
(Templates in the <utility> header)
template<class T1, class T2> struct pair;
template<class T1, class T2> pair<T1, T2> make_pair(const T1&, const T2&);

计算first与last之间的元素个数。返回一个整数值。
(From <iterator>)
difference_type distance(InputIterator first, InputIterator last);

用来为给定的容器创建迭代器，以便向容器插入元素。每种类型的迭代器对插入使用不同的运算。
(From <iterator>)
back_insert_iterator<Container> back_inserter(Container& x);
front_insert_iterator<Container> front_inserter(Container& x);
insert_iterator<Container> inserter(Container& x, Iterator i);

返回两个参数中较小的一个，或如果两个参数相等则返回第1个参数。
const LessThanComparable& min(const LessThanComparable& a, const LessThanComparable& b);
const T& min(const T& a, const T& b, BinaryPredicate binary_pred);

返回两个参数中较大的一个，或如果两个参数相等则返回第1个参数。
const LessThanComparable& max(const LessThanComparable& a, const LessThanComparable& b);
const T& max(const T& a, const T& b, BinaryPredicate binary_pred);

使用赋值的方法来交换a和b的值，所有的容器类都使用特化的swap()版本。
iter_swap()交换它涉及的两个参数的值。
void swap(Assignable& a, Assignable& b);
void iter_swap(ForwardIterator1 a, ForwardIterator2 b);