std::list<T,Allocator>::unique

 

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

Memberfunktionen
list::list list::~list list::operator= list::assign list::assign_range (C++23)   list::get_allocator Elementzugriff list::front list::back Iteratoren list::beginlist::cbegin (C++11) list::endlist::cend (C++11) list::rbeginlist::crbegin (C++11) list::rendlist::crend (C++11) Kapazität list::size list::empty list::max_size	Modifizierer list::clear list::insert list::insert_range (C++23) list::emplace (C++11) list::erase list::push_front list::emplace_front (C++11) list::prepend_range (C++23) list::pop_front list::push_back list::emplace_back (C++11) list::append_range (C++23) list::pop_back list::resize list::swap Operationen list::merge list::splice list::removelist::remove_if list::reverse list::unique list::sort
Nicht-Member-Funktionen
operator==operator<=> (C++20) swap(std::list) erase(std::list)erase_if(std::list) (C++20)(C++20)	operator!=operator<operator>operator<=operator>= (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)
Deduktionshilfen(C++17)

 

	(1)
void unique();			(bis C++20)
size_type unique();			(seit C++20)
		(2)
template< class BinaryPredicate > void unique( BinaryPredicate p );				(bis C++20)
template< class BinaryPredicate > size_type unique( BinaryPredicate p );				(seit C++20)

Entfernt alle *aufeinanderfolgenden* doppelten Elemente aus dem Container. Nur das erste Element jeder Gruppe von gleichen Elementen bleibt erhalten. Macht nur die Iteratoren und Referenzen auf die entfernten Elemente ungültig.

1) Verwendet operator== zum Vergleichen der Elemente.

2) Verwendet p zum Vergleichen der Elemente.

Das Verhalten ist undefiniert, wenn der entsprechende Komparator keine Äquivalenzrelation etabliert.

Parameter

p	-	binäre Prädikatfunktion, die ​true zurückgibt, wenn die Elemente als gleich behandelt werden sollen. Die Signatur der Prädikatfunktion sollte äquivalent zur folgenden sein:  bool pred(const Type1 &a, const Type2 &b); Obwohl die Signatur nicht zwingend const & haben muss, darf die Funktion die ihr übergebenen Objekte nicht modifizieren und muss alle Werte vom Typ (möglicherweise const) Type1 und Type2 unabhängig von der Wertkategorie akzeptieren können (daher ist Type1 & nicht erlaubt, ebenso wenig wie Type1, es sei denn, für Type1 ist eine Verschiebung gleichbedeutend mit einer Kopie(seit C++11)). Die Typen Type1 und Type2 müssen so beschaffen sein, dass ein Objekt vom Typ list<T,Allocator>::const_iterator dereferenziert und dann implizit in beide konvertiert werden kann. ​
Typanforderungen
- BinaryPredicate muss die Anforderungen an einen BinaryPredicate erfüllen.

Rückgabewert

(keine)	(bis C++20)
Die Anzahl der entfernten Elemente.	(seit C++20)

Komplexität

Wenn empty() true ist, wird kein Vergleich durchgeführt.

Andernfalls, gegeben \(\scriptsize N\)N als std::distance(begin(), end())

1) Genau \(\scriptsize N-1\)N-1 Vergleiche mittels operator==.

2) Genau \(\scriptsize N-1\)N-1 Aufrufe des Prädikats p.

Anmerkungen

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_list_remove_return_type	201806L	(C++20)	Änderung des Rückgabetyps

Beispiel

Führen Sie diesen Code aus

#include <iostream>
#include <list>
 
std::ostream& operator<< (std::ostream& os, std::list<int> const& container)
{
    for (int val : container)
        os << val << ' ';
    return os << '\n';
}
 
int main()
{
    std::list<int> c{1, 2, 2, 3, 3, 2, 1, 1, 2};
    std::cout << "Before unique(): " << c;
    const auto count1 = c.unique();
    std::cout << "After unique():  " << c
              << count1 << " elements were removed\n";
 
    c = {1, 2, 12, 23, 3, 2, 51, 1, 2, 2};
    std::cout << "\nBefore unique(pred): " << c;
 
    const auto count2 = c.unique([mod = 10](int x, int y)
    {
        return (x % mod) == (y % mod);
    });
 
    std::cout << "After unique(pred):  " << c
              << count2 << " elements were removed\n";
}

Ausgabe

Before unique(): 1 2 2 3 3 2 1 1 2
After unique():  1 2 3 2 1 2
3 elements were removed
 
Before unique(pred): 1 2 12 23 3 2 51 1 2 2
After unique(pred):  1 2 23 2 51 2
4 elements were removed

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 1207	C++98	war es unklar, ob Iteratoren und/oder Referenzen ungültig werden	macht nur Iteratoren und Referenzen auf die entfernten Elemente ungültig

Siehe auch

unique

Entfernt aufeinanderfolgende doppelte Elemente in einem Bereich (Funktionstemplate)