std:: set
|
Definiert im Header
<set>
|
||
|
template
<
class
Key,
|
(1) | |
|
namespace
pmr
{
template
<
|
(2) | (seit C++17) |
std::set
ist ein assoziativer Container, der eine sortierte Menge eindeutiger Objekte vom Typ
Key
enthält. Die Sortierung erfolgt mithilfe der Schlüsselvergleichsfunktion
Compare
. Such-, Entfernungs- und Einfügeoperationen haben logarithmische Komplexität. Mengen werden üblicherweise als
Red-Black-Bäume
implementiert.
Überall dort, wo die Standardbibliothek die Compare -Anforderungen verwendet, wird Eindeutigkeit durch die Äquivalenzrelation bestimmt. In ungenauen Begriffen gelten zwei Objekte a und b als äquivalent, wenn keines als kleiner als das andere bewertet wird: ! comp ( a, b ) && ! comp ( b, a ) .
std::set
erfüllt die Anforderungen von
Container
,
AllocatorAwareContainer
,
AssociativeContainer
und
ReversibleContainer
.
Alle Memberfunktionen von
std::set
sind
constexpr
: Es ist möglich,
std::set
-Objekte in der Auswertung eines konstanten Ausdrucks zu erstellen und zu verwenden.
Allerdings können
|
(seit C++26) |
Inhaltsverzeichnis |
Template-Parameter
|
Dieser Abschnitt ist unvollständig
Grund: Beschreibungen der Template-Parameter hinzufügen. |
Mitgliedertypen
| Typ | Definition | ||||
key_type
|
Key
|
||||
value_type
|
Key
|
||||
size_type
|
Vorzeichenloser Ganzzahltyp (üblicherweise std::size_t ) | ||||
difference_type
|
Vorzeichenbehafteter Ganzzahltyp (üblicherweise std::ptrdiff_t ) | ||||
key_compare
|
Compare
|
||||
value_compare
|
Compare
|
||||
allocator_type
|
Allocator
|
||||
reference
|
value_type & | ||||
const_reference
|
const value_type & | ||||
pointer
|
|
||||
const_pointer
|
|
||||
iterator
|
Konstanter
LegacyBidirectionalIterator
und
ConstexprIterator
(seit C++26)
zu
value_type
|
||||
const_iterator
|
LegacyBidirectionalIterator und ConstexprIterator (seit C++26) zu const value_type | ||||
reverse_iterator
|
std:: reverse_iterator < iterator > | ||||
const_reverse_iterator
|
std:: reverse_iterator < const_iterator > | ||||
node_type
(seit C++17)
|
eine Spezialisierung von node handle , die einen Container-Knoten repräsentiert | ||||
insert_return_type
(seit C++17)
|
Typ, der das Ergebnis des Einfügens eines
node_type
beschreibt, eine Spezialisierung von
template
<
class
Iter,
class
NodeType
>
|
Memberfunktionen
konstruiert den
set
(öffentliche Elementfunktion) |
|
zerstört den
set
(öffentliche Elementfunktion) |
|
|
weist dem Container Werte zu
(öffentliche Elementfunktion) |
|
|
gibt den zugeordneten Allokator zurück
(öffentliche Elementfunktion) |
|
Iteratoren |
|
|
(C++11)
|
gibt einen Iterator zum Anfang zurück
(öffentliche Member-Funktion) |
|
(C++11)
|
gibt einen Iterator zum Ende zurück
(öffentliche Member-Funktion) |
|
(C++11)
|
gibt einen umgekehrten Iterator zum Anfang zurück
(öffentliche Elementfunktion) |
|
(C++11)
|
gibt einen umgekehrten Iterator zum Ende zurück
(öffentliche Elementfunktion) |
Kapazität |
|
|
prüft, ob der Container leer ist
(öffentliche Elementfunktion) |
|
|
gibt die Anzahl der Elemente zurück
(öffentliche Elementfunktion) |
|
|
gibt die maximal mögliche Anzahl von Elementen zurück
(öffentliche Elementfunktion) |
|
Modifikatoren |
|
|
löscht den Inhalt
(öffentliche Elementfunktion) |
|
|
fügt Elemente ein
oder Knoten
(seit C++17)
(öffentliche Elementfunktion) |
|
|
(C++23)
|
fügt eine Reihe von Elementen ein
(öffentliche Elementfunktion) |
|
(C++11)
|
Konstruiert Element direkt vor Ort
(öffentliche Elementfunktion) |
|
(C++11)
|
Konstruiert Elemente direkt unter Verwendung eines Hinweises
(öffentliche Member-Funktion) |
|
löscht Elemente
(öffentliche Elementfunktion) |
|
|
tauscht die Inhalte aus
(öffentliche Elementfunktion) |
|
|
(C++17)
|
extrahiert Knoten aus dem Container
(öffentliche Elementfunktion) |
|
(C++17)
|
verbindet Knoten aus einem anderen Container
(öffentliche Elementfunktion) |
Lookup |
|
|
gibt die Anzahl der Elemente mit einem bestimmten Schlüssel zurück
(öffentliche Elementfunktion) |
|
|
findet Element mit spezifischem Schlüssel
(öffentliche Elementfunktion) |
|
|
(C++20)
|
prüft, ob der Container ein Element mit spezifischem Schlüssel enthält
(öffentliche Elementfunktion) |
|
gibt den Bereich der Elemente zurück, die einem bestimmten Schlüssel entsprechen
(öffentliche Elementfunktion) |
|
|
gibt einen Iterator zum ersten Element zurück,
das nicht kleiner
als der angegebene Schlüssel ist
(öffentliche Elementfunktion) |
|
|
gibt einen Iterator zum ersten Element zurück,
größer
als der angegebene Schlüssel
(öffentliche Elementfunktion) |
|
Beobachter |
|
|
gibt die Funktion zurück, die Schlüssel vergleicht
(öffentliche Elementfunktion) |
|
gibt die Funktion zurück, die Schlüssel in Objekten vom Typ
value_type
vergleicht
(öffentliche Elementfunktion) |
|
Nicht-Member-Funktionen
|
(entfernt in C++20)
(entfernt in C++20)
(entfernt in C++20)
(entfernt in C++20)
(entfernt in C++20)
(C++20)
|
vergleicht lexikographisch die Werte von zwei
set
s
(Funktions-Template) |
|
spezialisiert den
std::swap
Algorithmus
(Funktions-Template) |
|
|
(C++20)
|
löscht alle Elemente, die bestimmte Kriterien erfüllen
(Funktions-Template) |
Deduktionsleitfäden |
(seit C++17) |
Hinweise
Die Member-Typen
iterator
und
const_iterator
können Aliase für denselben Typ sein. Dies bedeutet, dass das Definieren eines Paares von Funktionsüberladungen, die die beiden Typen als Parametertypen verwenden, die
One Definition Rule
verletzen kann. Da
iterator
in
const_iterator
konvertierbar ist, wird stattdessen eine einzelne Funktion mit einem
const_iterator
als Parametertyp funktionieren.
| Feature-Test Makro | Wert | Std | Feature |
|---|---|---|---|
__cpp_lib_containers_ranges
|
202202L
|
(C++23) | Ranges-Konstruktion und -Einfügung für Container |
__cpp_lib_constexpr_set
|
202502L
|
(C++26) |
constexpr
std::set
|
Beispiel
#include <algorithm> #include <iomanip> #include <iostream> #include <iterator> #include <set> #include <string_view> template<typename T> std::ostream& operator<<(std::ostream& out, const std::set<T>& set) { if (set.empty()) return out << "{}"; out << "{ " << *set.begin(); std::for_each(std::next(set.begin()), set.end(), [&out](const T& element) { out << ", " << element; }); return out << " }"; } int main() { std::set<int> set{1, 5, 3}; std::cout << set << '\n'; set.insert(2); std::cout << set << '\n'; set.erase(1); std::cout << set << "\n\n"; std::set<int> keys{3, 4}; for (int key : keys) { if (set.contains(key)) std::cout << set << " enthält " << key << '\n'; else std::cout << set << " enthält nicht " << key << '\n'; } std::cout << '\n'; std::string_view word = "element"; std::set<char> characters(word.begin(), word.end()); std::cout << "Es gibt " << characters.size() << " eindeutige Zeichen in " << std::quoted(word) << ":\n" << characters << '\n'; }
Ausgabe:
{ 1, 3, 5 }
{ 1, 2, 3, 5 }
{ 2, 3, 5 }
{ 2, 3, 5 } enthält 3
{ 2, 3, 5 } enthält nicht 4
Es gibt 5 eindeutige Zeichen in "element":
{ e, l, m, n, t }
Fehlerberichte
Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.
| DR | Angewendet auf | Verhalten wie veröffentlicht | Korrektes Verhalten |
|---|---|---|---|
| LWG 103 | C++98 | Iterator erlaubt Modifikation von Schlüsseln | Iterator als konstant festgelegt |
| LWG 230 | C++98 |
Key
war nicht erforderlich
CopyConstructible
zu sein
(ein Schlüssel vom Typ
Key
könnte möglicherweise nicht konstruiert werden)
|
Key
wird ebenfalls benötigt
um CopyConstructible zu sein |
Siehe auch
|
Sammlung von Schlüsseln, sortiert nach Schlüsseln
(Klassen-Template) |
|
|
(C++11)
|
Sammlung eindeutiger Schlüssel, gehasht nach Schlüsseln
(Klassen-Template) |
|
(C++23)
|
passt einen Container an, um eine Sammlung eindeutiger Schlüssel zu bieten, sortiert nach Schlüsseln
(Klassen-Template) |