Namespaces
Variants

    std::min

    Von de.cppreference.net
     
    C++
     
    Algorithmenbibliothek
    Eingeschränkte Algorithmen und Algorithmen auf Bereichen (C++20)
    Eingeschränkte Algorithmen, z.B. ranges::copy, ranges::sort, ...
    Nicht modifizierende Sequenzoperationen    
    Stapeloperationen
    (C++17)
    Suchoperationen
    Modifizierende Sequenzoperationen
    Kopieroperationen
    (C++11)
    (C++11)
    (C++11)
    Tauschoperationen
    Transformationsoperationen
    Generierungsoperationen
    Entfernungsoperationen
    Reihenfolgeändernde Operationen
    (bis C++17)(C++11)
    (C++20)(C++20)
    Stichprobenoperationen
    (C++17)

    Sortier- und verwandte Operationen
    Partitionierungsoperationen
    (C++11)    
    (C++11)

    Sortieroperationen
    Binäre Suchoperationen
    (auf partitionierten Bereichen)
    Mengenoperationen (auf sortierten Bereichen)
    Mischoperationen (auf sortierten Bereichen)
    Heap-Operationen
    Minimum/Maximum-Operationen
    (C++11)
    (C++17)
    Lexikografische Vergleichsoperationen
    (C++20)
    Permutationsoperationen


     
    Definiert in Header <algorithm> 
    template< class T >
const T& min( const T& a, const T& b );
    		(1) (constexpr seit C++14) 
    template< class T, class Compare >
const T& min( const T& a, const T& b, Compare comp );
    		(2) (constexpr seit C++14) 
    template< class T >
T min( std::initializer_list<T> ilist );
    		(3) (seit C++11)
    (constexpr seit C++14)    		 
    template< class T, class Compare >
T min( std::initializer_list<T> ilist, Compare comp );
    		(4) (seit C++11)
    (constexpr seit C++14)

    Gibt den kleineren der gegebenen Werte zurück.

    1,2) Gibt den kleineren von a und b zurück.
    1) Verwendet operator< zum Vergleichen der Werte.
    Wenn T nicht LessThanComparable ist, ist das Verhalten undefiniert.
    2) Verwenden Sie die Vergleichsfunktion comp zum Vergleichen der Werte.
    3,4) Gibt den kleinsten der Werte in der Initialisierungsliste ilist zurück.
    Wenn ilist.size() null ist oder T nicht CopyConstructible ist, ist das Verhalten undefiniert.
    3) Verwendet operator< zum Vergleichen der Werte.
    Wenn T nicht LessThanComparable ist, ist das Verhalten undefiniert.
    4) Verwenden Sie die Vergleichsfunktion comp zum Vergleichen der Werte.

    Parameter

    a, b - die zu vergleichenden Werte
    ilist - Initialisierungsliste mit den zu vergleichenden Werten
    cmp - Vergleichsfunktionsobjekt (d.h. ein Objekt, das die Anforderungen von Compare erfüllt), das true zurückgibt, wenn a kleiner als b ist.

    Die Signatur der Vergleichsfunktion sollte wie folgt äquivalent sein:

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

    Während die Signatur kein const& haben muss, darf die Funktion die ihr übergebenen Objekte nicht modifizieren und muss in der Lage sein, alle Werte des Typs (möglicherweise const) Type1 und Type2 unabhängig von der Wertkategorie zu akzeptieren (daher ist Type1& nicht erlaubt, ebenso wenig Type1, es sei denn für Type1 ist eine Verschiebung gleichbedeutend mit einer Kopie(seit C++11)).
    Die Typen Type1 und Type2 müssen so sein, dass ein Objekt vom Typ T implizit in beide konvertiert werden kann.

    Rückgabewert

    1,2) Der kleinere von a und b. Wenn die Werte äquivalent sind, wird a zurückgegeben.
    3,4) Der kleinste Wert in ilist. Wenn mehrere Werte zum kleinsten äquivalent sind, wird der am weitesten links stehende solche Wert zurückgegeben.

    Komplexität

    1) Genau ein Vergleich mit operator<.
    2) Genau eine Anwendung der Vergleichsfunktion comp.
    3,4) Gegeben N als ilist.size():
    3) Genau N-1 Vergleiche mit operator<.
    4) Genau N-1 Anwendungen der Vergleichsfunktion comp.

    Mögliche Implementierung

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

    Hinweise

    Das Erfassen des Ergebnisses von std::min als Referenz erzeugt eine hängende Referenz, wenn einer der Parameter ein temporärer ist und dieser Parameter zurückgegeben wird: 

    int n = -1;
const int& r = std::min(n + 2, n * 2); // r is dangling

    Beispiel

    Diesen Code ausführen
    #include <algorithm>
#include <iostream>
#include <string_view>

int main()
{
    std::cout << "smaller of 10 and 010 is " << std::min(10, 010) << '\n'
              << "smaller of 'd' and 'b' is '" << std::min('d', 'b') << "'\n"
              << "shortest of \"foo\", \"bar\", and \"hello\" is \""
              << std::min({"foo", "bar", "hello"},
                          [](const std::string_view s1, const std::string_view s2)
                          {
                              return s1.size() < s2.size();
                          }) << "\"\n";
}

    Ausgabe: 

    smaller of 10 and 010 is 8
smaller of 'd' and 'b' is 'b'
shortest of "foo", "bar", and "hello" is "foo"

    Fehlerberichte

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

    DR Angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
    LWG 281 C++98 T war erforderlich, CopyConstructible für Überladungen (1,2) zu sein nicht erforderlich
    LWG 2239 C++98
    C++11     		1. T war erforderlich, LessThanComparable für
        Überladungen (2) (C++98) und (4) (C++11) zu sein
    2. die Komplexitätsanforderungen fehlten     		1. nicht erforderlich
    2. Anforderungen hinzugefügt

    Siehe auch

    		 gibt den größeren der gegebenen Werte zurück
    (Funktionstemplate & Algorithmusfunktionsobjekt)
    (C++20)
    (C++11)
    		 gibt den kleineren und größeren von zwei Elementen zurück
    (Funktionstemplate & Algorithmusfunktionsobjekt)
    (C++20)
    		gibt das kleinste Element in einem Bereich zurück
    (Funktionstemplate & Algorithmusfunktionsobjekt)
    (C++20)
    (C++17)
    		 spannt einen Wert zwischen einem Paar von Grenzwerten ein
    (Funktionstemplate & Algorithmusfunktionsobjekt)
    (C++20)
    (C++20)
    		 gibt den kleineren der gegebenen Werte zurück
    (Algorithmusfunktionsobjekt)