algorithm (STL/CLR)

定义执行算法的 STL/CLR 容器函数模版。

语法

#include <cliext/algorithm>

要求

标头：<cliext/algorithm>

命名空间：cliext

声明

Function	说明
adjacent_find (STL/CLR)	搜索两个相等的相邻元素。
binary_search (STL/CLR)	测试排序序列是否包含给定值。
copy (STL/CLR)	将值从源范围复制到目标范围，向前进行迭代。
copy_backward (STL/CLR)	将值从源范围复制到目标范围，向后进行迭代。
count (STL/CLR)	返回范围中其值与指定值匹配的元素的数量。
count_if (STL/CLR)	返回范围中其值与指定条件匹配的元素的数量。
equal (STL/CLR)	逐个元素比较两个范围。
equal_range (STL/CLR)	搜索值的有序序列，并返回两个位置，这些位置分隔所有等于给定元素的值的子序列。
fill (STL/CLR)	将相同的新值分配给指定范围中的每个元素。
fill_n (STL/CLR)	将新值分配给以特定元素开始的范围中指定数量的元素。
find (STL/CLR)	返回指定值首次出现的位置。
find_end (STL/CLR)	返回与指定序列相同的范围内的最后一个子序列。
find_first_of (STL/CLR)	在某一范围中搜索给定元素范围中任一元素的首次出现。
find_if (STL/CLR)	返回元素满足指定条件的值序列中首个元素的位置。
for_each (STL/CLR)	将指定的函数对象应用于值序列中的每个元素并返回函数对象。
generate (STL/CLR)	将函数对象生成的值分配给值序列中的每个元素。
generate_n (STL/CLR)	将函数对象生成的值分配给指定数量的元素。
includes (STL/CLR)	测试一个排序范围是否包含第二个排序范围中的所有元素。
inplace_merge (STL/CLR)	将两个连续排序范围中的元素合并为单个排序范围。
iter_swap (STL/CLR)	交换由一对指定迭代器引用的两个值。
lexicographical_compare (STL/CLR)	逐个元素比较两个序列，确定两者中较小的那个序列。
lower_bound (STL/CLR)	在排序的值序列中查找值大于或等于指定值的首个元素的位置。
make_heap (STL/CLR)	将指定范围中的元素转换为堆，其中堆上的第一个元素最大。
max (STL/CLR))	比较两个对象并返回两者中较大的一个。
max_element (STL/CLR)	查找指定值序列中的最大元素。
merge (STL/CLR))	将两个排序的源范围中的所有元素合并为单个排序的目标范围。
min (STL/CLR)	比较两个对象并返回两者中较小的一个。
min_element (STL/CLR)	查找指定值序列中的最小元素。
mismatch (STL/CLR)	逐个元素比较两个范围，并返回出现不同项的首个位置。
next_permutation (STL/CLR)	重新排序范围中的元素，以便使用按字典顺序的下一个更大排列（如果存在）替换原有排序。
nth_element (STL/CLR)	对元素序列进行分区，正确找到序列的第 n 个元素，使它前面的所有元素都小于或等于它，而它后面的所有元素都大于或等于它。
partial_sort (STL/CLR)	将范围中指定数量的较小元素按非降序顺序排列。
partial_sort_copy (STL/CLR)	将源范围中的元素复制到目标范围，以便对源范围中的元素进行排序。
partition (STL/CLR)	排列范围中的元素，使那些满足一元谓词的元素排在不满足一元谓词的元素之前。
pop_heap (STL/CLR)	将最大的元素从堆的前面移动到末尾，然后从剩余的元素中形成一个新的堆。
prev_permutation (STL/CLR)	重新排序范围中的元素，以便使用按字典顺序的前一个更大排列（如果存在）替换原有排序。
push_heap (STL/CLR)	将范围末尾的元素添加到包括范围中前面元素的现有堆中。
random_shuffle (STL/CLR)	将范围中 N 个元素的序列重新排序为随机选择的 N! 个 可能排列之一。
remove (STL/CLR)	从给定范围中删除指定值，而不影响剩余元素的顺序，并返回不包含指定值的新范围的末尾。
remove_copy (STL/CLR)	将源范围中的元素复制到目标范围（不复制具有指定值的元素），而不影响剩余元素的顺序。
remove_copy_if (STL/CLR)	将源范围中的元素复制到目标范围（不复制满足谓词的元素），而不影响其余元素的顺序。
remove_if (STL/CLR)	从给定范围中删除满足谓词的元素，而不影响剩余元素的顺序。 。
replace (STL/CLR)	将范围中与指定值匹配的元素替换为新值。
replace_copy (STL/CLR)	将源范围中的元素复制到目标范围，将与指定值匹配的元素替换为新值。
replace_copy_if (STL/CLR)	检查源范围中的每个元素，并替换满足指定谓词的元素，同时将结果复制到新的目标范围。
replace_if (STL/CLR)	检查范围中的每个元素，并替换满足指定谓词的元素。
reverse (STL/CLR)	反转范围中元素的顺序。
reverse_copy (STL/CLR)	反转源范围中元素的顺序，同时将这些元素复制到目标范围。
rotate (STL/CLR)	交换两个相邻范围中的元素。
rotate_copy (STL/CLR)	交换源范围中两个相邻范围内的元素，并将结果复制到目标范围。
search (STL/CLR)	在目标范围中搜索其元素与给定序列中的元素相等或在二元谓词指定的意义上等效于给定序列中的元素的序列的第一个匹配项。
search_n (STL/CLR)	在范围中搜索具有特定值或按二元谓词的指定与此值相关的指定数量的元素。
set_difference (STL/CLR)	将属于一个排序的源范围、但不属于另一排序的源范围的所有元素相并到一个排序的目标范围，其中排序条件可通过二元谓词指定。
set_intersection (STL/CLR)	将属于两个排序的源范围的所有元素相并为一个排序的目标范围，其中排序条件可通过二元谓词指定。
set_symmetric_difference (STL/CLR)	将属于一个而不是两个排序的源范围的所有元素相并为一个排序的目标范围，其中排序条件可通过二元谓词指定。
set_union (STL/CLR))	将至少属于两个排序的源范围之一的所有元素相并为一个排序的目标范围，其中排序条件可通过二元谓词指定。
sort (STL/CLR)	将指定范围中的元素按非降序顺序排列，或根据二元谓词指定的排序条件排列。
sort_heap (STL/CLR)	将堆转换为排序的范围。
stable_partition (STL/CLR)	将范围中的元素分为两个不相交的集，满足一元谓词的元素在不满足一元谓词的元素之前，并保留等效元素的相对顺序。
stable_sort (STL/CLR)	将指定范围中的元素按非降序顺序排列，或根据二元谓词指定的排序条件排列，并保留等效元素的相对顺序。
swap (STL/CLR)	在两种类型的对象之间交换元素值，将第一个对象的内容分配给第二个对象，将第二个对象的内容分配给第一个对象。
swap_ranges (STL/CLR)	将一个范围中的元素与另一大小相等的范围中的元素交换。
transform (STL/CLR)	将指定的函数对象应用于源范围中的每个元素或两个源范围中的元素对，并将函数对象的返回值复制到目标范围。
unique (STL/CLR)	移除指定范围中彼此相邻的重复元素。
unique_copy (STL/CLR)	将源范围中的元素复制到目标范围，彼此相邻的重复元素除外。
upper_bound (STL/CLR)	在排序的范围中查找其值大于指定值的第一个元素的位置，其中排序条件可通过二元谓词指定。

