std::ranges::min_element
From cppreference.com
C++
Feature test macros (C++20)
Concepts library (C++20)
Metaprogramming library (C++11)
Ranges library (C++20)
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Algorithm library
Constrained algorithms, e.g. ranges::copy, ranges::sort, ...
(C++17)
(C++17) (C++17)(C++17)(C++20)
(C++17)
(C++11)
(until C++17)(C++11)
(C++20)(C++20)
(C++17)
(C++17)
(C++17)
(C++17)
Constrained algorithms
All names in this menu belong to namespace
std::ranges
(C++23)
(C++23)
(C++23)
(C++23)
(C++23)
(C++23)
(C++23)
Defined in header
<algorithm>
Call signature
template< std::forward_iterator I, std::sentinel_for <I> S, class Proj = std::identity,
(1)
(since C++20)
std::indirect_strict_weak_order <std::projected <I, Proj>> Comp = ranges::less >
constexpr I
template< ranges::forward_range R, class Proj = std::identity,
(2)
(since C++20)
std::indirect_strict_weak_order <
std::projected <ranges::iterator_t <R>, Proj>> Comp = ranges::less >
constexpr ranges::borrowed_iterator_t <R>
1) Finds the smallest element 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:
- Explicit template argument lists cannot be specified when calling any of them.
- None of them are visible to argument-dependent lookup.
- When any of them are found by normal unqualified lookup as the name to the left of the function-call operator, argument-dependent lookup is inhibited.
[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
Iterator to the smallest element in the range [first, last). If several elements in the range are equivalent to the smallest element, returns the iterator to the first such element. Returns the iterator that compares equal to last if the range is empty (i.e., first == last).
[edit] Complexity
Exactly max(N - 1, 0) comparisons, where N = ranges::distance (first, last).
[edit] Possible implementation
struct min_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 I operator()(I first, S last, Comp comp = {}, Proj proj = {}) const { if (first == last) return last; auto smallest = first; while (++first != last) if (std::invoke (comp, std::invoke (proj, *first), std::invoke (proj, *smallest))) smallest = first; return smallest; } 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::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 min_element_fn min_element;
[edit] Example
Run this code
#include <algorithm> #include <array> #include <cmath> #include <iostream> int main() { namespace ranges = std::ranges; std::array v{3, 1, -13, 1, 3, 7, -13}; auto iterator = ranges::min_element(v.begin(), v.end()); auto position = ranges::distance (v.begin(), iterator); std::cout << "min element is v[" << position << "] == " << *iterator << '\n'; auto abs_compare = [](int a, int b) { return (std::abs(a) < std::abs(b)); }; iterator = ranges::min_element(v, abs_compare); position = ranges::distance (v.begin(), iterator); std::cout << "|min| element is v[" << position << "] == " << *iterator << '\n'; }
Output:
min element is v[2] == -13 |min| element is v[1] == 1