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

定义在头文件中 `<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	-	要检查的范围
comp	-	应用于投影元素的比较
proj	-	应用于元素的投影。

[编辑] 返回值

一个包含指向最小元素的迭代器的第一个元素和指向最大元素的迭代器的第二个元素的对象。如果范围为空，则返回 {first, first}。如果多个元素与最小元素等效，则返回指向第一个 such 元素的迭代器。如果多个元素与最大元素等效，则返回指向最后一个 such 元素的迭代器。

[编辑] 复杂度

最多 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(r), std::ref(comp), std::ref(proj));
    }
};
 
inline constexpr minmax_element_fn minmax_element;

[编辑] 示例

运行这段代码

#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]

[编辑] 参见

ranges::min_element (C++20)	返回范围内最小的元素 (niebloid)[编辑]
ranges::max_element (C++20)	返回范围内最大的元素 (niebloid)[编辑]
ranges::minmax (C++20)	返回两个元素中较小和较大的元素 (niebloid)[编辑]
minmax_element (C++11)	返回范围内最小和最大的元素 (函数模板) [编辑]

编译器支持
独立和托管
语言
标准库
标准库头文件
命名需求
特性测试宏 (C++20)
语言支持库
概念库 (C++20)
元编程库 (C++11)
诊断库
通用实用程序库
字符串库
容器库
迭代器库
范围库 (C++20)
算法库
数值库
本地化库
输入/输出库
文件系统库 (C++17)
正则表达式库 (C++11)
并发支持库 (C++11)
执行支持库 (C++26)
技术规范
符号索引
外部库

cppreference.com

命名空间

变体

视图

操作