Namespaces
Variants

std::ranges:: minmax_element, std::ranges:: minmax_element_result

From cppreference.net
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy , ranges::sort , ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
Modifying sequence operations
Copy operations
(C++11)
(C++11)
Swap operations
Transformation operations
Generation operations
Removing operations
Order-changing operations
(until C++17) (C++11)
(C++20) (C++20)
Sampling operations
(C++17)

Sorting and related operations
Partitioning operations
Sorting operations
Binary search operations
(on partitioned ranges)
Set operations (on sorted ranges)
Merge operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Lexicographical comparison operations
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Constrained algorithms
All names in this menu belong to namespace std::ranges
Non-modifying sequence operations
Modifying sequence operations
Partitioning operations
Sorting operations
Binary search operations (on sorted ranges)
Set operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Permutation operations
Fold operations
Operations on uninitialized storage
Return types
定义于头文件 <algorithm>
调用签名
template < std:: forward_iterator I, std:: sentinel_for < I > S, class Proj = std:: identity ,

std:: indirect_strict_weak_order < std :: projected < I, Proj >> Comp = ranges:: less >
constexpr minmax_element_result < I >

minmax_element ( I first, S last, Comp comp = { } , Proj proj = { } ) ;
(1) (C++20 起)
template < ranges:: forward_range R, class Proj = std:: identity ,

std:: indirect_strict_weak_order <
std :: projected < ranges:: iterator_t < R > , Proj >> Comp = ranges:: less >
constexpr minmax_element_result < ranges:: borrowed_iterator_t < R >>

minmax_element ( R && r, Comp comp = { } , Proj proj = { } ) ;
(2) (C++20 起)
辅助类型
template < class I >
using minmax_element_result = ranges:: min_max_result < I > ;
(3) (C++20 起)
1) 查找范围 [ first , last ) 中的最小和最大元素。
2) (1) 相同,但使用 r 作为源范围,如同使用 ranges:: begin ( r ) 作为 first ,以及 ranges:: end ( r ) 作为 last

本页面描述的函数式实体是 算法函数对象 (非正式称为 niebloids ),即:

目录

参数

first, last - 定义待检查元素范围的迭代器-哨位对
r - 待检查的 range
comp - 应用于投影元素的比较操作
proj - 应用于元素的投影操作

返回值

一个对象,其第一个元素是指向最小元素的迭代器,第二个元素是指向最大元素的迭代器。如果范围为空,则返回 { first, first } 。如果有多个元素等价于最小元素,则返回指向第一个此类元素的迭代器。如果有多个元素等价于最大元素,则返回指向最后一个此类元素的迭代器。

复杂度

最多 std:: max ( std:: floor ( 1.5 * ( N − 1 ) ) , 0.0 ) 次比较操作和两倍的投影操作,其中 N = ranges:: distance ( first, last )

可能的实现

struct minmax_element_fn
{
    template<std::forward_iterator I, std::sentinel_for<I> S, class Proj = std::identity,
             std::indirect_strict_weak_order<std::projected<I, Proj>> Comp = ranges::less>
    constexpr ranges::minmax_element_result<I>
        operator()(I first, S last, Comp comp = {}, Proj proj = {}) const
    {
        auto min = first, max = first;
        if (first == last || ++first == last)
            return {min, max};
        if (std::invoke(comp, std::invoke(proj, *first),
                              std::invoke(proj, *min)))
            min = first;
        else
            max = first;
        while (++first != last)
        {
            auto i = first;
            if (++first == last)
            {
                if (std::invoke(comp, std::invoke(proj, *i),
                                      std::invoke(proj, *min)))
                    min = i;
                else if (!(std::invoke(comp, std::invoke(proj, *i),
                                             std::invoke(proj, *max))))
                    max = i;
                break;
            }
            else
            {
                if (std::invoke(comp, std::invoke(proj, *first),
                                      std::invoke(proj, *i)))
                {
                  if (std::invoke(comp, std::invoke(proj, *first),
                                        std::invoke(proj, *min)))
                      min = first;
                  if (!(std::invoke(comp, std::invoke(proj, *i),
                                          std::invoke(proj, *max))))
                      max = i;
                }
                else
                {
                    if (std::invoke(comp, std::invoke(proj, *i),
                                          std::invoke(proj, *min)))
                        min = i;
                    if (!(std::invoke(comp, std::invoke(proj, *first),
                                            std::invoke(proj, *max))))
                        max = first;
                }
            }
        }
        return {min, max};
    }
    template<ranges::forward_range R, class Proj = std::identity,
             std::indirect_strict_weak_order<
                 std::projected<ranges::iterator_t<R>, Proj>> Comp = ranges::less>
    constexpr ranges::minmax_element_result<ranges::borrowed_iterator_t<R>>
        operator()(R&& r, Comp comp = {}, Proj proj = {}) const
    {
        return (*this)(ranges::begin(r), ranges::end</

示例

#include <algorithm>
#include <iostream>
#include <iterator>
namespace ranges = std::ranges;
int main()
{
    const auto v = {3, 9, 1, 4, 1, 2, 5, 9};
    const auto [min, max] = ranges::minmax_element(v);
    std::cout
        << "min = " << *min << ", at [" << ranges::distance(v.begin(), min) << "]\n"
        << "max = " << *max << ", at [" << ranges::distance(v.begin(), max) << "]\n";
}

输出:

min = 1, at [2]
max = 9, at [7]

参见

返回范围中的最小元素
(算法函数对象)
返回范围中的最大元素
(算法函数对象)
返回两个元素中的较小者和较大者
(算法函数对象)
返回范围中的最小和最大元素
(函数模板)