std::ranges::minmax_element, std::ranges::minmax_element_result
| Definido en el encabezado <algorithm>
|
||
| Firma de la llamada |
||
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) | (desde 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) | (desde C++20) |
| Tipos auxiliares |
||
template< class I >
using minmax_element_result = ranges::min_max_result<I>;
|
(3) | (desde C++20) |
[first, last).r como rango fuente, como si se usara ranges::begin(r) como first y ranges::end(r) como last.Las entidades similares a funciones descritas en esta página son objetos función de algoritmo (conocidos informalmente como niebloids), es decir:
- No se pueden especificar listas de argumentos de plantilla explícitas al llamar a ninguno de ellos.
- Ninguno de ellos es visible para la búsqueda dependiente de argumentos.
- Cuando cualquiera de ellos es encontrado por búsqueda normal no calificada como el nombre a la izquierda del operador de llamada a función, la búsqueda dependiente de argumentos se inhibe.
Parámetros
| first, last | - | el par iterador-centinela que define el rango de elementos a examinar |
| r | - |
el
range
a examinar
|
| comp | - | comparación a aplicar a los elementos proyectados |
| proj | - | proyección a aplicar a los elementos. |
Valor de retorno
Un objeto que consiste en un iterador al elemento más pequeño como primer elemento y un iterador al elemento más grande como segundo. Devuelve { first, first } si el rango está vacío. Si varios elementos son equivalentes al elemento más pequeño, se devuelve el iterador al primer elemento de este tipo. Si varios elementos son equivalentes al elemento más grande, se devuelve el iterador al último elemento de este tipo.
Complejidad
Como máximo std:: max ( std:: floor ( 1.5 * ( N − 1 ) ) , 0.0 ) aplicaciones de la comparación y el doble de aplicaciones de la proyección, donde N = ranges:: distance ( first, last ) .
Implementación posible
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; |
Ejemplo
#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"; }
Salida:
min = 1, at [2] max = 9, at [7]
Véase también
|
(C++20)
|
devuelve el elemento más pequeño en un rango
(objeto función de algoritmo) |
|
(C++20)
|
devuelve el elemento más grande en un rango
(objeto función de algoritmo) |
|
(C++20)
|
devuelve el menor y el mayor de dos elementos
(objeto función de algoritmo) |
|
(C++11)
|
devuelve los elementos más pequeño y más grande en un rango
(plantilla de función) |