成员

adjacent_find (STL/CLR)

搜索相等或满足指定条件的两个相邻元素。

语法

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);

备注

此函数的行为与 C++ 标准库函数 adjacent_find 相同。 有关详细信息，请参阅 adjacent_find。

binary_search (STL/CLR)

测试已排序的范围中是否有等于指定值的元素，或在二元谓词指定的意义上与指定值等效的元素。

语法

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);

备注

此函数的行为与 C++ 标准库函数 binary_search 相同。 有关详细信息，请参阅 binary_search。

copy (STL/CLR)

将一个源范围中的元素值分配到目标范围，循环访问元素的源序列并将它们分配在一个向前方向的新位置。

语法

template<class _InIt, class _OutIt> inline
    _OutIt copy(_InIt _First, _InIt _Last, _OutIt _Dest);

备注

此函数的行为与 C++ 标准库函数 copy 相同。 有关详细信息，请参阅 copy。

copy_backward (STL/CLR)

将一个源范围中的元素值分配到目标范围，循环访问元素的源序列并将它们分配在一个向后方向的新位置。

语法

template<class _BidIt1, class _BidIt2> inline
    _BidIt2 copy_backward(_BidIt1 _First, _BidIt1 _Last,
        _BidIt2 _Dest);

备注

此函数的行为与 C++ 标准库函数 copy_backward 相同。 有关详细信息，请参阅 copy_backward。

