Namespaces
Variants

std::max

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

Sortier- und verwandte Operationen
Partitionierungsoperationen
(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
Permutationsoperationen


 
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 gegebenen Werte zurück.

1,2) Gibt den größeren von a und b zurück.
1) Verwendet operator<, um die Werte zu vergleichen.
Wenn T nicht LessThanComparable ist, ist das Verhalten undefiniert.
2) Verwenden Sie die Vergleichsfunktion comp, um die Werte zu vergleichen.
3,4) Gibt den größten 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) Verwenden Sie die Vergleichsfunktion comp, um die Werte zu vergleichen.

Parameter

a, b - die zu vergleichenden Werte
ilist - Initialisierungsliste mit den zu vergleichenden Werten
comp - 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 äquivalent zu folgendem sein:

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

Während die Signatur const& nicht enthalten muss, darf die Funktion die ihr übergebenen Objekte nicht verändern 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 des Typs T implizit in beide konvertiert werden kann.

Rückgabewert

1,2) Der größere von a und b. Wenn sie äquivalent sind, wird a zurückgegeben.
3,4) Der größte Wert in ilist. Wenn mehrere Werte zum größten äquivalent sind, wird der am weitesten links stehende 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

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

Anmerkungen

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

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

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"

Fehlerberichte

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

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

Siehe auch

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