Namespaces
Variants

std:: minmax

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
minmax
(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 >
std:: pair < const T & , const T & > minmax ( const T & a, const T & b ) ;
(1) (depuis C++11)
(constexpr depuis C++14)
template < class T, class Compare >

std:: pair < const T & , const T & > minmax ( const T & a, const T & b,

Compare comp ) ;
(2) (depuis C++11)
(constexpr depuis C++14)
template < class T >
std:: pair < T, T > minmax ( std:: initializer_list < T > ilist ) ;
(3) (depuis C++11)
(constexpr depuis C++14)
template < class T, class Compare >

std:: pair < T, T > minmax ( std:: initializer_list < T > ilist,

Compare comp ) ;
(4) (depuis C++11)
(constexpr depuis C++14)

Retourne la plus petite et la plus grande des valeurs données.

1,2) Retourne des références vers le plus petit et le plus grand des 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) Renvoie les valeurs minimale et maximale de 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
comp - objet fonction de comparaison (c'est-à-dire un objet qui satisfait aux exigences de Compare ) qui renvoie true si le premier argument est inférieur au second.

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 du 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) Renvoie le résultat de std:: pair < const T & , const T & > ( a, b ) si a < b ou si a est équivalent à b . Renvoie le résultat de std:: pair < const T & , const T & > ( b, a ) si b < a .
3,4) Une paire avec la plus petite valeur dans ilist comme premier élément et la plus grande comme second. Si plusieurs éléments sont équivalents au plus petit, l'élément le plus à gauche est retourné. Si plusieurs éléments sont équivalents au plus grand, l'élément le plus à droite est retourné.

Complexité

1) Exactement une comparaison en utilisant operator < .
2) Exactement une application de la fonction de comparaison comp .
3,4) Étant donné N comme ilist. size ( ) :
3) Au maximum
3N
2
comparaisons en utilisant operator < .
4) Au plus
3N
2
applications de la fonction de comparaison comp .

Implémentation possible

minmax (1) 
template<class T>
constexpr std::pair<const T&, const T&> minmax(const T& a, const T& b)
{
    return (b < a) ? std::pair<const T&, const T&>(b, a)
                   : std::pair<const T&, const T&>(a, b);
}
minmax (2) 
template<class T, class Compare>
constexpr std::pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp)
{
    return comp(b, a) ? std::pair<const T&, const T&>(b, a)
                      : std::pair<const T&, const T&>(a, b);
}
minmax (3) 
template<class T>
constexpr std::pair<T, T> minmax(std::initializer_list<T> ilist)
{
    auto p = std::minmax_element(ilist.begin(), ilist.end());
    return std::pair(*p.first, *p.second);
}
minmax (4) 
template<class T, class Compare>
constexpr std::pair<T, T> minmax(std::initializer_list<T> ilist, Compare comp)
{
    auto p = std::minmax_element(ilist.begin(), ilist.end(), comp);
    return std::pair(*p.first, *p.second);
}

Notes

Pour les surcharges ( 1,2 ) , si l'un des paramètres est un temporaire, la référence retournée devient une référence pendante à la fin de l'expression complète qui contient l'appel à minmax : 

int n = 1;
auto p = std::minmax(n, n + 1);
int m = p.first; // correct
int x = p.second; // comportement indéfini
// Notez que les liaisons structurées présentent le même problème
auto [mm, xx] = std::minmax(n, n + 1);
xx; // comportement indéfini

Exemple

Exécuter ce code 
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <vector>
int main()
{
    std::vector<int> v{3, 1, 4, 1, 5, 9, 2, 6};
    std::srand(std::time(0));
    std::pair<int, int> bounds = std::minmax(std::rand() % v.size(),
                                             std::rand() % v.size());
    std::cout << "v[" << bounds.first << "," << bounds.second << "]: ";
    for (int i = bounds.first; i < bounds.second; ++i)
        std::cout << v[i] << ' ';
    std::cout << '\n';
}

Sortie possible : 

v[2,7]: 4 1 5 9 2

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 S'applique à Comportement publié Comportement corrigé
LWG 2239 C++11 T devait être LessThanComparable pour les surcharges ( 2,4 ) non requis

Voir aussi

renvoie la plus petite des valeurs données
(modèle de fonction)
renvoie la plus grande des valeurs données
(modèle de fonction)
(C++11)
renvoie les plus petits et les plus grands éléments d'une plage
(modèle de fonction)
(C++20)
renvoie le plus petit et le plus grand de deux éléments
(objet fonction algorithme)