count (STL/CLR)

返回范围中其值与指定值匹配的元素的数量。

语法

template<class _InIt, class _Ty> inline
    typename iterator_traits<_InIt>::difference_type
        count(_InIt _First, _InIt _Last, const _Ty% _Val);

备注

此函数的行为与 C++ 标准库函数 count 相同。 有关详细信息，请参阅 count。

count_if (STL/CLR)

返回范围中其值与指定条件匹配的元素的数量。

语法

template<class _InIt, class _Pr> inline
    typename iterator_traits<_InIt>::difference_type
        count_if(_InIt _First, _InIt _Last, _Pr _Pred);

备注

此函数的行为与 C++ 标准库函数 count_if 相同。 有关详细信息，请参阅 count_if。

equal (STL/CLR)

逐个元素比较两个范围是否相等或是否在二元谓词指定的意义上等效。

语法

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);

备注

此函数的行为与 C++ 标准库函数 equal 相同。 有关详细信息，请参阅 equal。

equal_range (STL/CLR)

在排序的范围中查找符合以下条件的位置对：第一个位置小于或等效于指定元素的位置，第二个位置大于此元素位置，等效意义或用于在序列中建立位置的排序可通过二元谓词指定。

语法

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);

备注

此函数的行为与 C++ 标准库函数 equal_range 相同。 有关详细信息，请参阅 equal_range。

fill (STL/CLR)

将相同的新值分配给指定范围中的每个元素。

语法

template<class _FwdIt, class _Ty> inline
    void fill(_FwdIt _First, _FwdIt _Last, const _Ty% _Val);

备注

此函数的行为与 C++ 标准库函数 fill 相同。 有关详细信息，请参阅 fill。

fill_n (STL/CLR)

将新值分配给以特定元素开始的范围中指定数量的元素。

语法

template<class _OutIt, class _Diff, class _Ty> inline
    void fill_n(_OutIt _First, _Diff _Count, const _Ty% _Val);

备注

此函数的行为与 C++ 标准库函数 fill_n 相同。 有关详细信息，请参阅 fill_n。

find (STL/CLR)

在范围中找到具有指定值的元素的第一个匹配项位置。

语法

template<class _InIt, class _Ty> inline
    _InIt find(_InIt _First, _InIt _Last, const _Ty% _Val);

备注

此函数的行为与 C++ 标准库函数 find 相同。 有关详细信息，请参阅 find。

find_end (STL/CLR)

在范围中查找与指定序列相同的最后一个序列，或在二元谓词指定的意义上等效的最后一个序列。

语法

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);

备注

此函数的行为与 C++ 标准库函数 find_end 相同。 有关详细信息，请参阅 find_end。

find_first_of (STL/CLR)

在目标范围中搜索若干值中任意值的第一个匹配项，或搜索在二元谓词指定的意义上等效于指定元素集的若干元素中任意元素的第一个匹配项。

