Namespaces
Variants

std:: max_element

From cppreference.net
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)
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
Lexicographical comparison operations
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Défini dans l'en-tête <algorithm>
template < class ForwardIt >
ForwardIt max_element ( ForwardIt first, ForwardIt last ) ;
(1) (constexpr depuis C++17)
template < class ExecutionPolicy, class ForwardIt >

ForwardIt max_element ( ExecutionPolicy && policy,

ForwardIt first, ForwardIt last ) ;
(2) (depuis C++17)
template < class ForwardIt, class Compare >

ForwardIt max_element ( ForwardIt first, ForwardIt last,

Compare comp ) ;
(3) (constexpr depuis C++17)
template < class ExecutionPolicy, class ForwardIt, class Compare >

ForwardIt max_element ( ExecutionPolicy && policy,
ForwardIt first, ForwardIt last,

Compare comp ) ;
(4) (depuis C++17)

Trouve le plus grand élément dans la plage [ first , last ) .

1) Les éléments sont comparés en utilisant operator < (jusqu'en C++20) std:: less { } (depuis C++20) .
3) Les éléments sont comparés en utilisant la fonction de comparaison comp .
2,4) Identique à (1,3) , mais exécuté selon la policy .
Ces surcharges participent à la résolution de surcharge seulement si toutes les conditions suivantes sont satisfaites :

std:: is_execution_policy_v < std:: decay_t < ExecutionPolicy >> est true .

(jusqu'à C++20)

std:: is_execution_policy_v < std:: remove_cvref_t < ExecutionPolicy >> est true .

(depuis C++20)

Table des matières

Paramètres

first, last - la paire d'itérateurs définissant la plage d'éléments à examiner
policy - la politique d'exécution à utiliser
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 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 est équivalent à une copie (depuis C++11) ).
Les types Type1 et Type2 doivent être tels qu'un objet de type ForwardIt puisse être déréférencé puis implicitement converti vers les deux.

Exigences de type
-
ForwardIt doit satisfaire aux exigences de LegacyForwardIterator .

Valeur de retour

Itérateur vers le plus grand élément de l'intervalle [ first , last ) . Si plusieurs éléments de l'intervalle sont équivalents au plus grand élément, retourne l'itérateur vers le premier de ces éléments. Retourne last si l'intervalle est vide.

Complexité

Étant donné N comme std:: distance ( first, last ) :

1,2) Exactement max(N-1,0) comparaisons en utilisant operator < (jusqu'à C++20) std:: less { } (depuis C++20) .
3,4) Exactement max(N-1,0) applications de la fonction de comparaison comp .

Exceptions

Les surcharges avec un paramètre de modèle nommé ExecutionPolicy signalent les erreurs comme suit :

  • Si l'exécution d'une fonction invoquée dans le cadre de l'algorithme lève une exception et que ExecutionPolicy fait partie des politiques standard , std::terminate est appelée. Pour tout autre ExecutionPolicy , le comportement est défini par l'implémentation.
  • Si l'algorithme ne parvient pas à allouer de la mémoire, std::bad_alloc est levée.

Implémentation possible

max_element (1)
template<class ForwardIt>
ForwardIt max_element(ForwardIt first, ForwardIt last)
{
    if (first == last)
        return last;
    ForwardIt largest = first;
    while (++first != last)
        if (*largest < *first)
            largest = first;
    return largest;
}
max_element (3)
template<class ForwardIt, class Compare>
ForwardIt max_element(ForwardIt first, ForwardIt last, Compare comp)
{
    if (first == last)
        return last;
    ForwardIt largest = first;
    while(++first != last)
        if (comp(*largest, *first))
            largest = first;
    return largest;
}

Exemple

#include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
int main()
{
    std::vector<int> v{3, 1, -14, 1, 5, 9, -14, 9};
    std::vector<int>::iterator result;
    result = std::max_element(v.begin(), v.end());
    std::cout << "Max element found at index "
              << std::distance(v.begin(), result)
              << " has value " << *result << '\n';
    result = std::max_element(v.begin(), v.end(), [](int a, int b)
    {
        return std::abs(a) < std::abs(b);
    });
    std::cout << "Absolute max element found at index "
              << std::distance(v.begin(), result)
              << " has value " << *result << '\n';
}

Sortie :

Max element found at index 5 has value 9
Absolute max element found at index 2 has value -14

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 Applicable à Comportement publié Comportement corrigé
LWG 212 C++98 la valeur de retour n'était pas spécifiée si [ first , last ) est vide retourne last dans ce cas
LWG 2150 C++98 l'itérateur vers le premier élément non-minimal était retourné a corrigé la valeur de retour

Voir aussi

renvoie le plus petit élément dans une plage
(modèle de fonction)
renvoie les plus petits et les plus grands éléments dans une plage
(modèle de fonction)
renvoie la plus grande des valeurs données
(modèle de fonction)
renvoie le plus grand élément dans une plage
(objet fonction algorithme)