深入详解STL算法
深入详解STL算法
下面将介绍标准模板库定义的算法。这些算法通过迭代器在容器中进行操作。所有的算法都是模板函数。
算法详细说明：
adjacent_find
template<class _FwdIt> inline
_FwdIt adjacent_find(_FwdIt _First, _FwdIt _Last);
template<class _FwdIt, class _Pr> inline
_FwdIt adjacent_find(_FwdIt _First, _FwdIt _Last, _Pr _Pred);
adjacent_find算法从start到end的序列中搜索临近的匹配的元素，并返回第一个元素的迭代器。如果没有找到任何邻近对，将返回_last。上面第一种形式搜索等价元素。第二个形式允许指定自己的方法来确定元素是否匹配。
binary_search
template<class _FwdIt, class _Ty> inline
bool binary_search(_FwdIt _First, _FwdIt _Last, const _Ty% _Val);
template<class _FwdIt, class _Ty, class _Pr> inline
bool binary_search(_FwdIt _First, _FwdIt _Last,const _Ty% _Val, _Pr _Pred);
该算法对已经排好序的序列从_fist到_last范围内执行二分搜索，搜索值_val。如果找到了_val将返回true，否则，返回false。第一种形式比较指定序列中的元亲是否相等。第二钟形式可指定自己的比较函数。
copy
template<class _InIt, class _OutIt> inline
_OutIt copy(_InIt _First, _InIt _Last, _OutIt _Dest);
copy()算法复制从_first开始到_last结束的序列．并将结果放入_DestBeg所指向的序列中，它返回指向结果序列结尾的指针，要复制的范围一定不能与_DestBeg重叠。返回迭代器为_DestEnd+(_Last-_First)。
count
template<class _InIt, class _Ty> inline
typename iterator_traits<_InIt>::difference_type
count(_InIt _First, _InIt _Last, const _Ty% _Val);
返回序列中从_First处开始到_Last处结束范围内与_Val匹配的元素的个数。
count_if
template<class _InIt, class _Pr> inline
typename iterator_traits<_InIt>::difference_type
count_if(_InIt _First, _InIt _Last, _Pr _Pred);
返回序列中从start处开始到end处结束范围内使一元谓词_Pred返回true的元素个数。
equal
template<class _InIt1, class _InIt2> inline
bool equal(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2);
template<class _InIt1, class _InIt2, class _Pr> inline
bool equal(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _Pr _Pred);
equal确定两个范围足否相同。算法将把_First1和_Last1所决定的范围与_First2所指向的序列进行比较。如果两者相同，将返回true。否则，将返回false。第二种形式允许指定二元谓词来确定两个元素是否相等。
equal_range
template<class _FwdIt, class _Ty> inline
_PAIR_TYPE(_FwdIt) equal_range(_FwdIt _First, _FwdIt _Last, const _Ty% _Val);
template<class _FwdIt, class _Ty, class _Pr> inline
_PAIR_TYPE(_FwdIt) equal_range(_FwdIt _First, _FwdIt _Last,const _Ty% _Val, _Pr _Pred);
该算法返回一个范围，在其中可插入元素到序列中而不会破坏排序顺序。_First和_Last指定了搜索范围，搜索值以_Val传递进来。要指定自己的搜索条件，可以自己指定比较函数_Comp。模板类pair为应用类，能够在其first和second成员中保存一对对象。
fill
template<class _FwdIt, class _Ty> inline
void fill(_FwdIt _First, _FwdIt _Last, const _Ty% _Val);
fill_n
template<class _OutIt, class _Diff, class _Ty> inline
void fill_n(_OutIt _First, _Diff _Count, const _Ty% _Val);
fill()和fill_n()算法使用val指定的值填充一个范围。对于fill()，范围是通过start
和end指定的，而对于fill_n()，范围从_First开始,包含_Count个元素。
find
template<class _InIt, class _Ty> inline
_InIt find(_InIt _First, _InIt _Last, const _Ty% _Val);
find()算法从 _First到_Last的范围中搜索_Val值。它返回指向所找到的第一个元素的迭代器。如果没有找到这样的元素．将返问指向_Last的迭代器。
find_end
template<class _FwdIt1, class _FwdIt2> inline
_FwdIt1 find_end(_FwdIt1 _First1, _FwdIt1 _Last1,_FwdIt2 _First2, _FwdIt2 _Last2);
template<class _FwdIt1, class _FwdIt2, class _Pr> inline
_FwdIt1 find_end(_FwdIt1 _First1, _FwdIt1 _Last1, _FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred);
该算法从[_First1, _Last1)范围内查找出[_First2, _Last2)定义的子序列。如果找到这样的序列，函数将返回指向范围中最后一个子序列中第一个一个元素的迭代器。否则，返回迭代器_Last1。第二种形式可指定确定元素何时匹配的二元谓词。
find_first_of
template<class _FwdIt1, class _FwdIt2> inline
_FwdIt1 find_first_of(_FwdIt1 _First1, _FwdIt1 _Last1,_FwdIt2 _First2, _FwdIt2 _Last2);
template<class _FwdIt1, class _FwdIt2, class _Pr> inline
_FwdIt1 find_first_of(_FwdIt1 _First1, _FwdIt1 _Last1,_FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred);
find_if
template<class _InIt, class _Pr> inline
_InIt find_if(_InIt _First, _InIt _Last, _Pr _Pred);
从[_First,_Last)的范围中搜索使一元谓词_Pred返回true的元素。它返回指向满足条件的第—个元素的选代器。如果序列中没有这样的值，算法将返回指向_Last的这代器。
for_each
template<class _InIt, class _Fn1> inline
_Fn1 for_each(_InIt _First, _InIt _Last, _Fn1 _Func);
for_each 算法将范围 [first, last) 中的每个元素中调用函数 _Func，并返回输入的参数。
generate
template<class _FwdIt, class _Fn0> inline
void generate(_FwdIt _First, _FwdIt _Last, _Fn0 _Func);
generate_n
template<class _OutIt, class _Diff, class _Fn0> inline
void generate_n(_OutIt _Dest, _Diff _Count, _Fn0 _Func);
算法generate和generate_n为一个范围中的元素分配由生成器函数返回的值。对于generate()，范围_First和_Lastd指定的。对于generate_n()，范围_First处开始，并包含了num个元素。生成器函数是通过_Gen传递进来的，它没有任何参数。
includes
template<class _InIt1, class _InIt2> inline
bool includes(_InIt1 _First1, _InIt1 _Last1,_InIt2 _First2, _InIt2 _Last2);
template<class _InIt1, class _InIt2, class _Pr> inline
bool includes(_InIt1 _First1, _InIt1 _Last1,_InIt2 _First2, _InIt2 _Last2, _Pr _Pred);
includes用来确定由_First1和_Last1定义的已排好序的序列是否包括由_First2和_Last2所定义的已排好序的序列中的所有元素。如果都包括，它返回true,否则算法返回false。在第二种形式中，可指定确定两个元素大小关系的比较函数。
iter_swap
template<class _FwdIt1, class _FwdIt2> inline
void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right);
将它的两个迭代器参数指向的值进行交换。
lexicographical_compare
template<class _InIt1, class _InIt2> inline
bool lexicographical_compare(_InIt1 _First1, _InIt1 _Last1,_InIt2 _First2, _InIt2 _Last2);
template<class _InIt1, class _InIt2, class _Pr> inline
bool lexicographical_compare(_InIt1 _First1, _InIt1 _Last1,_InIt2 _First2, _InIt2 _Last2, _Pr _Pred);
按字母表顺序将_First1和_Last1定义的序列_First2和_Last22所定义的序列进行比较。如果第—个序列按字典顺厅来说小丁第二个（换句话说．如果按字典顺序第一个序列在第二个之前)．则返回true。在第二种形式中，可指定确定两个元素大小关系的比较函数。
lower_bound
template<class _FwdIt, class _Ty> inline
_FwdIt lower_bound(_FwdIt _First, _FwdIt _Last, const _Ty% _Val);
template<class _FwdIt, class _Ty, class _Pr> inline
_FwdIt lower_bound(_FwdIt _First, _FwdIt _Last,const _Ty% _Val, _Pr _Pred);
该算法在start和end定义的序列中查找值<=val的第一个元素。它返回指向此点的迭代器。在第二种形式中，可指定确定两个元素大小关系的比较函数。
max
template<class _Ty> inline
const _Ty max(const _Ty% _Left, const _Ty% _Right);
template<class _Ty, class _Pr> inline
const _Ty max(const _Ty% _Left, const _Ty% _Right, _Pr _Pred);
返回两个数中最大的一个值 。在第二种形式中，可指定确定两个元素大小关系的比较函数。
max_element
template<class _FwdIt> inline
_FwdIt max_element(_FwdIt _First, _FwdIt _Last);
template<class _FwdIt, class _Pr> inline
_FwdIt max_element(_FwdIt _First, _FwdIt _Last, _Pr _Pred);
返回指向从start到end的范围中最大元素的选代器。在第二种形式中，可指定确定两个元素大小关系的比较函数。
merge
template<class _InIt1, class _InIt2, class _OutIt> inline
_OutIt merge(_InIt1 _First1, _InIt1 _Last1,_InIt2 _First2, _InIt2 _Last2, _OutIt _Dest);
template<class _InIt1, class _InIt2, class _OutIt, class _Pr> inline
_OutIt merge(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred);
merge算法将两个已排序的序列合并起来，并将结果放入第三个序列中。要合并的序列是通过_First1、_Last1和_First2、_Last2定义的，结果放入_Result指向的序列。算法返回指向结果序列结尾的迭代器。在第二种形式中，可指定确定两个元素大小关系的比较函数。
next_permutation
template<class _BidIt> inline
bool next_permutation(_BidIt _First, _BidIt _Last);
template<class _BidIt, class _Pr> inline
bool next_permutation(_BidIt _First, _BidIt _Last, _Pr _Pred);
该算法构造一个序列的下一个排列。在生成此排列时，假定从低到高有序的序列代表第一个排列。如果下一个排列不存在，该函数将对序列进行排序，使其变为相应的第一个排列，并返回false。否则，算法返回true。在第二种形式中，可指定确定两个元素大小关系的比较函数。
nth_element
template<class _RanIt> inline
void nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last);
template<class _RanIt, class _Pr> inline
void nth_element(_RanIt _First, _RanIt _Nth, _RanIt _Last, _Pr _Pred);
该算法对从_First到_Last的序列进行排列，使所有小于_Nth的元索都位于_Nth之前，所有大于_Nth的元素都位丁_Nth之后。在第二种形式中，可指定确定两个元素大小关系的比较函数。
partial_sort
template<class _RanIt> inline
void partial_sort(_RanIt _First, _RanIt _Mid, _RanIt _Last);
template<class _RanIt, class _Pr> inline
void partial_sort(_RanIt _First, _RanIt _Mid, _RanIt _Last,_Pr _Pred);
该算法对_First和_Last定义的序列进行排列，但是，在执行此算法之后，只有从First到_SortEnd范围内的元素是有序的。在第二种形式中，可指定确定两个元素大小关系的比较函数。
partial_sort_copy
template<class _InIt, class _RanIt> inline
_RanIt partial_sort_copy(_InIt _First1, _InIt _Last1,_RanIt _First2, _RanIt _Last2);
template<class _InIt, class _RanIt, class _Pr> inline
_RanIt partial_sort_copy(_InIt _First1, _InIt _Last1,_RanIt _First2, _RanIt _Last2, _Pr _Pred);
该算法对_First1到_Last1的范围进行排序，并复制尽量多的元素到_First2和_Last2定义的结果序列中，它返回指向复制到结果序列中最后—个元素的迭代器。在第二种形式中，可指定确定两个元素大小关系的比较函数。
partion
template<class _BidIt, class _Pr> inline
_BidIt partition(_BidIt _First, _BidIt _Last, _Pr _Pred);
partion()算法对_First和_Last定义的序列进行排列，这样，所有使_Comph所指定谓词返回true的元素均位于所有使此谓词返回false的元素之前。它返回指向第一个使指定谓词为false的元素的迭代器。
prev_permutation
template<class _BidIt> inline
bool prev_permutation(_BidIt _First, _BidIt _Last);
template<class _BidIt, class _Pr> inline
bool prev_permutation(_BidIt _First, _BidIt _Last, _Pr _Pred);
该算法构造一个序列的上一个排列。在生成此排列时，假定从低到高有序的序列代表第一个排列。如果上一个排列不存在，该函数将对序列进行排序，使其变为最后一个排列，并返回false。否则，算法返回true。在第二种形式中，可指定确定两个元素大小关系的比较函数。
random_shuffle
template<class _RanIt> inline
void random_shuffle(_RanIt _First, _RanIt _Last);
template<class _RanIt, class _Fn1> inline
void random_shuffle(_RanIt _First, _RanIt _Last, _Fn1% _Func);
示例：
#include <ctime>
int myrand(int n)
{
srand((int)time(0));
return rand() % n;
}
int main( ) {
using namespace std;
vector <int> v1;
vector <int>::iterator Iter1, Iter2;
int i;
for ( i = 1 ; i <= 9 ; i++ )
v1.push_back( i );
random_shuffle( v1.begin( ), v1.end( ));
cout << "The original version of vector v1 is: ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Shuffled once
random_shuffle( v1.begin( ), v1.end( ),myrand);
cout << "Vector v1 after one shuffle is: ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
}
输出结果：
The original version of vector v1 is: ( 9 2 7 3 1 6 8 4 5 ).
Vector v1 after one shuffle is: ( 1 9 6 7 2 5 4 8 3 ).
remove
template<class _FwdIt, class _Ty> inline
_FwdIt remove(_FwdIt _First, _FwdIt _Last, const _Ty% _Val);
remove_if
template<class _FwdIt, class _Pr> inline
_FwdIt remove_if(_FwdIt _First, _FwdIt _Last, _Pr _Pred);
remove_copy
template<class _InIt, class _OutIt, class _Ty> inline
_OutIt remove_copy(_InIt _First, _InIt _Last,_OutIt _Dest, const _Ty% _Val);
remove_copy_if
template<class _InIt, class _OutIt, class _Pr> inline
_OutIt remove_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest,_Pr _Pred);
1.remove()从指定范围中删除值等于val的元素，它返回指向剩余元素结尾的迭代器。
2.remove_if从指定范围中删除使谓词_Pred返回true的元素，它返回指向剩余元素结尾的迭代器。
3.remove_copy从指定范围中复制值等丁val的元素，并将结果放入result所指向的序列中：它返回指向结果序列结尾的迭代器。
4.remove_copy_if从指定范围中复制使谓词_Pred返回true的元素，并将结果放入result所指向的序列中：它返回指向结果序列结尾的迭代器。
replace
template<class ForwardIterator, class Type>
template<class _FwdIt, class _Ty> inline
void replace(_FwdIt _First, _FwdIt _Last,const _Ty% _Oldval, const _Ty% _Newval);
replace_if
template<class _FwdIt, class _Pr, class _Ty> inline
void replace_if(_FwdIt _First, _FwdIt _Last, _Pr _Pred,const _Ty% _Val);
replace_copy
template<class _InIt, class _OutIt, class _Ty> inline
_OutIt replace_copy(_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty% _Oldval, const _Ty% _Newval);
replace_copy_if
template<class _InIt, class _OutIt, class _Pr, class _Ty> inline
_OutIt replace_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest,_Pr _Pred, const _Ty% _Val);
1.在指定的范围中，replace使用值为new的元素替换值为old的元素。
2.在指定的范围中，replace_if使用值为new的元素替换使谓词_Pred返回true的元素。
3.在指定的范围中，replace_copy复制元素到_Result中。在此过程中，它使用值为new的元素替换值为01d的元素。原始范围保持不变。算法返回指向_Result结尾的迭代器。
4.在指定的范围中，replace_copy_if复制元素到_Result中。在此过程中，它使用值为new的元素替换使谓词_Pred返回true的元素。原始范围保持不变。算法返回指向_Result结尾的迭代器。
reverse
template<class _BidIt> inline
void reverse(_BidIt _First, _BidIt _Last);
reverse_copy
template<class _BidIt, class _OutIt> inline
_OutIt reverse_copy(_BidIt _First, _BidIt _Last, _OutIt _Dest);
1.reverse()算法反转由_First和_Last所指定范围的顺序。
2.reverse_copy()算法以逆序复制_First和_Last所指定的范围，并将结果放入_Result中。它返回指_Result结尾的迭代器。
rotate
template<class _FwdIt> inline
void rotate(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last);
rotate_copy
template<class _FwdIt, class _OutIt> inline
_OutIt rotate_copy(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last,_OutIt _Dest);
1.rotate()将_First和_Last所指定范围中的元素向左旋转，使mid指定的元素成为新的首元素。
2.rotate_copy()复制_First和_Last所指定的范围，并将结果存储到_Result中，在此过程中，它会将元素向左旋转，使得mid指定的元素成为新的首元素。它返回指向_Result结尾的迭代器。
search
template<class _FwdIt1, class _FwdIt2> inline
_FwdIt1 search(_FwdIt1 _First1, _FwdIt1 _Last1,_FwdIt2 _First2, _FwdIt2 _Last2);
template<class _FwdIt1, class _FwdIt2, class _Pr> inline
_FwdIt1 search(_FwdIt1 _First1, _FwdIt1 _Last1,_FwdIt2 _First2, _FwdIt2 _Last2, _Pr _Pred);
search()搜索序列的子序列。被搜索的序列由_First1和_Last1定义，而要搜索的子序列则由_First2和_Last2指定。如果找到了这样的子序列，将返指向其开头的迭代器。否则，返回_Last1。在第二种形式中，可指定确定两个元素何时相等的二元谓词。
search_n
template<class _FwdIt1, class _Diff2, class _Ty> inline
_FwdIt1 search_n(_FwdIt1 _First1, _FwdIt1 _Last1,_Diff2 _Count, const _Ty& _Val);
template<class _FwdIt1, class _Diff2, class _Ty, class _Pr> inline
_FwdIt1 search_n(_FwdIt1 _First1, _FwdIt1 _Last1,_Diff2 _Count, const _Ty& _Val, _Pr _Pred);
search_n是从一个[_first1, _last1)范围的数据中查找有_Count个连续的数据，每个数据都和_Val相同。如果找到,它将返回查找到的第一个数据的迭代指针，如果找不到，则返回_last1 。在第二种形式中，可指定确定两个元素何时相等的二元谓词。
set_difference
template<class _InIt1, class _InIt2, class _OutIt> inline
_OutIt set_difference(_InIt1 _First1, _InIt1 _Last1,_InIt2 _First2, _InIt2 _Last2,_OutIt _Dest);
template<class _InIt1, class _InIt2, class _OutIt, class _Pr> inline
_OutIt set_difference(_InIt1 _First1, _InIt1 _Last1,_InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred);
该算法生成包含两个有序的集合之差的序列。这两个集合分别由_First1、_Last1和_First2、_Last2定义。换句话说，要将_First2和_Last2定义的集合从_First1、_Last1所定义的集合中减掉。结果是有序的，并放_Result中。算法返回指向_Result结尾的迭代器。第二种形式中可指定决定两个元素大小关系的比较函数。
注意：两个序列必须是有序的。
set_intersection
template<class _InIt1, class _InIt2, class _OutIt> inline
_OutIt set_intersection(_InIt1 _First1, _InIt1 _Last1,_InIt2 _First2, _InIt2 _Last2, _OutIt _Dest);
template<class _InIt1, class _InIt2, class _OutIt, class _Pr> inline
_OutIt set_intersection(_InIt1 _First1, _InIt1 _Last1,_InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred);
生成包含两个有序集合的交集的序列。这两个集合分别由_First1、_Last1和_First2、_Last2定义。结呆序列包含了两个集合共有的元案。结果是有序的，并放_Result中。算法返回指向_Result结尾的迭代器。第二种形式中可指定决定两个元素大小关系的比较函数。
注意：两个序列必须是有序的。
set_symmetric_difference
template<class _InIt1, class _InIt2, class _OutIt> inline
_OutIt set_symmetric_difference(_InIt1 _First1, _InIt1 _Last1,_InIt2 _First2, _InIt2 _Last2, _OutIt _Dest);
template<class _InIt1, class _InIt2, class _OutIt, class _Pr> inline
_OutIt set_symmetric_difference(_InIt1 _First1, _InIt1 _Last1,_InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred);
该算法生成包含两个有序集合对称差的序列。这两个集合分别由_First1、_Last1和_First2、_Last2定义。换句话说，。结果集合只包含不为两个集合共有的元素。结果是有序的，并放_Result中。算法返回指向_Result结尾的迭代器。第二种形式中可指定决定两个元素大小关系的比较函数。
注意：两个序列必须是有序的。
set_union
template<class _InIt1, class _InIt2, class _OutIt> inline
_OutIt set_union(_InIt1 _First1, _InIt1 _Last1,_InIt2 _First2, _InIt2 _Last2, _OutIt _Dest);
template<class _InIt1, class _InIt2, class _OutIt, class _Pr> inline
_OutIt set_union(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2, _InIt2 _Last2, _OutIt _Dest, _Pr _Pred);
该算法生成包含两个有序集合的并集的序列。这两个集合分别由_First1、_Last1和_First2、_Last2定义。结呆序列包含了两个集合中的所有元案。结果是有序的，并放_Result中。算法返回指向_Result结尾的迭代器。第二种形式中可指定决定两个元素大小关系的比较函数。
注意：两个序列必须是有序的。
sort
template<class _RanIt> inline
void sort(_RanIt _First, _RanIt _Last);
template<class _RanIt, class _Pr> inline
void sort(_RanIt _First, _RanIt _Last, _Pr _Pred);
sort()算法对_First和_Last指定的范围进行排序。第二种形式中可指定决定两个元素大小关系的比较函数。
stable_partition
template<class _BidIt, class _Pr> inline
_BidIt stable_partition(_BidIt _First, _BidIt _Last, _Pr _Pred);
该算法对_First和_Last定义的序列进行排列，使得所有使_Pred谓词返回true的元素．均位于便谓词返回false的元素之前。划分是稳定的，这表示序列的相对顺序是预定的。算法返回指向使谓词返回false的第一个元素的迭代器。
stable_sort
template<class _BidIt> inline
void stable_sort(_BidIt _First, _BidIt _Last);
template<class _BidIt, class _Pr> inline
void stable_sort(_BidIt _First, _BidIt _Last, _Pr _Pred);
算法对_First和_Last指定的范围进行排序,但排序是稳定的，这表示相等的元素不会重新排列。第二种形式中可指定决定两个元素大小关系的比较函数。
swap
template<class Type>
void swap(Type& _Left, Type& _Right);
交换由_Left和_Right引用的值。
swap_ranges
template<class _FwdIt1, class _FwdIt2> inline
_FwdIt2 swap_ranges(_FwdIt1 _First1, _FwdIt1 _Last1,_FwdIt2 _First2);
该算法将_First1和_Last1所指定范围中的元素与序列中从_First2处开始的元素相互交换，它返回指向_First2所指定序列结尾的指针。注意，对于交换部分的元素，First1和_Last1所指定范围中的元素个数必须不大于从_First2处开始的元素个数。
transform
template<class _InIt, class _OutIt, class _Fn1> inline
_OutIt transform(_InIt _First, _InIt _Last, _OutIt _Dest,_Fn1 _Func);
template<class _InIt1, class _InIt2, class _OutIt, class _Fn2> inline
_OutIt transform(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2,_OutIt _Dest, _Fn2 _Func);
该算法将一个函数应用到元素范围，并将结果存储到_Result中，在第一种形式中．范围是由_First1和_Last1指定的．所应用的函数由_Func指定。这个函数使用自己的参数接收一个元素的值，并必须返回元素的转换结果。
在第二钟形式中，转换是通过二元运算符函数执行的，函数使用第一个参数从要转换的序列中接收一个元素的值，并用第二个参数接收第二个序列中的—个元素。
两个版本都返回指向结果序列结尾的迭代器。
示例：
// alg_transform.cpp
// compile with: /EHsc
#include <vector>
#include <algorithm>
#include <functional>
#include <iostream>
// The function object multiplies an element by a Factor
template <class Type>
class MultValue
{
private:
Type Factor; // The value to multiply by
public:
// Constructor initializes the value to multiply by
MultValue ( const Type& _Val ) : Factor ( _Val ) {
}
// The function call for the element to be multiplied
Type operator ( ) ( Type& elem ) const
{
return elem * Factor;
}
};
int main( )
{
using namespace std;
vector <int> v1, v2 ( 7 ), v3 ( 7 );
vector <int>::iterator Iter1, Iter2 , Iter3;
// Constructing vector v1
int i;
for ( i = -4 ; i <= 2 ; i++ )
{
v1.push_back( i );
}
cout << "Original vector v1 = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Modifying the vector v1 in place
transform (v1.begin ( ) , v1.end ( ) , v1.begin ( ) , MultValue<int> ( 2 ) );
cout << "The elements of the vector v1 multiplied by 2 in place gives:"
<< "/n v1mod = ( " ;
for ( Iter1 = v1.begin( ) ; Iter1 != v1.end( ) ; Iter1++ )
cout << *Iter1 << " ";
cout << ")." << endl;
// Using transform to multiply each element by a factor of 5
transform ( v1.begin ( ) , v1.end ( ) , v2.begin ( ) , MultValue<int> ( 5 ) );
cout << "Multiplying the elements of the vector v1mod/n "
<< "by the factor 5 & copying to v2 gives:/n v2 = ( " ;
for ( Iter2 = v2.begin( ) ; Iter2 != v2.end( ) ; Iter2++ )
cout << *Iter2 << " ";
cout << ")." << endl;
// The second version of transform used to multiply the
// elements of the vectors v1mod & v2 pairwise
transform ( v1.begin ( ) , v1.end ( ) , v2.begin ( ) , v3.begin ( ) ,
multiplies <int> ( ) );
cout << "Multiplying elements of the vectors v1mod and v2 pairwise "
<< "gives:/n v3 = ( " ;
for ( Iter3 = v3.begin( ) ; Iter3 != v3.end( ) ; Iter3++ )
cout << *Iter3 << " ";
cout << ")." << endl;
}
输出结果：
Original vector v1 = ( -4 -3 -2 -1 0 1 2 ).
The elements of the vector v1 multiplied by 2 in place gives:
v1mod = ( -8 -6 -4 -2 0 2 4 ).
Multiplying the elements of the vector v1mod
by the factor 5 & copying to v2 gives:
v2 = ( -40 -30 -20 -10 0 10 20 ).
Multiplying elements of the vectors v1mod and v2 pairwise gives:
v3 = ( 320 180 80 20 0 20 80 ).
注意：v2.size()>=v1.size();
unique
template<class _FwdIt> inline
_FwdIt unique(_FwdIt _First, _FwdIt _Last);
template<class _FwdIt, class _Pr> inline
_FwdIt unique(_FwdIt _First, _FwdIt _Last, _Pr _Pred);
该算法从指定范围删除连续的重复元素。在第二种形式中，可指定确定两个元素何时相等的二元谓词。unique返回指向范围结尾的迭代器。
unique_copy
template<class _InIt, class _OutIt> inline
_OutIt unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest);
template<class _InIt, class _OutIt, class _Pr> inline
_OutIt unique_copy(_InIt _First, _InIt _Last, _OutIt _Dest,_Pr _Pred);
该算法复制由_First和_Last指定的范围，并删除其中的连续重复元素。结果放入_Result中。在第二种形式中，可指定确定两个元素何时相等的二元谓词。算法返回指向范围结尾的迭代器。
upper_bound
template<class _FwdIt, class _Ty> inline
_FwdIt upper_bound(_FwdIt _First, _FwdIt _Last, const _Ty% _Val);
template<class _FwdIt, class _Ty, class _Pr> inline
_FwdIt upper_bound(_FwdIt _First, _FwdIt _Last,const _Ty% _Val, _Pr _Pred);
该算法在_First和_Last定义的序列中查找大于_Val的第一个元素的位置．它返回指向此位置的迭代器，在第二种形式中，可指定确定两个元素大小关系的比较函数。