语法

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);

备注

此函数的行为与 C++ 标准库函数 find_first_of 相同。 有关详细信息，请参阅 find_first_of。

find_if (STL/CLR)

在范围中找到满足指定条件的元素的第一个匹配项位置。

语法

template<class _InIt, class _Pr> inline
    _InIt find_if(_InIt _First, _InIt _Last, _Pr _Pred);

备注

此函数的行为与 C++ 标准库函数 find_if 相同。 有关详细信息，请参阅 find_if。

for_each (STL/CLR)

将指定的函数对象按向前顺序应用于范围中的每个元素并返回此函数对象。

语法

template<class _InIt, class _Fn1> inline
    _Fn1 for_each(_InIt _First, _InIt _Last, _Fn1 _Func);

备注

此函数的行为与 C++ 标准库函数 for_each 相同。 有关详细信息，请参阅 for_each。

generate (STL/CLR)

将函数对象生成的值分配给范围中的每个元素。

语法

template<class _FwdIt, class _Fn0> inline
    void generate(_FwdIt _First, _FwdIt _Last, _Fn0 _Func);

备注

此函数的行为与 C++ 标准库函数 generate 相同。 有关详细信息，请参阅 generate。

generate_n (STL/CLR)

将函数对象生成的值分配给范围中指定数量的元素，并返回到超出最后一个分配值的下一位置。

语法

template<class _OutIt, class _Diff, class _Fn0> inline
    void generate_n(_OutIt _Dest, _Diff _Count, _Fn0 _Func);

备注

此函数的行为与 C++ 标准库函数 generate_n 相同。 有关详细信息，请参阅 generate_n。

includes (STL/CLR)

测试一个排序的范围是否包含另一排序范围中的所有元素，其中元素之间的排序或等效条件可通过二元谓词指定。

语法

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);

备注

此函数的行为与 C++ 标准库函数 includes 相同。 有关详细信息，请参阅 includes。

inplace_merge (STL/CLR)

将两个连续的排序范围中的元素合并为一个排序范围，其中排序条件可通过二元谓词指定。

语法

template<class _BidIt> inline
    void inplace_merge(_BidIt _First, _BidIt _Mid, _BidIt _Last);
template<class _BidIt, class _Pr> inline
    void inplace_merge(_BidIt _First, _BidIt _Mid, _BidIt _Last,
        _Pr _Pred);

备注

此函数的行为与 C++ 标准库函数 inplace_merge 相同。有关详细信息，请参阅 inplace_merge。

iter_swap (STL/CLR)

交换由一对指定迭代器引用的两个值。

语法

template<class _FwdIt1, class _FwdIt2> inline
    void iter_swap(_FwdIt1 _Left, _FwdIt2 _Right);

备注

此函数的行为与 C++ 标准库函数 iter_swap 相同。 有关详细信息，请参阅 iter_swap。

lexicographical_compare (STL/CLR)

逐个元素比较两个序列以确定其中的较小序列。

语法

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);

备注

此函数的行为与 C++ 标准库函数 lexicographical_compare 相同。 有关详细信息，请参阅 lexicographical_compare。

lower_bound (STL/CLR)

在排序的范围中查找值小于或等效于指定值的第一个元素的位置，其中排序条件可通过二元谓词指定。

语法

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);

备注

此函数的行为与 C++ 标准库函数 lower_bound 相同。 有关详细信息，请参阅 lower_bound。

make_heap (STL/CLR)

将指定范围中的元素转换到第一个元素是最大元素的堆中，其中排序条件可通过二元谓词指定。

语法

template<class _RanIt> inline
    void make_heap(_RanIt _First, _RanIt _Last);
template<class _RanIt, class _Pr> inline
    void make_heap(_RanIt _First, _RanIt _Last, _Pr _Pred);

备注

此函数的行为与 C++ 标准库函数 make_heap 相同。 有关详细信息，请参阅 make_heap。

max (STL/CLR)

