std::ranges::minmax_element, std::ranges::minmax_element_result
| Definiert im Header <algorithm>
|
||
| Aufrufsignatur |
||
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) | (seit 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) | (seit C++20) |
| Hilfstypen |
||
template< class I >
using minmax_element_result = ranges::min_max_result<I>;
|
(3) | (seit C++20) |
[first, last).r als Quellbereich, als ob ranges::begin(r) als first und ranges::end(r) als last.Die auf dieser Seite beschriebenen funktionsähnlichen Entitäten sind Algorithmus-Funktionsobjekte (informell bekannt als niebloids), das heißt:
- Explizite Vorlagenargumentlisten können beim Aufruf keiner von ihnen angegeben werden.
- Keine von ihnen ist für die argumentabhängige Suche sichtbar.
- Wenn einer von ihnen durch normale unqualifizierte Suche als Name links des Funktionsaufrufoperators gefunden wird, wird die argumentabhängige Suche unterdrückt.
Parameter
| first, last | - | das Iterator-Sentinel-Paar, das den Bereich der zu untersuchenden Elemente definiert |
| r | - |
der zu untersuchende
range
|
| comp | - | Vergleich, der auf die projizierten Elemente angewendet wird |
| proj | - | Projektion, die auf die Elemente angewendet wird |
Rückgabewert
Ein Objekt, das aus einem Iterator zum kleinsten Element als erstes Element und einem Iterator zum größten Element als zweites Element besteht. Gibt { first, first } zurück, wenn der Bereich leer ist. Falls mehrere Elemente dem kleinsten Element entsprechen, wird der Iterator zum ersten solchen Element zurückgegeben. Falls mehrere Elemente dem größten Element entsprechen, wird der Iterator zum letzten solchen Element zurückgegeben.
Komplexität
Höchstens std:: max ( std:: floor ( 1.5 * ( N − 1 ) ) , 0.0 ) Anwendungen des Vergleichs und doppelt so viele Anwendungen der Projektion, wobei N = ranges:: distance ( first, last ) .
Mögliche Implementierung
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; |
Beispiel
#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"; }
Ausgabe:
min = 1, at [2] max = 9, at [7]
Siehe auch
|
(C++20)
|
gibt das kleinste Element in einem Bereich zurück
(Algorithmus-Funktionsobjekt) |
|
(C++20)
|
gibt das größte Element in einem Bereich zurück
(Algorithmus-Funktionsobjekt) |
|
(C++20)
|
gibt das kleinere und größere von zwei Elementen zurück
(Algorithmus-Funktionsobjekt) |
|
(C++11)
|
gibt die kleinsten und größten Elemente in einem Bereich zurück
(Funktions-Template) |