STL 算法
STL算法概述
简单介绍:
STL算法部分主要由头文件<algorithm>,<numeric>,<functional>组成。要使用 STL中的算法函数必须包括头文件<algorithm>。对于数值算法须包括<numeric>,<functional>中则定义了一些模板类,用来声明函数对象
注意:
编译器无法检測出所传递的迭代器是一个无效形式的迭代器,当然也无法给出算法函数错误的提示,由于迭代器并非真实的类别,它仅仅是传递给函数模板的一种參数格式而已
算法的一些限制:
1、保证迭代器有效
2、区间必须有足够的空间
STL採用覆盖模式而非安插模式。
STL中算法分类:
- 操作对象
- 直接改变容器的内容
- 将原容器的内容复制一份,改动其副本,然后传回该副本
- 功能:
- 非可变序列算法 指不直接改动其所操作的容器内容的算法
- 可变序列算法 指能够改动它们所操作的容器内容的算法
- 排序算法 包含对序列进行排序和合并的算法、搜索算法以及有序序列上的集合操作
- 数值算法 对容器内容进行数值计算
查找算法(13个):推断容器中是否包括某个值
函数名 | 头文件 | 函数功能 |
adjacent_find | <algorithm> | 在iterator对标识元素范围内,查找一对相邻反复元素,找到则返回指向这对元素的第一个元素的ForwardIterator .否则返回last.重载版本号使用输入的二元操作符取代相等的推断 |
函数原形 | template<class FwdIt> FwdIt adjacent_find(FwdIt first, FwdIt last); | |
template<class FwdIt, class Pred> FwdIt adjacent_find(FwdIt first, FwdIt last, Pred pr); | ||
binary_search | <algorithm> | 在有序序列中查找value,找到返回true.重载的版本号有用指定的比較函数对象或函数指针来推断相等 |
函数原形 | template<class FwdIt, class T> bool binary_search(FwdIt first, FwdIt last, const T& val); | |
template<class FwdIt, class T, class Pred> bool binary_search(FwdIt first, FwdIt last, const T& val,Pred pr); | ||
count | <algorithm> | 利用等于操作符,把标志范围内的元素与输入值比較,返回相等元素个数 |
函数原形 | template<class InIt, class Dist> size_t count(InIt first, InIt last,const T& val, Dist& n); | |
count_if | <algorithm> | 利用输入的操作符,对标志范围内的元素进行操作,返回结果为true的个数 |
函数原形 | template<class InIt, class Pred, class Dist> size_t count_if(InIt first, InIt last, Pred pr); | |
equal_range | <algorithm> | 功能类似equal,返回一对iterator,第一个表示lower_bound。第二个表示upper_bound |
函数原形 | template<class FwdIt, class T> pair<FwdIt, FwdIt> equal_range(FwdIt first, FwdIt last,const T& val); | |
template<class FwdIt, class T, class Pred> pair<FwdIt, FwdIt> equal_range(FwdIt first, FwdIt last,const T& val, Pred pr); | ||
find | <algorithm> | 利用底层元素的等于操作符,对指定范围内的元素与输入值进行比較.当匹配时,结束搜索,返回该元素的一个InputIterator |
函数原形 | template<class InIt, class T> InIt find(InIt first, InIt last, const T& val); | |
find_end | <algorithm> | 在指定范围内查找"由输入的另外一对iterator标志的第二个序列"的最后一次出现.找到则返回最后一对的第一个ForwardIterator,否则返回输入的"另外一对"的第一个ForwardIterator.重载版本号使用用户输入的操作符取代等于操作 |
函数原形 | template<class FwdIt1, class FwdIt2> FwdIt1 find_end(FwdIt1 first1, FwdIt1 last1,FwdIt2 first2, FwdIt2 last2); | |
template<class FwdIt1, class FwdIt2, class Pred> FwdIt1 find_end(FwdIt1 first1, FwdIt1 last1,FwdIt2 first2, FwdIt2 last2, Pred pr); | ||
find_first_of | <algorithm> | 在指定范围内查找"由输入的另外一对iterator标志的第二个序列"中随意一个元素的第一次出现。 重载版本号中使用了用户自己定义操作符 |
函数原形 | template<class FwdIt1, class FwdIt2> FwdIt1 find_first_of(FwdIt1 first1, FwdIt1 last1,FwdIt2 first2, FwdIt2 last2); | |
template<class FwdIt1, class FwdIt2, class Pred> FwdIt1 find_first_of(FwdIt1 first1, FwdIt1 last1,FwdIt2 first2, FwdIt2 last2, Pred pr); | ||
find_if | <algorithm> | 使用输入的函数取代等于操作符运行find |
template<class InIt, class Pred> InIt find_if(InIt first, InIt last, Pred pr); | ||
lower_bound | <algorithm> | 返回一个ForwardIterator,指向在有序序列范围内的能够插入指定值而不破坏容器顺序的第一个位置.重载函数使用自己定义比較操作 |
函数原形 | template<class FwdIt, class T> FwdIt lower_bound(FwdIt first, FwdIt last, const T& val); | |
template<class FwdIt, class T, class Pred> FwdIt lower_bound(FwdIt first, FwdIt last, const T& val, Pred pr); | ||
upper_bound | <algorithm> | 返回一个ForwardIterator,指向在有序序列范围内插入value而不破坏容器顺序的最后一个位置,该位置标志一个大于value的值.重载函数使用自己定义比較操作 |
函数原形 | template<class FwdIt, class T> FwdIt upper_bound(FwdIt first, FwdIt last, const T& val); | |
template<class FwdIt, class T, class Pred> FwdIt upper_bound(FwdIt first, FwdIt last, const T& val, Pred pr); | ||
search | <algorithm> | 给出两个范围,返回一个ForwardIterator,查找成功指向第一个范围内第一次出现子序列(第二个范围)的位置,查找失败指向last1,重载版本号使用自己定义的比較操作 |
函数原形 | template<class FwdIt1, class FwdIt2> FwdIt1 search(FwdIt1 first1, FwdIt1 last1,FwdIt2 first2, FwdIt2 last2); | |
template<class FwdIt1, class FwdIt2, class Pred> FwdIt1 search(FwdIt1 first1, FwdIt1 last1, FwdIt2 first2, FwdIt2 last2, Pred pr); | ||
search_n | <algorithm> | 在指定范围内查找val出现n次的子序列。重载版本号使用自己定义的比較操作 |
函数原形 | template<class FwdIt, class Dist, class T> FwdIt search_n(FwdIt first, FwdIt last,Dist n, const T& val); | |
template<class FwdIt, class Dist, class T, class Pred> FwdIt search_n(FwdIt first, FwdIt last,Dist n, const T& val, Pred pr); |
堆算法(4个)
函数名 | 头文件 | 函数功能 |
make_heap | <algorithm> | 把指定范围内的元素生成一个堆。 重载版本号使用自己定义比較操作 |
函数原形 | template<class RanIt> void make_heap(RanIt first, RanIt last); | |
template<class RanIt, class Pred> void make_heap(RanIt first, RanIt last, Pred pr); | ||
pop_heap | <algorithm> | 并不真正把最大元素从堆中弹出,而是又一次排序堆。它把first和last-1交换,然后又一次生成一个堆。 可使用容器的back来訪问被"弹出"的元素或者使用pop_back进行真正的删除。重载版本号使用自己定义的比較操作 |
函数原形 | template<class RanIt> void pop_heap(RanIt first, RanIt last); | |
template<class RanIt, class Pred> void pop_heap(RanIt first, RanIt last, Pred pr); | ||
push_heap | <algorithm> | 如果first到last-1是一个有效堆,要被增加到堆的元素存放在位置last-1,又一次生成堆。在指向该函数前,必须先把元素插入容器后。重载版本号使用指定的比較操作 |
函数原形 | template<class RanIt>void push_heap(RanIt first, RanIt last); | |
template<class RanIt, class Pred> void push_heap(RanIt first, RanIt last, Pred pr); | ||
sort_heap | <algorithm> | 对指定范围内的序列又一次排序。它如果该序列是个有序堆。重载版本号使用自己定义比較操作 |
函数原形 | template<class RanIt> void sort_heap(RanIt first, RanIt last); | |
template<class RanIt, class Pred> void sort_heap(RanIt first, RanIt last, Pred pr); |
关系算法(8个)
函数名 | 头文件 | 函数功能 |
equal | <algorithm> | 假设两个序列在标志范围内元素都相等。返回true。重载版本号使用输入的操作符取代默认的等于操作符 |
函数原形 | template<class InIt1, class InIt2> bool equal(InIt1 first, InIt1 last, InIt2 x); | |
template<class InIt1, class InIt2, class Pred> bool equal(InIt1 first, InIt1 last, InIt2 x, Pred pr); | ||
includes | <algorithm> | 推断第一个指定范围内的全部元素是否都被第二个范围包括,使用底层元素的<操作符,成功返回true。 重载版本号使用用户输入的函数 |
函数原形 | template<class InIt1, class InIt2> bool includes(InIt1 first1, InIt1 last1,InIt2 first2, InIt2 last2); | |
template<class InIt1, class InIt2, class Pred> bool includes(InIt1 first1, InIt1 last1,InIt2 first2, InIt2 last2, Pred pr); | ||
lexicographical_compare | <algorithm> | 比較两个序列。 重载版本号使用用户自己定义比較操作 |
函数原形 | template<class InIt1, class InIt2> bool lexicographical_compare(InIt1 first1, InIt1 last1,InIt2 first2, InIt2 last2); | |
template<class InIt1, class InIt2, class Pred> bool lexicographical_compare(InIt1 first1, InIt1 last1,InIt2 first2, InIt2 last2, Pred pr); | ||
max | <algorithm> | 返回两个元素中较大一个。重载版本号使用自己定义比較操作 |
函数原形 | template<class T> const T& max(const T& x, const T& y); | |
template<class T, class Pred> const T& max(const T& x, const T& y, Pred pr); | ||
max_element | <algorithm> | 返回一个ForwardIterator。指出序列中最大的元素。 重载版本号使用自己定义比較操作 |
函数原形 | template<class FwdIt> FwdIt max_element(FwdIt first, FwdIt last); | |
template<class FwdIt, class Pred> FwdIt max_element(FwdIt first, FwdIt last, Pred pr); | ||
min | <algorithm> | 返回两个元素中较小一个。 重载版本号使用自己定义比較操作 |
函数原形 | template<class T> const T& min(const T& x, const T& y); | |
template<class T, class Pred> const T& min(const T& x, const T& y, Pred pr); | ||
min_element | <algorithm> | 返回一个ForwardIterator,指出序列中最小的元素。 重载版本号使用自己定义比較操作 |
函数原形 | template<class FwdIt> FwdIt min_element(FwdIt first, FwdIt last); | |
template<class FwdIt, class Pred> FwdIt min_element(FwdIt first, FwdIt last, Pred pr); | ||
mismatch | <algorithm> | 并行比較两个序列,指出第一个不匹配的位置。返回一对iterator,标志第一个不匹配元素位置。 假设都匹配,返回每一个容器的last。重载版本号使用自己定义的比較操作 |
函数原形 | template<class InIt1, class InIt2> pair<InIt1, InIt2> mismatch(InIt1 first, InIt1 last, InIt2 x); | |
template<class InIt1, class InIt2, class Pred> pair<InIt1, InIt2> mismatch(InIt1 first, InIt1 last, InIt2 x, Pred pr); |
集合算法(4个)
函数名 | 头文件 | 函数功能 |
set_union | <algorithm> | 构造一个有序序列,包括两个序列中全部的不反复元素。重载版本号使用自己定义的比較操作 |
函数原形 | template<class InIt1, class InIt2, class OutIt> OutIt set_union(InIt1 first1, InIt1 last1, InIt2 first2, InIt2 last2, OutIt x); | |
template<class InIt1, class InIt2, class OutIt, class Pred> OutIt set_union(InIt1 first1, InIt1 last1,InIt2 first2, InIt2 last2,OutIt x, Pred pr); | ||
set_intersection | <algorithm> | 构造一个有序序列,当中元素在两个序列中都存在。 重载版本号使用自己定义的比較操作 |
函数原形 | template<class InIt1, class InIt2, class OutIt> OutIt set_intersection(InIt1 first1, InIt1 last1,InIt2 first2, InIt2 last2, OutIt x); | |
template<class InIt1, class InIt2, class OutIt, class Pred> OutIt set_intersection(InIt1 first1, InIt1 last1,InIt2 first2,InIt2 last2, OutIt x, Pred pr); | ||
set_difference | <algorithm> | 构造一个有序序列。该序列仅保留第一个序列中存在的而第二个中不存在的元素。 重载版本号使用自己定义的比較操作 |
函数原形 | template<class InIt1, class InIt2, class OutIt> OutIt set_difference(InIt1 first1, InIt1 last1,InIt2 first2, InIt2 last2, OutIt x); | |
template<class InIt1, class InIt2, class OutIt, class Pred> OutIt set_difference(InIt1 first1, InIt1 last1, InIt2 first2, InIt2 last2, OutIt x, Pred pr); | ||
set_symmetric_difference | <algorithm> | 构造一个有序序列,该序列取两个序列的对称差集(并集-交集) |
函数原形 | template<class InIt1, class InIt2, class OutIt> OutIt set_symmetric_difference(InIt1 first1, InIt1 last1, InIt2 first2, InIt2 last2, OutIt x); | |
template<class InIt1, class InIt2, class OutIt, class Pred> OutIt set_symmetric_difference(InIt1 first1, InIt1 last1, InIt2 first2, InIt2 last2, OutIt x, Pred pr); |
排列组合算法(2个)提供计算给定集合按一定顺序的全部可能排列组合
函数名 | 头文件 | 函数功能 |
next_permutation | <algorithm> | 取出当前范围内的排列,并又一次排序为下一个排列。重载版本号使用自己定义的比較操作 |
函数原形 | template<class BidIt> bool next_permutation(BidIt first, BidIt last); | |
template<class BidIt, class Pred> bool next_permutation(BidIt first, BidIt last, Pred pr); | ||
prev_permutation | <algorithm> | 取出指定范围内的序列并将它又一次排序为上一个序列。假设不存在上一个序列则返回false。重载版本号使用自己定义的比較操作 |
函数原形 | template<class BidIt> bool prev_permutation(BidIt first, BidIt last); | |
template<class BidIt, class Pred> bool prev_permutation(BidIt first, BidIt last, Pred pr); |
排序和通用算法(14个):提供元素排序策略
函数名 | 头文件 | 函数功能 |
inplace_merge | <algorithm> | 合并两个有序序列,结果序列覆盖两端范围。 重载版本号使用输入的操作进行排序 |
函数原形 | template<class BidIt> void inplace_merge(BidIt first, BidIt middle, BidIt last); | |
template<class BidIt, class Pred> void inplace_merge(BidIt first, BidIt middle, BidIt last, Pred pr); | ||
merge | <algorithm> | 合并两个有序序列。存放到还有一个序列。 重载版本号使用自己定义的比較 |
函数原形 | template<class InIt1, class InIt2, class OutIt> OutIt merge(InIt1 first1, InIt1 last1,InIt2 first2, InIt2 last2, OutIt x); | |
template<class InIt1, class InIt2, class OutIt, class Pred> OutIt merge(InIt1 first1, InIt1 last1,InIt2 first2, InIt2 last2, OutIt x, Pred pr); | ||
nth_element | <algorithm> | 将范围内的序列又一次排序,使全部小于第n个元素的元素都出如今它前面,而大于它的都出如今后面。重载版本号使用自己定义的比較操作 |
函数原形 | template<class RanIt> void nth_element(RanIt first, RanIt nth, RanIt last); | |
template<class RanIt, class Pred> void nth_element(RanIt first, RanIt nth, RanIt last, Pred pr); | ||
partial_sort | <algorithm> | 对序列做部分排序。被排序元素个数正好能够被放到范围内。重载版本号使用自己定义的比較操作 |
函数原形 | template<class RanIt> void partial_sort(RanIt first, RanIt middle, RanIt last); | |
template<class RanIt, class Pred> void partial_sort(RanIt first, RanIt middle, RanIt last, Pred pr); | ||
partial_sort_copy | <algorithm> | 与partial_sort类似。只是将经过排序的序列拷贝到还有一个容器 |
函数原形 | template<class InIt, class RanIt> RanIt partial_sort_copy(InIt first1, InIt last1,RanIt first2, RanIt last2); | |
template<class InIt, class RanIt, class Pred> RanIt partial_sort_copy(InIt first1, InIt last1,RanIt first2, RanIt last2, Pred pr); | ||
partition | <algorithm> | 对指定范围内元素又一次排序,使用输入的函数,把结果为true的元素放在结果为false的元素之前 |
函数原形 | template<class BidIt, class Pred> BidIt partition(BidIt first, BidIt last, Pred pr); | |
random_shuffle | <algorithm> | 对指定范围内的元素随机调整次序。重载版本号输入一个随机数产生操作 |
函数原形 | template<class RanIt> void random_shuffle(RanIt first, RanIt last); | |
template<class RanIt, class Fun> void random_shuffle(RanIt first, RanIt last, Fun& f); | ||
reverse | <algorithm> | 将指定范围内元素又一次反序排序 |
函数原形 | template<class BidIt> void reverse(BidIt first, BidIt last); | |
reverse_copy | <algorithm> | 与reverse类似,只是将结果写入还有一个容器 |
函数原形 | template<class BidIt, class OutIt> OutIt reverse_copy(BidIt first, BidIt last, OutIt x); | |
rotate | <algorithm> | 将指定范围内元素移到容器末尾,由middle指向的元素成为容器第一个元素 |
函数原形 | template<class FwdIt> void rotate(FwdIt first, FwdIt middle, FwdIt last); | |
rotate_copy | <algorithm> | 与rotate类似,只是将结果写入还有一个容器 |
函数原形 | template<class FwdIt, class OutIt> OutIt rotate_copy(FwdIt first, FwdIt middle, FwdIt last, OutIt x); | |
sort | <algorithm> | 以升序又一次排列指定范围内的元素。 重载版本号使用自己定义的比較操作 |
函数原形 | template<class RanIt> void sort(RanIt first, RanIt last); | |
template<class RanIt, class Pred> void sort(RanIt first, RanIt last, Pred pr); | ||
stable_sort | <algorithm> | 与sort类似,只是保留相等元素之间的顺序关系 |
函数原形 | template<class BidIt> void stable_sort(BidIt first, BidIt last); | |
template<class BidIt, class Pred> void stable_sort(BidIt first, BidIt last, Pred pr); | ||
stable_partition | <algorithm> | 与partition类似,只是不保证保留容器中的相对顺序 |
函数原形 | template<class FwdIt, class Pred> FwdIt stable_partition(FwdIt first, FwdIt last, Pred pr); |
删除和替换算法(15个)
函数名 | 头文件 | 函数功能 |
copy | <algorithm> | 复制序列 |
函数原形 | template<class InIt, class OutIt> OutIt copy(InIt first, InIt last, OutIt x); | |
copy_backward | <algorithm> | 与copy同样,只是元素是以相反顺序被拷贝 |
函数原形 | template<class BidIt1, class BidIt2> BidIt2 copy_backward(BidIt1 first, BidIt1 last, BidIt2 x); | |
iter_swap | <algorithm> | 交换两个ForwardIterator的值 |
函数原形 | template<class FwdIt1, class FwdIt2> void iter_swap(FwdIt1 x, FwdIt2 y); | |
remove | <algorithm> | 删除指定范围内全部等于指定元素的元素。 注意,该函数不是真正删除函数。内置函数不适合使用remove和remove_if函数 |
函数原形 | template<class FwdIt, class T> FwdIt remove(FwdIt first, FwdIt last, const T& val); | |
remove_copy | <algorithm> | 将全部不匹配元素拷贝到一个制定容器,返回OutputIterator指向被拷贝的末元素的下一个位置 |
函数原形 | template<class InIt, class OutIt, class T> OutIt remove_copy(InIt first, InIt last, OutIt x, const T& val); | |
remove_if | <algorithm> | 删除指定范围内输入操作结果为true的全部元素 |
函数原形 | template<class FwdIt, class Pred> FwdIt remove_if(FwdIt first, FwdIt last, Pred pr); | |
remove_copy_if | <algorithm> | 将全部不匹配元素复制到一个指定容器 |
函数原形 | template<class InIt, class OutIt, class Pred> OutIt remove_copy_if(InIt first, InIt last, OutIt x, Pred pr); | |
replace | <algorithm> | 将指定范围内全部等于vold的元素都用vnew取代 |
函数原形 | template<class FwdIt, class T> void replace(FwdIt first, FwdIt last,const T& vold, const T& vnew); | |
replace_copy | <algorithm> | 与replace类似。只是将结果写入还有一个容器 |
函数原形 | template<class InIt, class OutIt, class T> OutIt replace_copy(InIt first, InIt last, OutIt x,const T& vold, const T& vnew); | |
replace_if | <algorithm> | 将指定范围内全部操作结果为true的元素用新值取代 |
函数原形 | template<class FwdIt, class Pred, class T> void replace_if(FwdIt first, FwdIt last,Pred pr, const T& val); | |
replace_copy_if | <algorithm> | 与replace_if。只是将结果写入还有一个容器 |
函数原形 | template<class InIt, class OutIt, class Pred, class T> OutIt replace_copy_if(InIt first, InIt last, OutIt x, Pred pr, const T& val); | |
swap | <algorithm> | 交换存储在两个对象中的值 |
函数原形 | template<class T> void swap(T& x, T& y); | |
swap_range | <algorithm> | 将指定范围内的元素与还有一个序列元素值进行交换 |
函数原形 | template<class FwdIt1, class FwdIt2> FwdIt2 swap_ranges(FwdIt1 first, FwdIt1 last, FwdIt2 x); | |
unique | <algorithm> | 清除序列中反复元素,和remove类似。它也不能真正删除元素。重载版本号使用自己定义比較操作 |
函数原形 | template<class FwdIt> FwdIt unique(FwdIt first, FwdIt last); | |
template<class FwdIt, class Pred> FwdIt unique(FwdIt first, FwdIt last, Pred pr); | ||
unique_copy | <algorithm> | 与unique类似,只是把结果输出到还有一个容器 |
函数原形 | template<class InIt, class OutIt> OutIt unique_copy(InIt first, InIt last, OutIt x); | |
template<class InIt, class OutIt, class Pred> OutIt unique_copy(InIt first, InIt last, OutIt x, Pred pr); |
生成和变异算法(6个)
函数名 | 头文件 | 函数功能 |
fill | <algorithm> | 将输入值赋给标志范围内的全部元素 |
函数原形 | template<class FwdIt, class T> void fill(FwdIt first, FwdIt last, const T& x); | |
fill_n | <algorithm> | 将输入值赋给first到first+n范围内的全部元素 |
函数原形 | template<class OutIt, class Size, class T> void fill_n(OutIt first, Size n, const T& x); | |
for_each | <algorithm> | 用指定函数依次对指定范围内全部元素进行迭代訪问,返回所指定的函数类型。 该函数不得改动序列中的元素 |
函数原形 | template<class InIt, class Fun> Fun for_each(InIt first, InIt last, Fun f); | |
generate | <algorithm> | 连续调用输入的函数来填充指定的范围 |
函数原形 | template<class FwdIt, class Gen> void generate(FwdIt first, FwdIt last, Gen g); | |
generate_n | <algorithm> | 与generate函数类似。填充从指定iterator開始的n个元素 |
函数原形 | template<class OutIt, class Pred, class Gen> void generate_n(OutIt first, Dist n, Gen g); | |
transform | <algorithm> | 将输入的操作作用与指定范围内的每一个元素。并产生一个新的序列。重载版本号将操作作用在一对元素上。另外一个元素来自输入的另外一个序列。结果输出到指定容器 |
函数原形 | template<class InIt, class OutIt, class Unop> OutIt transform(InIt first, InIt last, OutIt x, Unop uop); | |
template<class InIt1, class InIt2, class OutIt, class Binop> OutIt transform(InIt1 first1, InIt1 last1, InIt2 first2,OutIt x, Binop bop); |
算数算法(4个)
函数名 | 头文件 | 函数功能 |
accumulate | <numeric> | iterator对标识的序列段元素之和,加到一个由val指定的初始值上。重载版本号不再做加法,而是传进来的二元操作符被应用到元素上 |
函数原形 | template<class InIt, class T> T accumulate(InIt first, InIt last, T val); | |
template<class InIt, class T, class Pred> T accumulate(InIt first, InIt last, T val, Pred pr); | ||
partial_sum | <numeric> | 创建一个新序列,当中每一个元素值代表指定范围内该位置前全部元素之和。 重载版本号使用自己定义操作取代加法 |
函数原形 | template<class InIt, class OutIt> OutIt partial_sum(InIt first, InIt last,OutIt result); | |
template<class InIt, class OutIt, class Pred> OutIt partial_sum(InIt first, InIt last,OutIt result, Pred pr); | ||
product | <numeric> | 对两个序列做内积(相应元素相乘,再求和)并将内积加到一个输入的初始值上。重载版本号使用用户定义的操作 |
函数原形 | template<class InIt1, class InIt2, class T> T product(InIt1 first1, InIt1 last1,Init2 first2, T val); | |
template<class InIt1, class InIt2, class T,class Pred1, class Pred2> T product(InIt1 first1, InIt1 last1,Init2 first2, T val, Pred1 pr1, Pred2 pr2); | ||
adjacent_difference | <numeric> | 创建一个新序列。新序列中每一个新值代表当前元素与上一个元素的差。重载版本号用指定二元操作计算相邻元素的差 |
函数原形 | template<class InIt, class OutIt> OutIt adjacent_difference(InIt first, InIt last,OutIt result); | |
template<class InIt, class OutIt, class Pred> OutIt adjacent_difference(InIt first, InIt last,OutIt result, Pred pr); |
转载自:http://www.cnblogs.com/kzloser/archive/2012/11/02/2751424.html
posted on 2017-06-23 15:18 cynchanpin 阅读(157) 评论(0) 编辑 收藏 举报