比较两个对象并返回较大对象，其中排序条件可通过二元谓词指定。

语法

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);

备注

此函数的行为与 C++ 标准库函数 max 相同。 有关详细信息，请参阅 max。

max_element (STL/CLR)

在指定范围中查找最大元素的第一个匹配项，其中排序条件可通过二元谓词指定。

语法

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);

备注

此函数的行为与 C++ 标准库函数 max_element 相同。 有关详细信息，请参阅 max_element。

merge (STL/CLR)

将两个排序的源范围中的所有元素合并为一个排序的目标范围，其中排序条件可通过二元谓词指定。

语法

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);

备注

此函数的行为与 C++ 标准库函数 merge 相同。 有关详细信息，请参阅 merge。

min (STL/CLR)

比较两个对象并返回较小对象，其中排序条件可通过二元谓词指定。

语法

template<class _Ty> inline
    const _Ty min(const _Ty% _Left, const _Ty% _Right);
template<class _Ty, class _Pr> inline
    const _Ty min(const _Ty% _Left, const _Ty% _Right, _Pr _Pred);

备注

此函数的行为与 C++ 标准库函数 min 相同。 有关详细信息，请参阅 min。

min_element (STL/CLR)

在指定范围中查找最小元素的第一个匹配项，其中排序条件可通过二元谓词指定。

语法

template<class _FwdIt> inline
    _FwdIt min_element(_FwdIt _First, _FwdIt _Last);
template<class _FwdIt, class _Pr> inline
    _FwdIt min_element(_FwdIt _First, _FwdIt _Last, _Pr _Pred);

备注

此函数的行为与 C++ 标准库函数 min_element 相同。 有关详细信息，请参阅 min_element。

mismatch (STL/CLR)

逐个元素比较两个范围是否相等或是否在二元谓词指定的意义上等效，并找到出现不同的第一个位置。

语法

template<class _InIt1, class _InIt2> inline
    _PAIR_TYPE(_InIt1)
        mismatch(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2);
template<class _InIt1, class _InIt2, class _Pr> inline
    _PAIR_TYPE(_InIt1)
        mismatch(_InIt1 _First1, _InIt1 _Last1, _InIt2 _First2,
            _Pr _Pred);

备注

此函数的行为与 C++ 标准库函数 mismatch 相同。 有关详细信息，请参阅 mismatch。

next_permutation (STL/CLR)

重新排序范围中的元素，以便使用按字典顺序的下一个更大排列（如果有）替换原有排序，其中“下一个”的意义可通过二元谓词指定。

语法

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);

备注

此函数的行为与 C++ 标准库函数 next_permutation 相同。 有关详细信息，请参阅 next_permutation。

nth_element (STL/CLR)

对范围内的元素分区，正确找到范围中序列的第 n 个元素，以使序列中位于此元素之前的所有元素小于或等于此元素，位于此元素之后的所有元素大于或等于此元素。

语法

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);

备注

此函数的行为与 C++ 标准库函数 nth_element 相同。 有关详细信息，请参阅 nth_element。

partial_sort (STL/CLR)

将范围中指定数量的较小元素按非降序顺序排列，或根据二元谓词指定的排序条件排列。

语法

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);

备注

此函数的行为与 C++ 标准库函数 partial_sort 相同。 有关详细信息，请参阅 partial_sort。

partial_sort_copy (STL/CLR)

将源范围中的元素复制到目标范围，其中源元素按降序或二元谓词指定的其他顺序排序。

语法

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);

备注

此函数的行为与 C++ 标准库函数 partial_sort_copy 相同。 有关详细信息，请参阅 partial_sort_copy。

partition (STL/CLR)

将范围中的元素分为两个不相交的集，满足一元谓词的元素在不满足一元谓词的元素之前。

语法

template<class _BidIt, class _Pr> inline
    _BidIt partition(_BidIt _First, _BidIt _Last, _Pr _Pred);

备注

此函数的行为与 C++ 标准库函数 partition 相同。 有关详细信息，请参阅 partition。

