Namespaces
Variants

std:: minmax

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
minmax
(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 >
std:: pair < const T & , const T & > minmax ( const T & a, const T & b ) ;
(1) (seit C++11)
(constexpr seit C++14)
template < class T, class Compare >

std:: pair < const T & , const T & > minmax ( const T & a, const T & b,

Compare comp ) ;
(2) (seit C++11)
(constexpr seit C++14)
template < class T >
std:: pair < T, T > minmax ( std:: initializer_list < T > ilist ) ;
(3) (seit C++11)
(constexpr seit C++14)
template < class T, class Compare >

std:: pair < T, T > minmax ( std:: initializer_list < T > ilist,

Compare comp ) ;
(4) (seit C++11)
(constexpr seit C++14)

Gibt die niedrigsten und die höchsten der angegebenen Werte zurück.

1,2) Gibt Referenzen auf den kleineren und den größeren 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 und den größten 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
comp - Vergleichsfunktionsobjekt (d.h. ein Objekt, das die Anforderungen von Compare erfüllt), das true zurückgibt, wenn das erste Argument kleiner als das zweite ist.

Die Signatur der Vergleichsfunktion sollte folgender entsprechen:

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

Obwohl die Signatur keine 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 gleichbedeutend mit 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) Gibt das Ergebnis von std:: pair < const T & , const T & > ( a, b ) zurück, falls a < b oder falls a äquivalent zu b ist. Gibt das Ergebnis von std:: pair < const T & , const T & > ( b, a ) zurück, falls b < a .
3,4) Ein Paar mit dem kleinsten Wert in ilist als erstem Element und dem größten als zweitem. Wenn mehrere Elemente dem kleinsten entsprechen, wird das am weitesten links stehende zurückgegeben. Wenn mehrere Elemente dem größten entsprechen, wird das am weitesten rechts 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) Höchstens
3N
2
Vergleiche unter Verwendung von operator < .
4) Höchstens
3N
2
Anwendungen der Vergleichsfunktion comp .

Mögliche Implementierung

minmax (1) 
template<class T>
constexpr std::pair<const T&, const T&> minmax(const T& a, const T& b)
{
    return (b < a) ? std::pair<const T&, const T&>(b, a)
                   : std::pair<const T&, const T&>(a, b);
}
minmax (2) 
template<class T, class Compare>
constexpr std::pair<const T&, const T&> minmax(const T& a, const T& b, Compare comp)
{
    return comp(b, a) ? std::pair<const T&, const T&>(b, a)
                      : std::pair<const T&, const T&>(a, b);
}
minmax (3) 
template<class T>
constexpr std::pair<T, T> minmax(std::initializer_list<T> ilist)
{
    auto p = std::minmax_element(ilist.begin(), ilist.end());
    return std::pair(*p.first, *p.second);
}
minmax (4) 
template<class T, class Compare>
constexpr std::pair<T, T> minmax(std::initializer_list<T> ilist, Compare comp)
{
    auto p = std::minmax_element(ilist.begin(), ilist.end(), comp);
    return std::pair(*p.first, *p.second);
}

Hinweise

Für Überladungen ( 1,2 ) , wenn einer der Parameter ein temporäres Objekt ist, wird die zurückgegebene Referenz am Ende des vollständigen Ausdrucks, der den Aufruf von minmax enthält, zu einer hängenden Referenz: 

int n = 1;
auto p = std::minmax(n, n + 1);
int m = p.first; // ok
int x = p.second; // undefiniertes Verhalten
// Beachten Sie, dass strukturierte Bindungen das gleiche Problem haben
auto [mm, xx] = std::minmax(n, n + 1);
xx; // undefiniertes Verhalten

Beispiel

Diesen Code ausführen 
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <vector>
int main()
{
    std::vector<int> v{3, 1, 4, 1, 5, 9, 2, 6};
    std::srand(std::time(0));
    std::pair<int, int> bounds = std::minmax(std::rand() % v.size(),
                                             std::rand() % v.size());
    std::cout << "v[" << bounds.first << "," << bounds.second << "]: ";
    for (int i = bounds.first; i < bounds.second; ++i)
        std::cout << v[i] << ' ';
    std::cout << '\n';
}

Mögliche Ausgabe: 

v[2,7]: 4 1 5 9 2

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 2239 C++11 T musste LessThanComparable sein für Überladungen ( 2,4 ) nicht erforderlich

Siehe auch

gibt den kleineren der gegebenen Werte zurück
(Funktions-Template)
gibt den größeren der gegebenen Werte zurück
(Funktions-Template)
(C++11)
gibt die kleinsten und größten Elemente in einem Bereich zurück
(Funktions-Template)
(C++20)
gibt das kleinere und größere von zwei Elementen zurück
(Algorithmus-Funktionsobjekt)