泛型算法-优快云博客

本文链接：https://blog.youkuaiyun.com/an_zhenwei/article/details/8772511

本文详细介绍了C++标准模板库(STL)中的多种算法，包括计数(count)、条件计数(count_if)、去除(remove/remove_if)、复制(copy/copy_backward/reverse_copy)、反转(reverse/reverse_copy)、遍历(for_each)、查找(find/search)、转换(transform)、累加(accumulate)及不匹配(mismatch)等。每种算法均附带了详细的说明和用例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

stl_numeric.h

accumulate、inner_product、adjacent_difference、partial_sum、power、iota

count --- 区间中有多少等于某个值的元素
count_if --- 有多少元素满足一个判断式
区间中的最小和最大值可以通过min_element和max_element获得

accumulate --- 产生区间统计的算法
for_each --- 对区间的每个元素进行一些操作

remove:

template <class ForwardIterator, class T>

ForwardIterator remove (ForwardIterator first, ForwardIterator last, const T& val) ------ 移除与val相同的成员，只是依次前移成员，不会更改容器大小。

remove_if:

template <class ForwardIterator, class UnaryPredicate>

ForwardIterator remove_if (ForwardIterator first, ForwardIterator last, UnaryPredicate pred) ------ pred就是一个一元函数，返回bool

remove_copy

template <class InputIterator, class OutputIterator, class T>

OutputIterator remove_copy (InputIterator first, InputIterator last,

OutputIterator result, const T& val); ------ 从first到last，移除和val相等的元素，移除的结果存储到result中；

不能使用begin，end等成员函数返回的迭代器，必须使用插入迭代器！否则不能变更容器大小！！！很多泛型算法类似！！！

copy

template <class InputIterator, class OutputIterator>

OutputIterator copy (InputIterator first, InputIterator last, OutputIterator result); ------ 从first到last依次复制到result；

copy_backward

template <class BidirectionalIterator1, class BidirectionalIterator2>

BidirectionalIterator2 copy_backward (BidirectionalIterator1 first,

BidirectionalIterator1 last,
BidirectionalIterator2 result); --- result作为最后位置的迭代器；从last到first依次复制到result；

reverse_copy

template <class BidirectionalIterator, class OutputIterator>

OutputIterator reverse_copy (BidirectionalIterator first,

BidirectionalIterator last, OutputIterator result); ------ 反序复制

reverse

template <class BidirectionalIterator>

void reverse (BidirectionalIterator first, BidirectionalIterator last); ------ 转序

for_each

template <class InputIterator, class Function>
Function for_each (InputIterator first, InputIterator last, Function fn); ------ 依次执行函数fn，入参为迭代器所指对象； fun可以为函数指针，也可以为函数对象。

find

template <class InputIterator, class T>
InputIterator find (InputIterator first, InputIterator last, const T& val); ------ 找到第一个val并返回迭代器；

transform

unary operation(1)
template <class InputIterator, class OutputIterator, class UnaryOperation>
OutputIterator transform (InputIterator first1, InputIterator last1,
OutputIterator result, UnaryOperation op); ------ op的入参从first1到last1，操作结果依次存储到result中
binary operation(2)
template <class InputIterator1, class InputIterator2,
class OutputIterator, class BinaryOperation>
OutputIterator transform (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, OutputIterator result,
BinaryOperation binary_op); ------ op的第一个入参从first1到last1，第二个入参从first2开始，操作结果依次存储到result中

equality (1)
template <class ForwardIterator1, class ForwardIterator2>
ForwardIterator1 search (ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2); ------ 在“first1到last1的字符串”中查找“first2到last2的字符串”。
predicate (2)
template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
ForwardIterator1 search (ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2,
BinaryPredicate pred); ------ 在“first1到last1的字符串”中查找“first2到last2的字符串”，通过pred进行比较。

equal

equality (1)

template <class InputIterator1, class InputIterator2>

bool equal (InputIterator1 first1, InputIterator1 last1,

InputIterator2 first2); ------ 从first1到last1，依次比较first和first2链表中的成员；

predicate (2)

template <class InputIterator1, class InputIterator2, class BinaryPredicate>

bool equal (InputIterator1 first1, InputIterator1 last1,

InputIterator2 first2, BinaryPredicate pred); ------ 把first1和first2依次传入pred进行比较，看是否为true；

count

无返回值时，最后一个参数为输出值

template <class _InputIter, class _Tp, class _Size>

void count(_InputIter __first, _InputIter __last, const _Tp& __value,

_Size& __n)

template <class _InputIter, class _Tp>

typename iterator_traits<_InputIter>::difference_type

count(_InputIter __first, _InputIter __last, const _Tp& __value)

count_if

template <class _InputIter, class _Predicate, class _Size>

void count_if(_InputIter __first, _InputIter __last, _Predicate __pred,

_Size& __n)

template <class _InputIter, class _Predicate>

typename iterator_traits<_InputIter>::difference_type

count_if(_InputIter __first, _InputIter __last, _Predicate __pred)

accumulate

累加动作

template <class _InputIterator, class _Tp>

_Tp accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)

{

__STL_REQUIRES(_InputIterator, _InputIterator);

for ( ; __first != __last; ++__first)

__init = __init + *__first;

return __init;

}

list<double> ld;
double sum = accumulate(ld.begin(), Id.end(), 0.0); //不能用0，否则返回值是整数

//__init是二元函数的第一个参数。

template <class _InputIterator, class _Tp, class _BinaryOperation>

_Tp accumulate(_InputIterator __first, _InputIterator __last, _Tp __init,

_BinaryOperation __binary_op)

{

__STL_REQUIRES(_InputIterator, _InputIterator);

for ( ; __first != __last; ++__first)

__init = __binary_op(__init, *__first);

return __init;

}

mismatch

返回第一个不匹配的pair，由input1和input2的各一个成员组成。
template <class _InputIter1, class _InputIter2>
pair<_InputIter1, _InputIter2> mismatch(_InputIter1 __first1,
_InputIter1 __last1,
_InputIter2 __first2)
template <class _InputIter1, class _InputIter2, class _BinaryPredicate>
pair<_InputIter1, _InputIter2> mismatch(_InputIter1 __first1,
_InputIter1 __last1,
_InputIter2 __first2,
_BinaryPredicate __binary_pred)