std::ranges::min
From cppreference.com
| Defined in header <algorithm>
|
||
| Call signature |
||
template< class T, class Proj = std::identity,
std::indirect_strict_weak_order
<std::projected<const T*, Proj>> Comp = ranges::less >
constexpr const T&
min( const T& a, const T& b, Comp comp = {}, Proj proj = {} );
|
(1) | (since C++20) |
template< std::copyable T, class Proj = std::identity,
std::indirect_strict_weak_order
<std::projected<const T*, Proj>> Comp = ranges::less >
constexpr T
min( std::initializer_list<T> r, Comp comp = {}, Proj proj = {} );
|
(2) | (since C++20) |
template< ranges::input_range R, class Proj = std::identity,
std::indirect_strict_weak_order
<std::projected<ranges::iterator_t<R>,
Proj>> Comp = ranges::less >
requires std::indirectly_copyable_storable<ranges::iterator_t<R>,
ranges::range_value_t<R>*>
constexpr ranges::range_value_t<R>
min( R&& r, Comp comp = {}, Proj proj = {} );
|
(3) | (since C++20) |
template< /*execution-policy*/ Ep, /*sized-random-access-range*/ R,
class Proj = std::identity,
std::indirect_strict_weak_order
<std::projected<ranges::iterator_t<R>,
Proj>> Comp = ranges::less >
requires std::indirectly_copyable_storable<ranges::iterator_t<R>,
ranges::range_value_t<R>*>
ranges::range_value_t<R>
min( Ep&& policy, R&& r, Comp comp = {}, Proj proj = {} );
|
(4) | (since C++26) |
For the definition of /*execution-policy*/, see this page; for the definition of /*sized-random-access-range*/, see this page.
Returns the smaller of the given values (projected by proj), the projected values are compared using comp.
1) Returns the smaller of
a and b.2-4) Returns the first smallest value in the initializer list or target range
r. If
ranges::distance(r) is zero, the behavior is undefined.4) Same as (3), but executed according to
policy.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.
Parameters
| a, b | - | the values to compare |
| r | - | the range of values to compare |
| comp | - | the comparator to be applied to the (projected) elements |
| proj | - | the projection to be applied to the elements |
| policy | - | the execution policy to use |
Return value
1) The smaller of
a and b, according to their respective projected values. If they are equivalent, returns a.2-4) The smallest value in
r, according to the projection. If there are multiple smallest values, returns the first one of them.Complexity
1) Exactly one application of
comp, and two applications of proj.2-4) Given N as
ranges::distance(r):2,3) Exactly N-1 applications of
comp, and twice as many applications of proj.4) 𝓞(N) applications of
comp, and twice as many applications of proj.Exceptions
4) During the execution process:
- If the temporary memory resources required for parallelization are not available, std::bad_alloc is thrown.
- If an uncaught exception is thrown while accessing objects via an algorithm argument, the behavior is determined by the execution policy (for standard policies, std::terminate is invoked).
Notes
Capturing the result of std::ranges::min by reference produces a dangling reference if one of the parameters is a temporary and that parameter is returned:
int n = -1;
const int& r = std::ranges::min(n + 2, n * 2); // r is dangling
Possible implementation
struct min_fn
{
template<class T, class Proj = std::identity,
std::indirect_strict_weak_order
<std::projected<const T*, Proj>> Comp = ranges::less>
constexpr const T& operator()(const T& a, const T& b,
Comp comp = {}, Proj proj = {}) const
{
return std::invoke(comp, std::invoke(proj, b), std::invoke(proj, a)) ? b : a;
}
template<std::copyable T, class Proj = std::identity,
std::indirect_strict_weak_order
<std::projected<const T*, Proj>> Comp = ranges::less>
constexpr T operator()(std::initializer_list<T> r,
Comp comp = {}, Proj proj = {}) const
{
return *ranges::min_element(r, std::ref(comp), std::ref(proj));
}
template<ranges::input_range R, class Proj = std::identity,
std::indirect_strict_weak_order
<std::projected<ranges::iterator_t<R>, Proj>> Comp = ranges::less>
requires std::indirectly_copyable_storable<ranges::iterator_t<R>,
ranges::range_value_t<R>*>
constexpr ranges::range_value_t<R> operator()(R&& r, Comp comp = {},
Proj proj = {}) const
{
using V = ranges::range_value_t<R>;
if constexpr (ranges::forward_range<R>)
return static_cast<V>(*ranges::min_element(r, std::ref(comp),
std::ref(proj)));
else
{
auto i = ranges::begin(r);
auto s = ranges::end(r);
V m(*i);
while (++i != s)
if (std::invoke(comp, std::invoke(proj, *i), std::invoke(proj, m)))
m = *i;
return m;
}
}
};
inline constexpr min_fn min;
|
Example
Run this code
#include <algorithm>
#include <iostream>
#include <string>
int main()
{
namespace ranges = std::ranges;
using namespace std::string_view_literals;
std::cout << "Smaller of 1 and 9999: " << ranges::min(1, 9999) << '\n'
<< "Smaller of 'a' and 'b': '" << ranges::min('a', 'b') << "'\n"
<< R"(Shortest of "foo", "bar", and "hello": )"
<< ranges::min({"foo"sv, "bar"sv, "hello"sv}, {},
&std::string_view::size) << "\"\n";
}
Output:
Smaller of 1 and 9999: 1
Smaller of 'a' and 'b': 'a'
Shortest of "foo", "bar", and "hello": "foo"
See also
| returns the smaller of the given values (function template) | |
(C++20) |
returns the greater of the given values (algorithm function object) |
(C++20) |
returns the smaller and larger of two elements (algorithm function object) |
(C++20) |
returns the smallest element in a range (algorithm function object) |
(C++20) |
clamps a value between a pair of boundary values (algorithm function object) |