pop_heap (STL/CLR)

移除从堆顶到范围中倒数第二个位置之间的最大元素，然后将剩余元素形成新堆。

语法

template<class _RanIt> inline
    void pop_heap(_RanIt _First, _RanIt _Last);
template<class _RanIt, class _Pr> inline
    void pop_heap(_RanIt _First, _RanIt _Last, _Pr _Pred);

备注

此函数的行为与 C++ 标准库函数 pop_heap 相同。 有关详细信息，请参阅 pop_heap。

prev_permutation (STL/CLR)

重新排序范围中的元素，以便使用按字典顺序的下一个更大排列（如果有）替换原有排序，其中“下一个”的意义可通过二元谓词指定。

语法

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);

备注

此函数的行为与 C++ 标准库函数 prev_permutation 相同。 有关详细信息，请参阅 prev_permutation。

push_heap (STL/CLR)

将范围末尾的元素添加到包括范围中前面元素的现有堆中。

语法

template<class _RanIt> inline
    void push_heap(_RanIt _First, _RanIt _Last);
template<class _RanIt, class _Pr> inline
    void push_heap(_RanIt _First, _RanIt _Last, _Pr _Pred);

备注

此函数的行为与 C++ 标准库函数 push_heap 相同。 有关详细信息，请参阅 push_heap。

random_shuffle (STL/CLR)

将范围中 N 个元素的序列重新排序为随机选择的 N! 个 可能排列之一。

语法

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);

备注

此函数的行为与 C++ 标准库函数 random_shuffle 相同。 有关详细信息，请参阅 random_shuffle。

remove (STL/CLR)

从给定范围中消除指定值，而不影响剩余元素的顺序，并返回不包含指定值的新范围的末尾。

语法

template<class _FwdIt, class _Ty> inline
    _FwdIt remove(_FwdIt _First, _FwdIt _Last, const _Ty% _Val);

备注

此函数的行为与 C++ 标准库函数 remove 相同。 有关详细信息，请参阅 remove。

remove_copy (STL/CLR)

将源范围中的元素复制到目标范围（不复制具有指定值的元素），而不影响剩余元素的顺序，并返回新目标范围的末尾。

语法

template<class _InIt, class _OutIt, class _Ty> inline
    _OutIt remove_copy(_InIt _First, _InIt _Last,
        _OutIt _Dest, const _Ty% _Val);

备注

此函数的行为与 C++ 标准库函数 remove_copy 相同。 有关详细信息，请参阅 remove_copy。

remove_copy_if (STL/CLR)

将源范围中的元素复制到目标范围（不复制满足谓词的元素），而不影响剩余元素的顺序，并返回新目标范围的末尾。

语法

template<class _InIt, class _OutIt, class _Pr> inline
    _OutIt remove_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest,
        _Pr _Pred);

备注

此函数的行为与 C++ 标准库函数 remove_copy_if 相同。 有关详细信息，请参阅 remove_copy_if。

remove_if (STL/CLR)

从给定范围中消除满足谓词的元素，而不影响剩余元素的顺序，并返回不包含指定值的新范围的末尾。

语法

template<class _FwdIt, class _Pr> inline
    _FwdIt remove_if(_FwdIt _First, _FwdIt _Last, _Pr _Pred);

备注

此函数的行为与 C++ 标准库函数 remove_if 相同。 有关详细信息，请参阅 remove_if。

replace (STL/CLR)

检查范围中的每个元素，并替换与指定值匹配的元素。

语法

template<class _FwdIt, class _Ty> inline
    void replace(_FwdIt _First, _FwdIt _Last,
        const _Ty% _Oldval, const _Ty% _Newval);

备注

此函数的行为与 C++ 标准库函数 replace 相同。 有关详细信息，请参阅 replace。

replace_copy (STL/CLR)

检查源范围中的每个元素，并替换与指定值匹配的元素，同时将结果复制到新的目标范围。

语法

