Namespaces
Variants

std:: min_element

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
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 ForwardIt >
ForwardIt min_element ( ForwardIt first, ForwardIt last ) ;
(1) (constexpr depuis C++17)
template < class ExecutionPolicy, class ForwardIt >

ForwardIt min_element ( ExecutionPolicy && policy,

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

ForwardIt min_element ( ForwardIt first, ForwardIt last,

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

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

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

Trouve le plus petit é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 l' intervalle des é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 ne nécessite pas 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 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 petit élément de l'intervalle [ first , last ) . Si plusieurs éléments de l'intervalle sont équivalents au plus petit é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é. 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é.

Implémentation possible

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

Exemple

Exécuter ce code 
#include <algorithm>
#include <iostream>
#include <vector>
int main()
{
    std::vector<int> v{3, 1, -4, 1, 5, 9};
    std::vector<int>::iterator result = std::min_element(v.begin(), v.end());
    std::cout << "min element has value " << *result << " and index ["
              << std::distance(v.begin(), result) << "]\n";
}

Sortie : 

min element has value -4 and index [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 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-maximal était retourné a corrigé la valeur de retour

Voir aussi

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