Namespaces
Variants
Actions

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

From cppreference.com
< cpp‎ | algorithm‎ | ranges
 
C++
 
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
(C++11)                (C++11)(C++11)

Modifying sequence operations
Copy operations
(C++11)
(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
(C++11)
(C++17)
Lexicographical comparison operations
(C++20)
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
       
       
minmax_element
   
Permutation operations
Fold operations
Numeric operations
(C++23)            
Operations on uninitialized storage
Return types
 
Defined in header <algorithm>
Call signature
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) (since 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) (since C++20)
Helper types
template< class I >
using minmax_element_result = ranges::min_max_result<I>;
 (3) (since C++20)
1) Finds the smallest and largest elements in the range [first, last).
2) Same as (1), but uses r as the source range, as if using ranges::begin(r) as first and ranges::end(r) as last.

The function-like entities described on this page are algorithm function objects (informally known as niebloids), that is:

Contents

[edit] Parameters

first, last - the iterator-sentinel pair defining the range of elements to examine
r - the range to examine
comp - comparison to apply to the projected elements
proj - projection to apply to the elements.

[edit] Return value

An object consisting of an iterator to the smallest element as the first element and an iterator to the greatest element as the second. Returns {first, first} if the range is empty. If several elements are equivalent to the smallest element, the iterator to the first such element is returned. If several elements are equivalent to the largest element, the iterator to the last such element is returned.

[edit] Complexity

At most std::max(std::floor(1.5 * (N − 1)), 0.0) applications of the comparison and twice as many applications of the projection, where N = ranges::distance(first, last).

[