std::unordered_set<Key,Hash,KeyEqual,Allocator>::erase

 

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::unordered_set

Membertypen
Memberfunktionen
unordered_set::unordered_set unordered_set::~unordered_set unordered_set::operator= unordered_set::get_allocator Iteratoren unordered_set::beginunordered_set::cbegin unordered_set::endunordered_set::cend Kapazität unordered_set::size unordered_set::max_size unordered_set::empty Modifizierer unordered_set::clear unordered_set::erase unordered_set::swap unordered_set::extract (C++17) unordered_set::merge (C++17) unordered_set::insert unordered_set::insert_range (C++23)   unordered_set::emplace unordered_set::emplace_hint	Suche unordered_set::count unordered_set::find unordered_set::contains (C++20) unordered_set::equal_range Bucket-Schnittstelle unordered_set::begin(size_type)unordered_set::cbegin(size_type) unordered_set::end(size_type)unordered_set::cend(size_type) unordered_set::bucket_count unordered_set::max_bucket_count unordered_set::bucket_size unordered_set::bucket Hash-Politik unordered_set::load_factor unordered_set::max_load_factor unordered_set::rehash unordered_set::reserve Observer unordered_set::hash_function unordered_set::key_eq
Nicht-Member-Funktionen
operator==operator!= (bis C++20)	std::swap(std::unordered_set) erase_if(std::unordered_set) (C++20)
Abzugsleitfäden (C++17)

 

	(1)
iterator erase( iterator pos );			(seit C++11) (bis C++23)
iterator erase( iterator pos )     requires(!std::same_as<iterator, const_iterator>);			(seit C++23)
iterator erase( const_iterator pos );		(2)	(seit C++11)
iterator erase( const_iterator first, const_iterator last );		(3)	(seit C++11)
size_type erase( const Key& key );		(4)	(seit C++11)
template< class K > size_type erase( K&& x );		(5)	(seit C++23)

Entfernt angegebene Elemente aus dem Container. Die Reihenfolge der verbleibenden Elemente bleibt erhalten. (Dies ermöglicht das Löschen einzelner Elemente während der Iteration durch den Container.)

1,2) Entfernt das Element an der Position pos. Nur ein Überladung ist vorhanden, wenn iterator und const_iterator vom selben Typ sind.

3) Entfernt die Elemente im Bereich [first, last), was ein gültiger Bereich in *this sein muss.

4) Entfernt das Element (falls vorhanden) mit dem Schlüssel, das zu key äquivalent ist.

5) Entfernt alle Elemente mit einem Schlüssel, der äquivalent zu dem Wert x ist. Diese Überladung nimmt nur an der Overload-Auflösung teil, wenn Hash::is_transparent und KeyEqual::is_transparent gültig sind und jeweils einen Typ bezeichnen und weder iterator noch const_iterator implizit von K konvertierbar sind. Dies setzt voraus, dass ein solches Hash sowohl mit dem Typ K als auch mit dem Typ Key aufrufbar ist und dass KeyEqual transparent ist, was zusammen die Aufrufbarkeit dieser Funktion ohne die Erzeugung einer Instanz von Key ermöglicht.

Referenzen und Iteratoren auf die gelöschten Elemente werden ungültig. Andere Iteratoren und Referenzen werden nicht ungültig.

Der Iterator pos muss gültig und dereferenzierbar sein. Daher kann der end() Iterator (der gültig, aber nicht dereferenzierbar ist) nicht als Wert für pos verwendet werden.

Parameter

pos	-	Iterator auf das zu entfernende Element
first, last	-	Das Iteratorenpaar, das den Bereich der zu entfernenden Elemente definiert
key	-	Schlüsselwert der zu entfernenden Elemente
x	-	Ein Wert eines beliebigen Typs, der transparent mit einem Schlüssel verglichen werden kann, der die zu entfernenden Elemente bezeichnet

Rückgabewert

1-3) Iterator nach dem zuletzt entfernten Element.

4) Anzahl der entfernten Elemente (0 oder 1).

5) Anzahl der entfernten Elemente.

Ausnahmen

1-3) Wirft nichts.

4,5) Alle Ausnahmen, die vom Hash- und KeyEqual-Objekt ausgelöst werden.

Komplexität

Gegeben eine Instanz c von unordered_set

1,2) Durchschnittlicher Fall: konstant, schlimmster Fall: c.size().

3) Durchschnittlicher Fall: std::distance(first, last), schlimmster Fall: c.size().

4) Durchschnittlicher Fall: c.count(key), schlimmster Fall: c.size().

5) Durchschnittlicher Fall: c.count(x), schlimmster Fall: c.size().

Anmerkungen

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_associative_heterogeneous_erasure	202110L	(C++23)	Heterogene Löschung in assoziativen Containern und unordentlichen assoziativen Containern; Überladung (5)

Beispiel

Führen Sie diesen Code aus

#include <unordered_set>
#include <iostream>
 
int main()
{
    std::unordered_set<int> c = {1, 2, 3, 4, 1, 2, 3, 4};
 
    auto print = [&c]
    {
        std::cout << "c = { ";
        for (int n : c)
            std::cout << n << ' ';
        std::cout << "}\n";
    };
    print();
 
    std::cout << "Erase all odd numbers:\n";
    for (auto it = c.begin(); it != c.end();)
    {
        if (*it % 2 != 0)
            it = c.erase(it);
        else
            ++it;
    }
    print();
 
    std::cout << "Erase 1, erased count: " << c.erase(1) << '\n';
    std::cout << "Erase 2, erased count: " << c.erase(2) << '\n';
    std::cout << "Erase 2, erased count: " << c.erase(2) << '\n';
    print();
}

Mögliche Ausgabe

c = { 1 2 3 4 }
Erase all odd numbers:
c = { 2 4 }
Erase 1, erased count: 0
Erase 2, erased count: 1
Erase 2, erased count: 0
c = { 4 }

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 2059	C++11	Es gab Mehrdeutigkeit für die Überladung (2)	Überladung (1) hinzugefügt
LWG 2356	C++11	die Reihenfolge nicht-äquivalenter Elemente, die nicht gelöscht wurden, war nicht garantiert beibehalten zu werden	musste erhalten bleiben

Siehe auch

clear

leert den Inhalt (public member function)