Namespaces
Variants

std:: min

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
min
(C++11)
(C++17)
Lexicographical comparison operations
(C++20)
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
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 angegebenen Werte zurück.

1,2) Gibt den kleineren Wert von a und b zurück.
1) Verwendet operator < zum Vergleichen der Werte.
Falls T nicht LessThanComparable ist, ist das Verhalten undefiniert.
2) Verwenden Sie die Vergleichsfunktion comp , um die Werte zu vergleichen.
3,4) Gibt den kleinsten Wert 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.
Falls T nicht LessThanComparable ist, ist das Verhalten undefiniert.
4) Verwenden Sie die Vergleichsfunktion comp um die Werte zu vergleichen.

Inhaltsverzeichnis

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 folgender entsprechen:

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

Obwohl die Signatur const & nicht 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 T implizit in beide konvertiert werden kann.

Rückgabewert

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

Komplexität

1) Genau ein Vergleich unter Verwendung von 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);
}
**Anmerkung:** Der gesamte C++-Code innerhalb der ` 
`-Tags wurde gemäß den Anweisungen nicht übersetzt, da er als Code gekennzeichnet ist. Die Funktionsnamen, Schlüsselwörter und Typen (wie `min`, `template`, `class`, `T`, `Compare`, `const`, `std::initializer_list`, etc.) wurden ebenfalls nicht übersetzt, da es sich um C++-spezifische Begriffe handelt.

Hinweise

Das Erfassen des Ergebnisses von std::min durch 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 ist hängend

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

Siehe auch

gibt den größeren der gegebenen Werte zurück
(Funktions-Template)
(C++11)
gibt den kleineren und größeren von zwei Elementen zurück
(Funktions-Template)
gibt das kleinste Element in einem Bereich zurück
(Funktions-Template)
(C++17)
begrenzt einen Wert zwischen einem Paar von Grenzwerten
(Funktions-Template)
(C++20)
gibt den kleineren der gegebenen Werte zurück
(Algorithmus-Funktionsobjekt)