Namespaces
Variants

std:: max

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

1,2) Gibt den größeren Wert 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 , um die Werte zu vergleichen.
3,4) Gibt den größten Wert in der Initialisiererliste 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 um die Werte zu vergleichen.

Inhaltsverzeichnis

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 Folgender sein:

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

Obwohl die Signatur nicht const & 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) Der größere Wert von a und b . Wenn sie äquivalent sind, wird a zurückgegeben.
3,4) Der größte Wert in ilist . Wenn mehrere Werte dem größten entsprechen, wird der am weitesten links stehende 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

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

Hinweise

Das Erfassen des Ergebnisses von std::max 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::max(n + 2, n * 2); // r ist hängend

Beispiel

Diesen Code ausführen 
#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 Korrigiertes 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 kleineren der gegebenen Werte zurück
(Funktions-Template)
(C++11)
gibt den kleineren und größeren von zwei Elementen zurück
(Funktions-Template)
gibt das größte Element in einem Bereich zurück
(Funktions-Template)
(C++17)
begrenzt einen Wert zwischen einem Paar von Grenzwerten
(Funktions-Template)
(C++20)
gibt den größeren der gegebenen Werte zurück
(Algorithmus-Funktionsobjekt)