std::flat_map<Key,T,Compare,KeyContainer,MappedContainer>::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::flat_map

Membertypen

Memberfunktionen

flat_map::flat_map flat_map::operator= Elementzugriff flat_map::at flat_map::operator[] Iteratoren flat_map::beginflat_map::cbegin flat_map::endflat_map::cend flat_map::rbeginflat_map::crbegin flat_map::rendflat_map::crend Suche flat_map::count flat_map::find flat_map::contains flat_map::equal_range    flat_map::lower_bound flat_map::upper_bound Kapazität flat_map::size flat_map::max_size flat_map::empty Modifizierer flat_map::clear flat_map::erase flat_map::swap flat_map::emplace flat_map::extract flat_map::replace flat_map::insert flat_map::insert_range flat_map::insert_or_assign flat_map::emplace_hint flat_map::try_emplace Observer flat_map::key_comp flat_map::keys flat_map::value_comp flat_map::values

Nicht-Member-Funktionen

operator==operator<=>         swap(std::flat_map) erase_if(std::flat_map)

Hilfsklassen

uses_allocator<std::flat_map>

Tags

sorted_unique       sorted_unique_t

Deduction Guides

 

iterator erase( iterator position );	(1)	(seit C++23)
iterator erase( const_iterator pos );	(2)	(seit C++23)
iterator erase( const_iterator first, const_iterator last );	(3)	(seit C++23)
size_type erase( const Key& key );	(4)	(seit C++23)
template< class K > size_type erase( K&& x );	(5)	(seit C++23)

Entfernt angegebene Elemente aus dem Container.

1,2) Entfernt das Element an der Position pos.

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 sich äquivalent zum Wert x verhält. Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn der qualifizierte Bezeichner Compare::is_transparent gültig ist und einen Typ bezeichnet und weder iterator noch const_iterator von K implizit konvertierbar sind. Es ermöglicht das Aufrufen dieser Funktion, ohne eine Instanz von Key zu erstellen.

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 Compare-Objekt ausgelöst werden.

Komplexität

Abhängig von den zugrundeliegenden Containern. Typischerweise linear.

Beispiel

Führen Sie diesen Code aus

#include <flat_map>
#include <iostream>
 
int main()
{
    std::flat_map<int, std::string> c =
    {
        {1, "one"}, {2, "two"}, {3, "three"},
        {4, "four"}, {5, "five"}, {6, "six"}
    };
 
    // erase all odd numbers from c
    for (auto it = c.begin(); it != c.end();)
    {
        if (it->first % 2 != 0)
            it = c.erase(it);
        else
            ++it;
    }
 
    for (auto& p : c)
        std::cout << p.second << ' ';
    std::cout << '\n';
}

Ausgabe

two four six

Siehe auch

clear

leert den Inhalt (public member function)