Namensräume
Varianten
Aktionen

std::max

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
max
(C++11)
(C++17)
Lexikographische Vergleichsoperationen
Permutationsoperationen
C-Bibliothek
Numerische Operationen
Operationen auf uninitialisiertem Speicher
 
Definiert in Header <algorithm>
template< class T >
const T& max( const T& a, const T& b );
(1) (constexpr seit C++14)
template< class T, class Compare >
const T& max( const T& a, const T& b, Compare comp );
(2) (constexpr seit C++14)
template< class T >
T max( std::initializer_list<T> ilist );
(3) (seit C++11)
(constexpr seit C++14)
template< class T, class Compare >
T max( std::initializer_list<T> ilist, Compare comp );
(4) (seit C++11)
(constexpr seit C++14)

Gibt den größeren der beiden übergebenen Werte zurück.

1,2) Gibt den größeren der Werte 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 größten Wert 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

[edit] Parameter

a, b - die zu vergleichenden Werte
ilist - Initialisierungsliste mit den zu vergleichenden Werten
comp - Funktionsobjekt für den Vergleich (d.h. ein Objekt, das die Anforderungen an Compare erfüllt), welches true zurückgibt, wenn a *weniger* 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.

[edit] Rückgabewert

1,2) Der größere Wert von a und b. Wenn sie gleich sind, wird a zurückgegeben.
3,4) Der größte Wert in der Initialisierungsliste ilist. Wenn mehrere Werte dem größten entsprechen, wird der links stehende zurückgegeben.

[edit] 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.

[edit] Mögliche Implementierung

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

[edit] Hinweise

Das Erfassen des Ergebnisses von std::max als Referenz kann zu einer verwaisten Referenz führen, wenn einer der Parameter ein temporäres Objekt ist und dieses Objekt zurückgegeben wird.

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

[edit] Beispiel

#include <algorithm>
#include <iomanip>
#include <iostream>
#include <string_view>
 
int main()
{
    auto longest = [](const std::string_view s1, const std::string_view s2)
                   {
                       return s1.size() < s2.size();
                   };
 
    std::cout << "Larger of 69 and 96 is " << std::max(69, 96) << "\n"
                 "Larger of 'q' and 'p' is '" << std::max('q', 'p') << "'\n"
                 "Largest of 010, 10, 0X10, and 0B10 is "
              << std::max({010, 10, 0X10, 0B10}) << '\n'
              << R"(Longest of "long", "short", and "int" is )"
              << std::quoted(std::max({"long", "short", "int"}, longest)) << '\n';
}

Ausgabe

Larger of 69 and 96 is 96
Larger of 'q' and 'p' is 'q'
Largest of 010, 10, 0X10, and 0B10 is 16
Longest of "long", "short", and "int" is "short"

[edit] Fehlermeldungen

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

[edit] Siehe auch

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