template<class _InIt, class _OutIt, class _Ty> inline
    _OutIt replace_copy(_InIt _First, _InIt _Last, _OutIt _Dest,
        const _Ty% _Oldval, const _Ty% _Newval);

备注

此函数的行为与 C++ 标准库函数 replace_copy 相同。 有关详细信息，请参阅 replace_copy。

replace_copy_if (STL/CLR)

检查源范围中的每个元素，并替换满足指定谓词的元素，同时将结果复制到新的目标范围。

语法

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);

备注

此函数的行为与 C++ 标准库函数 replace_copy_if 相同。 有关详细信息，请参阅 replace_copy_if。

replace_if (STL/CLR)

检查范围中的每个元素，并替换满足指定谓词的元素。

语法

template<class _FwdIt, class _Pr, class _Ty> inline
    void replace_if(_FwdIt _First, _FwdIt _Last, _Pr _Pred,
        const _Ty% _Val);

备注

此函数的行为与 C++ 标准库函数 replace_if 相同。 有关详细信息，请参阅 replace_if。

reverse (STL/CLR)

反转范围中元素的顺序。

语法

template<class _BidIt> inline
    void reverse(_BidIt _First, _BidIt _Last);

备注

此函数的行为与 C++ 标准库函数 reverse 相同。 有关详细信息，请参阅 reverse。

reverse_copy (STL/CLR)

反转源范围中元素的顺序，同时将这些元素复制到目标范围。

语法

template<class _BidIt, class _OutIt> inline
    _OutIt reverse_copy(_BidIt _First, _BidIt _Last, _OutIt _Dest);

备注

此函数的行为与 C++ 标准库函数 reverse_copy 相同。 有关详细信息，请参阅 reverse_copy。

rotate (STL/CLR)

交换两个相邻范围中的元素。

语法

template<class _FwdIt> inline
    void rotate(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last);

备注

此函数的行为与 C++ 标准库函数 rotate 相同。 有关详细信息，请参阅 rotate。

rotate_copy (STL/CLR)

交换源范围中两个相邻范围内的元素，并将结果复制到目标范围。

语法

template<class _FwdIt, class _OutIt> inline
    _OutIt rotate_copy(_FwdIt _First, _FwdIt _Mid, _FwdIt _Last,
        _OutIt _Dest);

备注

此函数的行为与 C++ 标准库函数 rotate_copy 相同。 有关详细信息，请参阅 rotate_copy。

search (STL/CLR)

在目标范围中搜索其元素与给定序列中的元素相等或在二元谓词指定的意义上等效于给定序列中的元素的序列的第一个匹配项。

语法

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);

备注

此函数的行为与 C++ 标准库函数 search 相同。 有关详细信息，请参阅 search。

search_n (STL/CLR)

在范围中搜索具有特定值或按二元谓词的指定与此值相关的指定数量的元素。

语法

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);

备注

此函数的行为与 C++ 标准库函数 search_n 相同。 有关详细信息，请参阅 search_n。

set_difference (STL/CLR)

将属于一个排序的源范围、但不属于另一排序的源范围的所有元素相并到一个排序的目标范围，其中排序条件可通过二元谓词指定。

语法

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);

备注

此函数的行为与 C++ 标准库函数 set_difference 相同。 有关详细信息，请参阅 set_difference。

set_intersection (STL/CLR)

将属于两个排序的源范围的所有元素相并为一个排序的目标范围，其中排序条件可通过二元谓词指定。

语法

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);

备注

此函数的行为与 C++ 标准库函数 set_intersection 相同。 有关详细信息，请参阅 set_intersection。

set_symmetric_difference (STL/CLR)

将属于一个而不是两个排序的源范围的所有元素相并为一个排序的目标范围，其中排序条件可通过二元谓词指定。

语法

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);

备注

此函数的行为与 C++ 标准库函数 set_symmetric_difference 相同。 有关详细信息，请参阅 set_symmetric_difference。

set_union (STL/CLR)

