Namespaces
Variants

std:: min

From cppreference.net
C++
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy , ranges::sort , ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
Modifying sequence operations
Copy operations
(C++11)
(C++11)
(C++11)
Swap operations
Transformation operations
Generation operations
Removing operations
Order-changing operations
(until C++17) (C++11)
(C++20) (C++20)
Sampling operations
(C++17)

Sorting and related operations
Partitioning operations
Sorting operations
Binary search operations
(on partitioned ranges)
Set operations (on sorted ranges)
Merge operations (on sorted ranges)
Heap operations
Minimum/maximum operations
min
(C++11)
(C++17)
Lexicographical comparison operations
(C++20)
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
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) Renvoie le plus petit de a et b .
1) Utilise operator < pour comparer les valeurs.
Si T n'est pas LessThanComparable , le comportement est indéfini.
2) Utilisez la fonction de comparaison comp pour comparer les valeurs.
3,4) Retourne la plus petite valeur dans la liste d'initialisation ilist .
Si ilist. size ( ) est 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) Utilisez la fonction de comparaison comp pour comparer les valeurs.

Table des matières

Paramètres

a, b - les valeurs à comparer
ilist - liste d'initialisation avec les valeurs à comparer
cmp - fonction de comparaison (c'est-à-dire un objet qui satisfait aux exigences de Compare ) qui renvoie 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é , pas plus que Type1 sauf si pour Type1 un déplacement équivaut à 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) Le plus petit 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 la valeur la 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 en 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 un temporaire et que ce paramètre est retourné : 

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

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 modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 281 C++98 T devait être CopyConstructible pour les surcharges ( 1,2 ) non requis
LWG 2239 C++98
C++11 		1. T devait être LessThanComparable pour
les surcharges ( 2 ) (C++98) et ( 4 ) (C++11)
2. les exigences de complexité étaient manquantes 		1. non requis
2. exigences ajoutées

Voir aussi

renvoie la plus grande des valeurs données
(modèle de fonction)
(C++11)
renvoie le plus petit et le plus grand de deux éléments
(modèle de fonction)
renvoie le plus petit élément dans une plage
(modèle de fonction)
(C++17)
limite une valeur entre une paire de valeurs limites
(modèle de fonction)
(C++20)
renvoie la plus petite des valeurs données
(objet fonction algorithme)