std::min

Défini dans l'en-tête `<algorithm>`
template< class T > const T& min( const T& a, const T& b );	(1)	(constexpr depuis C++14)
template< class T, class Compare > const T& min( const T& a, const T& b, Compare comp );	(2)	(constexpr depuis C++14)
template< class T > T min( std::initializer_list<T> ilist );	(3)	(depuis C++11) (constexpr depuis C++14)
template< class T, class Compare > T min( std::initializer_list<T> ilist, Compare comp );	(4)	(depuis C++11) (constexpr depuis C++14)

Retourne la plus petite des valeurs données.

1,2) Retourne la plus petite de a et b.

1) Utilise operator< pour comparer les valeurs.

Si T n'est pas LessThanComparable, le comportement est indéfini.

2) Utilise la fonction de comparaison comp pour comparer les valeurs.

3,4) Retourne la plus petite des valeurs dans la liste d'initialisation ilist.

Si ilist.size() vaut zéro, ou si T n'est pas CopyConstructible, le comportement est indéfini.

3) Utilise operator< pour comparer les valeurs.

Si T n'est pas LessThanComparable, le comportement est indéfini.

4) Utilise la fonction de comparaison comp pour comparer les valeurs.

Paramètres

a, b - les valeurs à comparer

ilist - liste d'initialisation avec les valeurs à comparer

cmp

-

objet fonction de comparaison (c'est-à-dire un objet qui satisfait aux exigences de Compare) qui retourne true si a est inférieur à b.

La signature de la fonction de comparaison doit être équivalente à ce qui suit :

bool cmp(const Type1& a, const Type2& b);

Bien que la signature n'ait pas besoin d'avoir const&, la fonction ne doit pas modifier les objets qui lui sont passés et doit pouvoir accepter toutes les valeurs de type (éventuellement const) Type1 et Type2 indépendamment de la catégorie de valeur (ainsi, Type1& n'est pas autorisé, ni Type1 sauf si pour Type1 un déplacement est équivalent à une copie(depuis C++11)).
Les types Type1 et Type2 doivent être tels qu'un objet de type T puisse être implicitement converti vers les deux.

Valeur de retour

1,2) La plus petite de a et b. Si les valeurs sont équivalentes, retourne a.

3,4) La plus petite valeur dans ilist. Si plusieurs valeurs sont équivalentes à la plus petite, retourne celle située le plus à gauche.

Complexité

1) Exactement une comparaison utilisant operator<.

2) Exactement une application de la fonction de comparaison comp.

3,4) Étant donné

N

comme ilist.size():

3) Exactement

N-1

comparaisons utilisant operator<.

4) Exactement

N-1

applications de la fonction de comparaison comp.

Implémentation possible

min (1)
template<class T> const T& min(const T& a, const T& b) { return (b < a) ? b : a; }
min (2)
template<class T, class Compare> const T& min(const T& a, const T& b, Compare comp) { return (comp(b, a)) ? b : a; }
min (3)
template<class T> T min(std::initializer_list<T> ilist) { return *std::min_element(ilist.begin(), ilist.end()); }
min (4)
template<class T, class Compare> T min(std::initializer_list<T> ilist, Compare comp) { return *std::min_element(ilist.begin(), ilist.end(), comp); }

Notes

Capturer le résultat de std::min par référence produit une référence pendante si l'un des paramètres est une temporaire et que ce paramètre est retourné :

int n = -1;
const int& r = std::min(n + 2, n * 2); // r is dangling

Exemple

Exécuter ce code

#include <algorithm>
#include <iostream>
#include <string_view>

int main()
{
    std::cout << "smaller of 10 and 010 is " << std::min(10, 010) << '\n'
              << "smaller of 'd' and 'b' is '" << std::min('d', 'b') << "'\n"
              << "shortest of \"foo\", \"bar\", and \"hello\" is \""
              << std::min({"foo", "bar", "hello"},
                          [](const std::string_view s1, const std::string_view s2)
                          {
                              return s1.size() < s2.size();
                          }) << "\"\n";
}

Sortie :

smaller of 10 and 010 is 8
smaller of 'd' and 'b' is 'b'
shortest of "foo", "bar", and "hello" is "foo"

Rapports de défauts

Les rapports de défauts suivants, modifiant le comportement, ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR	Appliqué à	Comportement tel que publié	Comportement correct
LWG 281	C++98	`T` était requis d'être CopyConstructible pour les surcharges (1,2)	non requis
LWG 2239	C++98 C++11	1. `T` était requis d'être LessThanComparable pour les surcharges (2) (C++98) et (4) (C++11) 2. les exigences de complexité manquaient	1. non requis 2. ajouté les exigences

Voir aussi

max	retourne la plus grande des valeurs données (modèle de fonction & objet fonction d'algorithme)
ranges::max (C++20)
minmax (C++11)	retourne le plus petit et le plus grand de deux éléments (modèle de fonction & objet fonction d'algorithme)
ranges::minmax (C++20)
min_element	retourne le plus petit élément d'une plage (modèle de fonction & objet fonction d'algorithme)
ranges::min_element (C++20)
clamp (C++17)	limite une valeur entre une paire de valeurs limites (modèle de fonction & objet fonction d'algorithme)
ranges::clamp (C++20)
ranges::min (C++20)	retourne la plus petite des valeurs données (objet fonction d'algorithme)

Support du compilateur
Freestanding et hébergé
Langage
Bibliothèque standard
En-têtes de la bibliothèque standard
Exigences nommées
Macros de test de fonctionnalités (C++20)
Bibliothèque de support linguistique
Bibliothèque de concepts (C++20)
Bibliothèque de diagnostics
Bibliothèque de gestion de la mémoire
Bibliothèque de métaprogrammation (C++11)
Bibliothèque d'utilitaires généraux
Bibliothèque de conteneurs
Bibliothèque d'itérateurs
Bibliothèque de plages (C++20)
Bibliothèque d'algorithmes
Bibliothèque de chaînes
Bibliothèque de traitement du texte
Bibliothèque numérique
Bibliothèque de date et d'heure
Bibliothèque d'entrée/sortie
Bibliothèque du système de fichiers (C++17)
Bibliothèque de support de la concurrence (C++11)
Bibliothèque de contrôle d'exécution (C++26)
Spécifications techniques
Index des symboles
Bibliothèques externes

fr.cppreference.net

Namespaces

Variants