std::ranges::min
Depuis fr.cppreference.net
| Défini dans l'en-tête <algorithm>
|
||
| Signatures 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&
min( 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
min( 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>
min( R&& r, Comp comp = {}, Proj proj = {} );
|
(3) | (depuis C++20) |
Renvoie le plus petit des éléments projetés donnés.
1) Renvoie le plus petit de
a et b.2) Renvoie le premier plus petit élément de la liste d'initialisation
r.3) Renvoie la première plus petite 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 niebloids), c'est-à-dire :
- Les listes d'arguments de modèle explicites ne peuvent pas être spécifiées lors de l'appel de l'une d'elles.
- Aucune d'elles n'est visible par recherche dépendante des arguments.
- Lorsque l'une d'elles est trouvée par recherche non qualifiée normale comme le 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 petit de
a
et
b
, selon la projection. S'ils sont équivalents, retourne
a
.
2,3)
L'élément le plus petit dans
r
, selon la projection. Si plusieurs valeurs sont équivalentes au plus petit, retourne celui le 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 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; |
Notes
Capturer le résultat de
std::ranges::min
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::min(n + 2, n * 2); // r est pendante
Exemple
Exécuter ce 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" << "shortest of \"foo\", \"bar\", and \"hello\": \"" << ranges::min({"foo"sv, "bar"sv, "hello"sv}, {}, &std::string_view::size) << "\"\n"; }
Sortie :
smaller of 1 and 9999: 1 smaller of 'a', and 'b': 'a' shortest of "foo", "bar", and "hello": "foo"
Voir aussi
|
(C++20)
|
renvoie la plus grande 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 petit é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 petite des valeurs données
(modèle de fonction) |