std::minmax
De fr.cppreference.net
< cpp | Algorithmes
| 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) |
Renvoie la plus petite et la plus grande des valeurs données.
1,2) Renvoie des références au plus petit et au plus grand 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) Renvoie la plus petite et la plus grande des valeurs de la liste d'initialisation
ilist.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 |
| 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 :
Bien que la signature n'ait pas besoin d'avoir |
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 renvoyé. Si plusieurs éléments sont équivalents au plus grand, l'élément le plus à droite est renvoyé.Complexité
1) Exactement une comparaison utilisant
operator<.2) Exactement une application de la fonction de comparaison
comp.3,4) Étant donné N en tant que
ilist.size():3) Au plus
comparaisons utilisant
| 3N |
| 2 |
operator<.4) Au plus
applications de la fonction de comparaison
| 3N |
| 2 |
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 une temporaire, la référence renvoyé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; // ok
int x = p.second; // undefined behavior
// Note that structured bindings have the same issue
auto [mm, xx] = std::minmax(n, n + 1);
xx; // undefined behavior
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 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 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 & objet fonction d'algorithme) | |
(C++20) |
|
| renvoie la plus grande des valeurs données (modèle de fonction & objet fonction d'algorithme) | |
(C++20) |
|
(C++11) |
renvoie les éléments les plus petit et le plus grand dans une plage (modèle de fonction & objet fonction d'algorithme) |
(C++20) |
|
(C++20) |
renvoie le plus petit et le plus grand de deux éléments (objet fonction d'algorithme) |