std::ranges::minmax_element, std::ranges::minmax_element_result
| Défini dans l'en-tête <algorithm>
|
||
| Signature d'appel |
||
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) | (depuis 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) | (depuis C++20) |
| Types auxiliaires |
||
template< class I >
using minmax_element_result = ranges::min_max_result<I>;
|
(3) | (depuis C++20) |
[first, last).r comme intervalle source, comme si on utilisait ranges::begin(r) comme first et ranges::end(r) comme last.Les entités de type fonction décrites sur cette page sont des objets fonction d'algorithme (informellement appelés niebloïdes), c'est-à-dire :
- Les listes explicites d'arguments de modèle ne peuvent pas être spécifiées lors de l'appel de l'une d'elles.
- Aucune d'elles n'est visible par la recherche dépendante des arguments.
- Lorsque l'une d'elles est trouvée par une recherche non qualifiée normale comme nom à gauche de l'opérateur d'appel de fonction, la recherche dépendante des arguments est inhibée.
Paramètres
| first, last | - | la paire itérateur-sentinelle définissant la plage d'éléments à examiner |
| r | - |
la
range
à examiner
|
| comp | - | comparaison à appliquer aux éléments projetés |
| proj | - | projection à appliquer aux éléments |
Valeur de retour
Un objet constitué d'un itérateur vers le plus petit élément comme premier élément et d'un itérateur vers le plus grand élément comme second. Renvoie { first, first } si la plage est vide. Si plusieurs éléments sont équivalents au plus petit élément, l'itérateur vers le premier de ces éléments est renvoyé. Si plusieurs éléments sont équivalents au plus grand élément, l'itérateur vers le dernier de ces éléments est renvoyé.
Complexité
Au plus std:: max ( std:: floor ( 1.5 * ( N − 1 ) ) , 0.0 ) applications de la comparaison et deux fois plus d'applications de la projection, où N = ranges:: distance ( first, last ) .
Implémentation possible
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; |
Exemple
#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"; }
Sortie :
min = 1, at [2] max = 9, at [7]
Voir aussi
|
(C++20)
|
retourne le plus petit élément dans une plage
(objet fonction algorithme) |
|
(C++20)
|
retourne le plus grand élément dans une plage
(objet fonction algorithme) |
|
(C++20)
|
retourne le plus petit et le plus grand de deux éléments
(objet fonction algorithme) |
|
(C++11)
|
retourne les plus petits et les plus grands éléments dans une plage
(modèle de fonction) |