Namespaces
Variants

std:: max

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
max
(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 & max ( const T & a, const T & b ) ;
(1) (constexpr depuis C++14)
template < class T, class Compare >
const T & max ( const T & a, const T & b, Compare comp ) ;
(2) (constexpr depuis C++14)
template < class T >
T max ( std:: initializer_list < T > ilist ) ;
(3) (depuis C++11)
(constexpr depuis C++14)
template < class T, class Compare >
T max ( std:: initializer_list < T > ilist, Compare comp ) ;
(4) (depuis C++11)
(constexpr depuis C++14)

Retourne la plus grande des valeurs données.

1,2) Retourne le 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) Utilisez la fonction de comparaison comp pour comparer les valeurs.
3,4) Retourne la plus grande 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
comp - objet 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 grand de a et b . S'ils sont équivalents, retourne a .
3,4) La plus grande valeur dans ilist . Si plusieurs valeurs sont équivalentes à la plus grande, retourne celle la plus à gauche.

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) Exactement N-1 comparaisons en utilisant operator < .
4) Exactement N-1 applications de la fonction de comparaison comp .

Implémentation possible

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

Notes

Capturer le résultat de std::max 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::max(n + 2, n * 2); // r est pendante

Exemple

Exécuter ce code 
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <string_view>
int main()
{
    auto longest = [](const std::string_view s1, const std::string_view s2)
                   {
                       return s1.size() < s2.size();
                   };
    std::cout << "Larger of 69 and 96 is " << std::max(69, 96) << "\n"
                 "Larger of 'q' and 'p' is '" << std::max('q', 'p') << "'\n"
                 "Largest of 010, 10, 0X10, and 0B10 is "
              << std::max({010, 10, 0X10, 0B10}) << '\n'
              << R"(Longest of "long", "short", and "int" is )"
              << std::quoted(std::max({"long", "short", "int"}, longest)) << '\n';
}

Sortie : 

Larger of 69 and 96 is 96
Larger of 'q' and 'p' is 'q'
Largest of 010, 10, 0X10, and 0B10 is 16
Longest of "long", "short", and "int" is "short"

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 correct
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. ajout des exigences

Voir aussi

renvoie la plus petite 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 grand élément dans une plage
(modèle de fonction)
(C++17)
borne une valeur entre une paire de valeurs limites
(modèle de fonction)
(C++20)
renvoie la plus grande des valeurs données
(objet fonction algorithme)