operator==,!=,<,<=,>,>=,<=>(std::multiset)

 

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

 

Container-Bibliothek

Sequenz

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

hive (C++26)

deque

forward_list (C++11)

list

Assoziativ

setzt

multiset

map

multimap

Ungeordnete assoziative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adapter

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Ansichten

span (C++20)

mdspan (C++23)

Tabellen

Iterator-Invalidierung

Mitgliedsfunktionstabelle

Nicht-Mitgliedsfunktionstabelle

 

std::multiset

Memberfunktionen

multiset::multiset multiset::~multiset         multiset::operator= multiset::get_allocator

Iteratoren multiset::beginmultiset::cbegin (C++11) multiset::endmultiset::cend (C++11) multiset::rbeginmultiset::crbegin (C++11)     multiset::rendmultiset::crend (C++11) Kapazität multiset::size multiset::max_size multiset::empty Observer multiset::key_comp multiset::value_comp Modifizierer multiset::clear multiset::erase multiset::swap multiset::extract (C++17) multiset::merge (C++17) multiset::insert multiset::insert_range (C++23) multiset::emplace (C++11) multiset::emplace_hint (C++11) Suche multiset::count multiset::find multiset::contains (C++20) multiset::equal_range multiset::lower_bound multiset::upper_bound

Nicht-Member-Funktionen

std::swap(std::multiset) erase_if(std::multiset) (C++20)   operator==operator<=> (C++20) operator!=operator<operator>operator<=operator>= (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)

Deduction guides(C++17)

 

Definiert in Header <set>
template< class Key, class Compare, class Alloc > bool operator==( const std::multiset<Key, Compare, Alloc>& lhs,                  const std::multiset<Key, Compare, Alloc>& rhs );	(1)
template< class Key, class Compare, class Alloc > bool operator!=( const std::multiset<Key, Compare, Alloc>& lhs,                  const std::multiset<Key, Compare, Alloc>& rhs );	(2)	(bis C++20)
template< class Key, class Compare, class Alloc > bool operator<( const std::multiset<Key, Compare, Alloc>& lhs,                 const std::multiset<Key, Compare, Alloc>& rhs );	(3)	(bis C++20)
template< class Key, class Compare, class Alloc > bool operator<=( const std::multiset<Key, Compare, Alloc>& lhs,                  const std::multiset<Key, Compare, Alloc>& rhs );	(4)	(bis C++20)
template< class Key, class Compare, class Alloc > bool operator>( const std::multiset<Key, Compare, Alloc>& lhs,                 const std::multiset<Key, Compare, Alloc>& rhs );	(5)	(bis C++20)
template< class Key, class Compare, class Alloc > bool operator>=( const std::multiset<Key, Compare, Alloc>& lhs,                  const std::multiset<Key, Compare, Alloc>& rhs );	(6)	(bis C++20)
template< class Key, class Compare, class Alloc > synth-three-way-result<T>     operator<=>( const std::multiset<Key, Compare, Alloc>& lhs,                  const std::multiset<Key, Compare, Alloc>& rhs );	(7)	(seit C++20)

Vergleicht den Inhalt zweier multisets.

1,2) Prüft, ob der Inhalt von lhs und rhs gleich ist, d. h. sie haben die gleiche Anzahl von Elementen und jedes Element in lhs ist mit dem Element in rhs an der gleichen Position gleich.

3-6) Vergleicht den Inhalt von lhs und rhs lexikographisch. Der Vergleich wird von einer Funktion ausgeführt, die äquivalent zu std::lexicographical_compare ist. Dieser Vergleich ignoriert die Sortierung Compare des multisets.

7) Vergleicht den Inhalt von lhs und rhs lexikographisch. Der Vergleich wird so ausgeführt, als ob std::lexicographical_compare_three_way(lhs.begin(), lhs.end(),
                                       rhs.begin(), rhs.end(), synth-three-way) aufgerufen würde. Dieser Vergleich ignoriert die Sortierung Compare des multisets.

Der Rückgabetyp ist der Rückgabetyp von synth-three-way (d. h. synth-three-way-result <T>).

Wenn keine der folgenden Bedingungen erfüllt ist, ist das Verhalten undefiniert

• T modelliert three_way_comparable.
• < ist für Werte des Typs (möglicherweise const-qualifiziert) T definiert, und < ist eine totale Ordnungsrelation.

Die Operatoren <, <=, >, >= und != sind synthetisiert aus operator<=> und operator== beziehungsweise.

(seit C++20)

Parameter

lhs, rhs	-	Zu vergleichende multisets
- Key muss die Anforderungen von EqualityComparable erfüllen, um die Überladungen (1,2) verwenden zu können.

Rückgabewert

1) true, wenn der Inhalt der multisets gleich ist, false andernfalls.

2) true, wenn der Inhalt der multisets nicht gleich ist, false andernfalls.

3) true, wenn der Inhalt von lhs lexikographisch kleiner als der Inhalt von rhs ist, false andernfalls.

4) true, wenn der Inhalt von lhs lexikographisch kleiner oder gleich dem Inhalt von rhs ist, false andernfalls.

5) true, wenn der Inhalt von lhs lexikographisch größer als der Inhalt von rhs ist, false andernfalls.

6) true, wenn der Inhalt von lhs lexikographisch größer oder gleich dem Inhalt von rhs ist, false andernfalls.

7) Die relative Ordnung des ersten Paares nicht-gleicher Elemente in lhs und rhs, wenn solche Elemente vorhanden sind, andernfalls lhs.size() <=> rhs.size().

Komplexität

1,2) Konstant, wenn lhs und rhs unterschiedliche Größen haben, andernfalls linear zur Größe des multisets.

3-7) Linear zur Größe des multisets.

Hinweise

Die relationalen Operatoren sind in Bezug auf den `operator<` des Elementtyps definiert.	(bis C++20)
Die relationalen Operatoren sind in Bezug auf synth-three-way definiert, der, wenn möglich, `operator<=>` und andernfalls `operator<` verwendet. Insbesondere, wenn das Element selbst keinen `operator<=>` bereitstellt, aber implizit in einen dreiwertig vergleichbaren Typ konvertiert werden kann, wird diese Konvertierung anstelle von `operator<` verwendet.	(seit C++20)

Beispiel

Führen Sie diesen Code aus

#include <cassert>
#include <compare>
#include <set>
 
int main()
{
    const std::multiset
        a{1, 2, 3},
        b{1, 2, 3},
        c{7, 8, 9, 10};
 
    assert
    (""
        "Compare equal containers:" &&
        (a != b) == false &&
        (a == b) == true &&
        (a < b) == false &&
        (a <= b) == true &&
        (a > b) == false &&
        (a >= b) == true &&
        (a <=> b) != std::weak_ordering::less &&
        (a <=> b) != std::weak_ordering::greater &&
        (a <=> b) == std::weak_ordering::equivalent &&
        (a <=> b) >= 0 &&
        (a <=> b) <= 0 &&
        (a <=> b) == 0 &&
 
        "Compare non equal containers:" &&
        (a != c) == true &&
        (a == c) == false &&
        (a < c) == true &&
        (a <= c) == true &&
        (a > c) == false &&
        (a >= c) == false &&
        (a <=> c) == std::weak_ordering::less &&
        (a <=> c) != std::weak_ordering::equivalent &&
        (a <=> c) != std::weak_ordering::greater &&
        (a <=> c) < 0 &&
        (a <=> c) != 0 &&
        (a <=> c) <= 0 &&
    "");
}

Defect reports

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 3431	C++20	operator<=> erforderte nicht, dass T three_way_comparable modelliert.	requires