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

ForwardIt min_element ( ExecutionPolicy && policy,

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

ForwardIt min_element ( ForwardIt first, ForwardIt last,

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

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

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

Findet das kleinste Element im Bereich [ first , last ) .

1) Elemente werden verglichen mit operator < (bis C++20) std:: less { } (seit C++20) .
3) Elemente werden mithilfe der Vergleichsfunktion comp verglichen.
2,4) Gleich wie (1,3) , aber ausgeführt gemäß policy .
Diese Überladungen nehmen nur dann an der Überladungsauflösung teil, wenn alle folgenden Bedingungen erfüllt sind:

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

(bis C++20)

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

(seit C++20)

Inhaltsverzeichnis

Parameter

first, last - das Paar von Iteratoren, das den Bereich der zu untersuchenden Elemente definiert
policy - die zu verwendende Ausführungsrichtlinie
comp - Vergleichsfunktionsobjekt (d.h. ein Objekt, das die Anforderungen von Compare erfüllt), das true zurückgibt, wenn das erste Argument kleiner als das zweite ist.

Die Signatur der Vergleichsfunktion sollte äquivalent zu folgender sein:

bool cmp ( const Type1 & a, const Type2 & b ) ;

Obwohl die Signatur nicht const & benötigt, darf die Funktion die übergebenen Objekte nicht modifizieren und muss alle Werte des Typs (möglicherweise const) Type1 und Type2 unabhängig von der Wertkategorie akzeptieren können (daher ist Type1 & nicht erlaubt , ebenso wenig wie Type1 , es sei denn, für Type1 ist eine Verschiebung äquivalent zu einer Kopie (seit C++11) ).
Die Typen Type1 und Type2 müssen so beschaffen sein, dass ein Objekt vom Typ ForwardIt dereferenziert und dann implizit in beide konvertiert werden kann.

Typanforderungen
-
ForwardIt muss die Anforderungen von LegacyForwardIterator erfüllen.

Rückgabewert

Iterator zum kleinsten Element im Bereich [ first , last ) . Wenn mehrere Elemente im Bereich dem kleinsten Element entsprechen, wird der Iterator zum ersten solchen Element zurückgegeben. Gibt last zurück, wenn der Bereich leer ist.

Komplexität

Gegeben N als std:: distance ( first, last ) :

1,2) Genau max(N-1,0) Vergleiche unter Verwendung von operator < (bis C++20) std:: less { } (seit C++20) .
3,4) Genau max(N-1,0) Anwendungen der Vergleichsfunktion comp .

Exceptions

Die Überladungen mit einem Template-Parameter namens ExecutionPolicy melden Fehler wie folgt:

  • Wenn die Ausführung einer als Teil des Algorithmus aufgerufenen Funktion eine Exception wirft und ExecutionPolicy einer der Standard-Policies ist, wird std::terminate aufgerufen. Für jede andere ExecutionPolicy ist das Verhalten implementierungsdefiniert.
  • Wenn der Algorithmus keinen Speicher allozieren kann, wird std::bad_alloc geworfen.

Mögliche Implementierung

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;
}

Beispiel

Diesen Code ausführen 
#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";
}

Ausgabe: 

min element has value -4 and index [2]

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 212 C++98 der Rückgabewert war nicht spezifiziert, wenn [ first , last ) leer ist gibt in diesem Fall last zurück
LWG 2150 C++98 der Iterator zum ersten Nicht-Größten-Element wurde zurückgegeben korrigierte den Rückgabewert

Siehe auch

gibt das größte Element in einem Bereich zurück
(Funktions-Template)
(C++11)
gibt das kleinste und das größte Element in einem Bereich zurück
(Funktions-Template)
gibt den kleineren der gegebenen Werte zurück
(Funktions-Template)
(C++20)
gibt das kleinste Element in einem Bereich zurück
(Algorithmus-Funktionsobjekt)