将至少属于两个排序的源范围之一的所有元素相并为一个排序的目标范围，其中排序条件可通过二元谓词指定。

语法

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);

备注

此函数的行为与 C++ 标准库函数 set_union 相同。 有关详细信息，请参阅 set_union。

sort (STL/CLR)

将指定范围中的元素按非降序顺序排列，或根据二元谓词指定的排序条件排列。

语法

template<class _RanIt> inline
    void sort(_RanIt _First, _RanIt _Last);
template<class _RanIt, class _Pr> inline
    void sort(_RanIt _First, _RanIt _Last, _Pr _Pred);

备注

此函数的行为与 C++ 标准库函数 sort 相同。 有关详细信息，请参阅 sort。

sort_heap (STL/CLR)

将堆转换为排序的范围。

语法

template<class _RanIt> inline
    void sort_heap(_RanIt _First, _RanIt _Last);
template<class _RanIt, class _Pr> inline
    void sort_heap(_RanIt _First, _RanIt _Last, _Pr _Pred);

备注

此函数的行为与 C++ 标准库函数 sort_heap 相同。 有关详细信息，请参阅 sort_heap。

stable_partition (STL/CLR)

将范围中的元素分为两个不相交的集，满足一元谓词的元素在不满足一元谓词的元素之前，并保留等效元素的相对顺序。

语法

template<class _BidIt, class _Pr> inline
    _BidIt stable_partition(_BidIt _First, _BidIt _Last, _Pr _Pred);

备注

此函数的行为与 C++ 标准库函数 stable_partition 相同。 有关详细信息，请参阅 stable_partition。

stable_sort (STL/CLR)

将指定范围中的元素按非降序顺序排列，或根据二元谓词指定的排序条件排列，并保留等效元素的相对顺序。

语法

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);

备注

此函数的行为与 C++ 标准库函数 stable_sort 相同。 有关详细信息，请参阅 stable_sort。

swap (STL/CLR)

在两种类型的对象之间交换元素值，将第一个对象的内容分配给第二个对象，将第二个对象的内容分配给第一个对象。

语法

<class _Ty> inline
    void swap(_Ty% _Left, _Ty% _Right);

备注

此函数的行为与 C++ 标准库函数 swap 相同。 有关详细信息，请参阅 swap。

swap_ranges (STL/CLR)

将一个范围中的元素与另一大小相等的范围中的元素交换。

语法

template<class _FwdIt1, class _FwdIt2> inline
    _FwdIt2 swap_ranges(_FwdIt1 _First1, _FwdIt1 _Last1,
        _FwdIt2 _First2);

备注

此函数的行为与 C++ 标准库函数 swap_ranges 相同。 有关详细信息，请参阅 swap_ranges。

transform (STL/CLR)

将指定的函数对象应用于源范围中的每个元素或两个源范围中的元素对，并将函数对象的返回值复制到目标范围。

语法

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);

备注

此函数的行为与 C++ 标准库函数 transform 相同。 有关详细信息，请参阅 transform。

unique (STL/CLR)

移除指定范围中彼此相邻的重复元素。

语法

template<class _FwdIt> inline
    _FwdIt unique(_FwdIt _First, _FwdIt _Last);
template<class _FwdIt, class _Pr> inline
    _FwdIt unique(_FwdIt _First, _FwdIt _Last, _Pr _Pred);

备注

此函数的行为与 C++ 标准库函数 unique 相同。 有关详细信息，请参阅 unique。

unique_copy (STL/CLR)

将源范围中的元素复制到目标范围，彼此相邻的重复元素除外。

语法

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);

备注

此函数的行为与 C++ 标准库函数 unique_copy 相同。 有关详细信息，请参阅 unique_copy。

upper_bound (STL/CLR)

在排序的范围中查找其值大于指定值的第一个元素的位置，其中排序条件可通过二元谓词指定。

语法

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);

备注

此函数的行为与 C++ 标准库函数 upper_bound 相同。 有关详细信息，请参阅 upper_bound。