Difference between revisions of "cpp/algorithm/ranges/min element"
From cppreference.com
m (→Return value: should return iterator but not sentinel) |
|||
| (6 intermediate revisions by 3 users not shown) | |||
| Line 2: | Line 2: | ||
{{cpp/algorithm/ranges/navbar}} | {{cpp/algorithm/ranges/navbar}} | ||
{{dcl begin}} | {{dcl begin}} | ||
| − | {{dcl header | algorithm}} | + | {{dcl header|algorithm}} |
| − | {{dcl h | Call signature}} | + | {{dcl h|Call signature}} |
| − | {{dcl | since=c++20 | num=1 | 1= | + | {{dcl|since=c++20|num=1|1= |
template< std::forward_iterator I, std::sentinel_for<I> S, class Proj = std::identity, | 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 > | std::indirect_strict_weak_order<std::projected<I, Proj>> Comp = ranges::less > | ||
| − | constexpr I min_element( I first, S last, Comp comp = {}, Proj proj = {} ); | + | constexpr I |
| + | min_element( I first, S last, Comp comp = {}, Proj proj = {} ); | ||
}} | }} | ||
| − | {{dcl | since=c++20 | num=2 | 1= | + | {{dcl|since=c++20|num=2|1= |
template< ranges::forward_range R, class Proj = std::identity, | template< ranges::forward_range R, class Proj = std::identity, | ||
std::indirect_strict_weak_order< | std::indirect_strict_weak_order< | ||
std::projected<ranges::iterator_t<R>, Proj>> Comp = ranges::less > | std::projected<ranges::iterator_t<R>, Proj>> Comp = ranges::less > | ||
constexpr ranges::borrowed_iterator_t<R> | constexpr ranges::borrowed_iterator_t<R> | ||
| − | min_element( R&& r, Comp comp = {}, Proj proj = {} ); | + | min_element( R&& r, Comp comp = {}, Proj proj = {} ); |
}} | }} | ||
{{dcl end}} | {{dcl end}} | ||
| − | @1@ Finds the smallest element in the range {{ | + | @1@ Finds the smallest element in the range {{|firstlast}}. |
| − | @2@ Same as {{v|1}}, but uses {{ | + | @2@ Same as {{v|1}}, but uses {{|r}} as the source range, as if using {{c|ranges::begin(r)}} as {{|first}} and {{c|ranges::end(r)}} as {{|last}}. |
{{cpp/ranges/niebloid}} | {{cpp/ranges/niebloid}} | ||
| Line 25: | Line 26: | ||
===Parameters=== | ===Parameters=== | ||
{{par begin}} | {{par begin}} | ||
| − | {{par | + | {{par rangeto examine}} |
| − | {{par | r | the range to examine}} | + | {{par|r|the rangeto examine}} |
| − | {{par | comp | comparison to apply to the projected elements}} | + | {{par|comp|comparison to apply to the projected elements}} |
| − | {{par | proj | projection to apply to the elements}} | + | {{par|proj|projection to apply to the elements}} |
{{par end}} | {{par end}} | ||
===Return value=== | ===Return value=== | ||
| − | Iterator to the smallest element in the range {{ | + | Iterator to the smallest element in the range {{|firstlast}}. If several elements in the range are equivalent to the smallest element, returns the iterator to the first such element. Returns {{|}} if the range is empty . |
===Complexity=== | ===Complexity=== | ||
| − | Exactly {{math|max(N-1,0)}} comparisons, where {{c|N | + | Exactly {{math|max(N - 1, 0)}} comparisons, where {{c|N = ranges::distance(first, last)}}. |
===Possible implementation=== | ===Possible implementation=== | ||
{{eq fun | {{eq fun | ||
| − | + | |1= | |
| − | struct min_element_fn { | + | 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 | ||
| + | |||
| + | |||
| + | |||
| + | |||
| + | ; | ||
} | } | ||
| − | + | ||
| − | + | = | |
| − | + | ||
| − | + | ||
| − | + | ||
| − | + | (= ) | |
| − | + | { | |
| + | (::(, ::(, ), std::(proj)); | ||
} | } | ||
| − | |||
| − | |||
| − | |||
| − | |||
| − | |||
| − | |||
| − | |||
| − | |||
| − | |||
| − | |||
| − | |||
}; | }; | ||
| Line 74: | Line 71: | ||
===Example=== | ===Example=== | ||
{{example | {{example | ||
| − | + | |code= | |
| − | + | ||
#include <algorithm> | #include <algorithm> | ||
| + | |||
| + | |||
#include <iostream> | #include <iostream> | ||
| − | + | ||
| − | + | ||
| − | + | ||
int main() | int main() | ||
{ | { | ||
| − | |||
| − | |||
namespace ranges = std::ranges; | namespace ranges = std::ranges; | ||
| − | auto | + | |
| − | + | ||
| − | + | ||
| + | auto = ranges::min_element(v.begin(), v.end()); | ||
| + | ranges::distance(v.begin(), ) | ||
| + | << '\n'; | ||
| + | |||
auto abs_compare = [](int a, int b) { return (std::abs(a) < std::abs(b)); }; | auto abs_compare = [](int a, int b) { return (std::abs(a) < std::abs(b)); }; | ||
| − | + | = ranges::min_element(v, abs_compare); | |
| − | + | ranges::distance(v.begin(), ) | |
| + | << '\n'; | ||
} | } | ||
| − | + | |output= | |
| − | min element | + | min element 2 |
| − | min element | + | minelement 1 |
}} | }} | ||
===See also=== | ===See also=== | ||
{{dsc begin}} | {{dsc begin}} | ||
| − | {{dsc inc | cpp/algorithm/ranges/dsc max_element}} | + | {{dsc inc|cpp/algorithm/ranges/dsc max_element}} |
| − | {{dsc inc | cpp/algorithm/ranges/dsc minmax_element}} | + | {{dsc inc|cpp/algorithm/ranges/dsc minmax_element}} |
| − | {{dsc inc | cpp/algorithm/ranges/dsc max}} | + | {{dsc inc|cpp/algorithm/ranges/dsc max}} |
| − | {{dsc inc | cpp/algorithm/dsc min_element}} | + | {{dsc inc|cpp/algorithm/dsc min_element}} |
{{dsc end}} | {{dsc end}} | ||
{{langlinks|de|es|fr|it|ja|pt|ru|zh}} | {{langlinks|de|es|fr|it|ja|pt|ru|zh}} | ||
Latest revision as of 02:55, 26 March 2025
| 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 > |
(1) | (since C++20) |
| template< ranges::forward_range R, class Proj = std::identity, std::indirect_strict_weak_order< |
(2) | (since C++20) |
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.
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
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
[edit] See also
| (C++20) |
returns the largest element in a range (algorithm function object) |
| (C++20) |
returns the smallest and the largest elements in a range (algorithm function object) |
| (C++20) |
returns the greater of the given values (algorithm function object) |
| returns the smallest element in a range (function template) |
