std::minmax

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Algorithmenbibliothek

Beschränkte Algorithmen und Algorithmen für Bereiche (C++20)
Beschränkte Algorithmen, z.B. ranges::copy, ranges::sort, ...
Ausführungsrichtlinien (C++17)
is_execution_policy (C++17)   execution::seqexecution::parexecution::par_unseqexecution::unseq (C++17)    (C++17)(C++17)(C++20)	execution::sequenced_policyexecution::parallel_policyexecution::parallel_unsequenced_policyexecution::parallel_unsequenced (C++17)(C++17)(C++17)(C++20)
Nicht-modifizierende Sequenzoperationen Stapeloperationen for_each for_each_n (C++17) Suchoperationen all_ofany_ofnone_of (C++11)                (C++11)(C++11) countcount_if mismatch equal findfind_iffind_if_not (C++11) find_end find_first_of adjacent_find search search_n Modifizierende Sequenzoperationen Kopieroperationen copycopy_if (C++11) copy_backward copy_n (C++11) move (C++11) move_backward (C++11) Tauschoperationen swap iter_swap swap_ranges Transformationsoperationen replacereplace_if transform replace_copyreplace_copy_if Generierungsoperationen fill fill_n generate generate_n Entfernungsoperationen removeremove_if unique remove_copyremove_copy_if unique_copy Ordnungsändernde Operationen reverse reverse_copy rotate rotate_copy random_shuffleshuffle (bis C++17)(C++11) shift_leftshift_right (C++20)(C++20) Stichprobenoperationen sample (C++17)	Sortier- und verwandte Operationen Partitionierungsoperationen partition partition_copy (C++11)   stable_partition is_partitioned (C++11) partition_point (C++11) Sortieroperationen sort stable_sort partial_sort partial_sort_copy is_sorted (C++11) is_sorted_until (C++11) nth_element Binäre Suchoperationen (auf partitionierten Bereichen) lower_bound upper_bound equal_range binary_search Mengenoperationen (auf sortierten Bereichen) includes set_union set_intersection set_difference set_symmetric_difference Zusammenführungsoperationen (auf sortierten Bereichen) merge inplace_merge Heapoperationen push_heap pop_heap make_heap sort_heap is_heap (C++11) is_heap_until (C++11) Minimum/Maximum-Operationen max min minmax (C++11) clamp (C++17) max_element min_element minmax_element (C++11) Lexikographische Vergleichsoperationen lexicographical_compare lexicographical_compare_three_way (C++20) Permutationsoperationen next_permutation prev_permutation is_permutation (C++11) C-Bibliothek qsort bsearch
Numerische Operationen
iota (C++11) inner_product adjacent_difference    accumulate reduce (C++17) transform_reduce (C++17)	partial_sum inclusive_scan (C++17)    exclusive_scan (C++17) transform_inclusive_scan (C++17) transform_exclusive_scan (C++17)
Operationen auf uninitialisiertem Speicher
uninitialized_copy uninitialized_move (C++17)    uninitialized_fill uninitialized_copy_n (C++11) uninitialized_move_n (C++17) uninitialized_fill_n	destroy (C++17) destroy_n (C++17) destroy_at (C++17) construct_at (C++20)       uninitialized_default_construct (C++17) uninitialized_value_construct (C++17) uninitialized_default_construct_n (C++17) uninitialized_value_construct_n (C++17)

 

Definiert in 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 kleinsten und die größten der gegebenen Werte zurück.

1,2) Gibt Referenzen auf den kleineren und 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 das kleinste und das größte 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) Verwendet die Vergleichsfunktion comp, um die Werte zu vergleichen.

Parameter

a, b	-	die zu vergleichenden Werte
ilist	-	Initialisierungsliste mit den zu vergleichenden Werten
comp	-	Ein Vergleichsfunktions-Objekt (d.h. ein Objekt, das die Anforderungen an Compare erfüllt), das true zurückgibt, wenn das erste Argument *weniger* als das zweite 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.

Rückgabewert

1,2) Gibt das Ergebnis von std::pair<const T&, const T&>(a, b) zurück, wenn a < b oder wenn a äquivalent zu b ist. Gibt das Ergebnis von std::pair<const T&, const T&>(b, a) zurück, wenn b < a.

3,4) Ein Paar mit dem kleinsten Wert in ilist als erstes Element und dem größten als zweites. Wenn mehrere Elemente äquivalent zum kleinsten sind, wird das am weitesten links stehende Element zurückgegeben. Wenn mehrere Elemente äquivalent zum größten sind, wird das am weitesten rechts stehende Element zurückgegeben.

Komplexität

1) Genau ein Vergleich unter Verwendung von operator<.

2) Genau eine Anwendung der Vergleichsfunktion comp.

3,4) Sei \(\scriptsize N\)N gleich ilist.size().

3) Höchstens \(\scriptsize \frac{3N}{2}\)

3N

2

Vergleiche unter Verwendung von operator<.

4) Höchstens \(\scriptsize \frac{3N}{2}\)

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

Bei den Ü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; // undefined behavior
 
// Note that structured bindings have the same issue
auto [mm, xx] = std::minmax(n, n + 1);
xx; // undefined behavior

Beispiel

Führen Sie diesen Code aus

#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	Korrigiertes Verhalten
LWG 2239	C++11	T war für die Überladungen (2,4) als LessThanComparable erforderlich.	nicht erforderlich.

Siehe auch

min	Gibt den kleineren der beiden Werte zurück (Funktionstemplate)
max	Gibt den größeren der beiden Werte zurück (Funktionstemplate)
minmax_element (C++11)	gibt das kleinste und das größte Element in einem Bereich zurück (Funktionsvorlage)
ranges::minmax (C++20)	gibt die kleinere und größere von zwei Elementen zurück (Algorithmus-Funktionsobjekt)