std::ranges::max
De fr.cppreference.net
| Défini dans l'en-tête <algorithm>
|
||
| Signature d'appel |
||
template< class T, class Proj = std::identity,
std::indirect_strict_weak_order<
std::projected<const T*, Proj>> Comp = ranges::less >
constexpr const T&
max( const T& a, const T& b, Comp comp = {}, Proj proj = {} );
|
(1) | (depuis 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
max( std::initializer_list<T> r, Comp comp = {}, Proj proj = {} );
|
(2) | (depuis 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>
max( R&& r, Comp comp = {}, Proj proj = {} );
|
(3) | (depuis C++20) |
Retourne la plus grande des valeurs projetées données.
1) Retourne la plus grande de
a et b.2) Retourne la première plus grande valeur dans la liste d'initialisation
r.3) Retourne la première plus grande valeur dans la plage
r.Les entités de type fonction décrites sur cette page sont des objets fonctions d'algorithme (informellement appelés niebloïdes), c'est-à-dire :
- Les listes d'arguments template explicites ne peuvent pas être spécifiées lors de l'appel de l'un d'eux.
- Aucun d'eux n'est visible par la recherche dépendante des arguments.
- Lorsque l'un d'eux est trouvé par 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
| a, b | - | les valeurs à comparer |
| r | - | la plage de valeurs à comparer |
| comp | - | comparaison à appliquer aux éléments projetés |
| proj | - | projection à appliquer aux éléments |
Valeur de retour
1)
Le plus grand de
a
et
b
, selon leurs valeurs projetées respectives. S'ils sont équivalents, retourne
a
.
2,3)
La valeur maximale dans
r
, selon la projection. Si plusieurs valeurs sont équivalentes au maximum, retourne celle la plus à gauche. Si la plage est vide (tel que déterminé par
ranges::
distance
(
r
)
), le comportement est indéfini.
Complexité
1)
Exactement une comparaison.
2,3)
Exactement
ranges::
distance
(
r
)
-
1
comparaisons.
Implémentation possible
struct max_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, a), std::invoke(proj, b)) ? 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::max_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::max_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, m), std::invoke(proj, *i))) m = *i; return m; } } }; inline constexpr max_fn max; |
Notes
Capturer le résultat de
std::ranges::max
par référence produit une référence pendante si l'un des paramètres est un temporaire et que ce paramètre est retourné :
int n = -1; const int& r = std::ranges::max(n + 2, n * 2); // r est pendante
Exemple
Exécuter ce code
#include <algorithm> #include <iostream> #include <string> static_assert(std::ranges::max({0B10, 0X10, 010, 10}) == 16); // overload (2) int main() { namespace ranges = std::ranges; using namespace std::string_view_literals; std::cout << "plus grand entre 1 et 9999 : " << ranges::max(1, 9999) << '\n' << "plus grand entre 'a' et 'b' : '" << ranges::max('a', 'b') << "'\n" << "plus long parmi \"foo\", \"bar\" et \"hello\" : \"" << ranges::max({"foo"sv, "bar"sv, "hello"sv}, {}, &std::string_view::size) << "\"\n"; }
Sortie :
plus grand entre 1 et 9999 : 9999 plus grand entre 'a' et 'b' : 'b' plus long parmi "foo", "bar" et "hello" : "hello"
Voir aussi
|
(C++20)
|
renvoie la plus petite des valeurs données
(objet fonction algorithme) |
|
(C++20)
|
renvoie le plus petit et le plus grand de deux éléments
(objet fonction algorithme) |
|
(C++20)
|
renvoie le plus grand élément d'une plage
(objet fonction algorithme) |
|
(C++20)
|
limite une valeur entre une paire de valeurs limites
(objet fonction algorithme) |
|
renvoie la plus grande des valeurs données
(modèle de fonction) |