Namensräume
Varianten
Aktionen

std::min

Von cppreference.com
< cpp‎ | algorithm
 
 
Algorithmenbibliothek
Beschränkte Algorithmen und Algorithmen für Bereiche (C++20)
Beschränkte Algorithmen, z.B. ranges::copy, ranges::sort, ...
Ausführungsrichtlinien (C++17)
Nicht-modifizierende Sequenzoperationen
Stapeloperationen
(C++17)
Suchoperationen
(C++11)                (C++11)(C++11)

Modifizierende Sequenzoperationen
Kopieroperationen
(C++11)
(C++11)
Tauschoperationen
Transformationsoperationen
Generierungsoperationen
Entfernungsoperationen
Ordnungsändernde Operationen
(bis C++17)(C++11)
(C++20)(C++20)
Stichprobenoperationen
(C++17)

Sortier- und verwandte Operationen
Partitionierungsoperationen
Sortieroperationen
Binäre Suchoperationen
(auf partitionierten Bereichen)
Mengenoperationen (auf sortierten Bereichen)
Zusammenführungsoperationen (auf sortierten Bereichen)
Heapoperationen
Minimum/Maximum-Operationen
min
(C++11)
(C++17)
Lexikographische Vergleichsoperationen
Permutationsoperationen
C-Bibliothek
Numerische Operationen
Operationen auf uninitialisiertem Speicher
 
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<, um die Werte zu vergleichen.
Wenn T nicht LessThanComparable ist, ist das Verhalten undefiniert.
2) Verwendet die Vergleichsfunktion comp, um die Werte zu vergleichen.
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<, um die Werte zu vergleichen.
Wenn T nicht LessThanComparable ist, ist das Verhalten undefiniert.
4) Verwendet die Vergleichsfunktion comp, um die Werte zu vergleichen.

Inhalt

[bearbeiten] Parameter

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

Die Signatur der Vergleichsfunktion sollte äquivalent zu Folgendem sein

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

Obwohl die Signatur nicht const& haben muss, darf die Funktion die übergebenen Objekte nicht modifizieren und muss alle Werte vom Typ (möglicherweise const) Type1 und Type2 unabhängig von der Wertkategorie akzeptieren (daher ist Type1& nicht erlaubt, und auch nicht Type1, es sei denn, für Type1 ist ein Move äquivalent zu einer Kopie(seit C++11)).
Die Typen Type1 und Type2 müssen so beschaffen sein, dass ein Objekt vom Typ T implizit in beide konvertiert werden kann.

[bearbeiten] Rückgabewert

1,2) Der kleinere von a und b. Wenn die Werte gleich sind, wird a zurückgegeben.
3,4) Der kleinste Wert in ilist. Wenn mehrere Werte gleich dem kleinsten sind, wird der links stehende Wert zurückgegeben.

[bearbeiten] Komplexität

1) Genau ein Vergleich unter Verwendung von operator<.
2) Genau eine Anwendung der Vergleichsfunktion comp.
3,4) Sei N gleich ilist.size().
3) Genau N-1 Vergleiche mit operator<.
4) Genau N-1 Aufrufe der Vergleichsfunktion comp.

[bearbeiten] 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);
}

[bearbeiten] Hinweise

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

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

[bearbeiten] Beispiel

#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"

[bearbeiten] 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 musste für die Überladungen (1,2) CopyConstructible sein. nicht erforderlich.
LWG 2239 C++98
C++11
1. T musste für die Überladungen (2) (C++98) und (4) (C++11) LessThanComparable sein.
    überladungen (2) (C++98) und (4) (C++11)
2. Die Komplexitätsanforderungen fehlten.
1. Nicht erforderlich
2. Die Anforderungen wurden hinzugefügt.

[bearbeiten] Siehe auch

Gibt den größeren der beiden Werte zurück
(Funktionstemplate) [edit]
(C++11)
gibt die kleinere und größere von zwei Elementen zurück
(Funktionsvorlage) [editieren]
gibt das kleinste Element in einem Bereich zurück
(Funktionsvorlage) [editieren]
(C++17)
klemmt einen Wert zwischen einem Paar von Grenzwerte
(Funktionsvorlage) [editieren]
Gibt den kleineren der beiden Werte zurück
(Algorithmus-Funktionsobjekt)[bearbeiten]