std::deque<T,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::deque

Membertypen
Memberfunktionen
deque::deque deque::~deque deque::operator= deque::assign deque::assign_range (C++23)   deque::get_allocator Elementzugriff deque::at deque::operator[] deque::front deque::back Iteratoren deque::begindeque::cbegin (C++11) deque::enddeque::cend (C++11) deque::rbegindeque::crbegin (C++11) deque::renddeque::crend (C++11)	Kapazität deque::empty deque::size deque::max_size deque::shrink_to_fit (DR*) Modifizierer deque::clear deque::insert deque::insert_range (C++23) deque::emplace deque::erase deque::push_front deque::emplace_front (C++11) deque::prepend_range (C++23) deque::pop_front deque::push_back deque::emplace_back (C++11) deque::append_range (C++23) deque::pop_back deque::resize deque::swap
Nicht-Member-Funktionen
operator==operator<=> (C++20) swap(std::deque) erase(std::deque)erase_if(std::deque) (C++20)(C++20)	operator!=operator<operator>operator<=operator>= (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)
Deduktionsleitfäden(C++17)

 

	(1)
iterator erase( iterator pos );			(bis C++11)
iterator erase( const_iterator pos );			(seit C++11)
		(2)
iterator erase( iterator first, iterator last );				(bis C++11)
iterator erase( const_iterator first, const_iterator last );				(seit C++11)

Löscht die angegebenen Elemente aus dem Container.

1) Entfernt das Element an der Position pos.

2) Entfernt die Elemente im Bereich [first, last).

Alle Iteratoren und Referenzen werden ungültig, es sei denn, die gelöschten Elemente befinden sich am Ende oder am Anfang des Containers. In diesem Fall werden nur die Iteratoren und Referenzen auf die gelöschten Elemente ungültig. Der end()-Iterator wird ebenfalls ungültig, es sei denn, die gelöschten Elemente befinden sich am Anfang des Containers und das letzte Element wird nicht gelöscht.

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.

Der Iterator first muss nicht dereferenzierbar sein, wenn first == last: Das Löschen eines leeren Bereichs hat keine Auswirkung.

Parameter

pos	-	Iterator auf das zu entfernende Element
first, last	-	Das Iteratorenpaar, das den Bereich der zu entfernenden Elemente definiert
Typanforderungen
- T muss die Anforderungen von MoveAssignable erfüllen.

Rückgabewert

Iterator nach dem letzten entfernten Element.

1) Wenn pos sich auf das letzte Element bezieht, wird der end()-Iterator zurückgegeben.

2) Wenn last == end() vor der Entfernung, dann wird der aktualisierte end()-Iterator zurückgegeben.

Wenn [first, last) ein leerer Bereich ist, wird last zurückgegeben.

Ausnahmen

Wirft keine Ausnahme, es sei denn, der Zuweisungsoperator von T wirft eine Ausnahme.

Komplexität

Linear: Die Anzahl der Aufrufe des Destruktors von T ist gleich der Anzahl der gelöschten Elemente. Die Anzahl der Aufrufe des Zuweisungsoperators von T ist nicht größer als der kleinere Wert aus der Anzahl der Elemente vor den gelöschten Elementen und der Anzahl der Elemente nach den gelöschten Elementen.

Hinweise

Wenn Container-Elemente basierend auf einem Prädikat gelöscht werden müssen, anstatt den Container zu durchlaufen und den unären erase aufzurufen, wird die Iterator-Bereichsüberladung im Allgemeinen mit std::remove()/std::remove_if() verwendet, um die Anzahl der Verschiebungen der verbleibenden (nicht entfernten) Elemente zu minimieren – dies ist das Erase-Remove-Idiom. std::erase_if() ersetzt das Erase-Remove-Idiom.(seit C++20)

Beispiel

Führen Sie diesen Code aus

#include <deque>
#include <iostream>
 
 
void print_container(const std::deque<int>& c)
{
    for (int i : c)
        std::cout << i << ' ';
    std::cout << '\n';
}
 
int main()
{
    std::deque<int> c{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    print_container(c);
 
    c.erase(c.begin());
    print_container(c);
 
    c.erase(c.begin() + 2, c.begin() + 5);
    print_container(c);
 
    // Erase all even numbers
    for (std::deque<int>::iterator it = c.begin(); it != c.end();)
    {
        if (*it % 2 == 0)
            it = c.erase(it);
        else
            ++it;
    }
    print_container(c);
}

Ausgabe

0 1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 6 7 8 9
1 7 9

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 151	C++98	first musste dereferenzierbar sein, was verursachte das Löschen eines leeren deque zu undefiniertem Verhalten	nicht erforderlich, wenn first == last
LWG 638	C++98	Der Past-the-End-Iterator wurde nicht ungültig	er wird ungültig, wenn die Elemente aus der Mitte oder vom Ende gelöscht werden

Siehe auch

erase(std::deque)erase_if(std::deque) (C++20)	entfernt alle Elemente, die bestimmte Kriterien erfüllen (function template)
clear	leert den Inhalt (public member function)