Namespaces
Variants

std:: set

From cppreference.net
Definiert im Header <set>
template <

class Key,
class Compare = std:: less < Key > ,
class Allocator = std:: allocator < Key >

> class set ;
(1)
namespace pmr {

template <
class Key,
class Compare = std:: less < Key >
> using set = std :: set < Key, Compare, std:: pmr :: polymorphic_allocator < Key >> ;

}
(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 std::set -Objekte im Allgemeinen nicht constexpr sein, da jeder dynamisch allokierte Speicher in derselben Auswertung des konstanten Ausdrucks freigegeben werden muss.

(seit C++26)

Inhaltsverzeichnis

Template-Parameter

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

Allocator::pointer

(bis C++11)

std:: allocator_traits < Allocator > :: pointer

(seit C++11)
const_pointer

Allocator::const_pointer

(bis C++11)

std:: allocator_traits < Allocator > :: const_pointer

(seit C++11)
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 >
struct /*unspezifiziert*/
{
Iter     position ;
bool inserted ;
NodeType node ;
} ;

instanziiert mit den Template-Argumenten iterator und node_type .

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
gibt einen Iterator zum Anfang zurück
(öffentliche Member-Funktion)
(C++11)
gibt einen Iterator zum Ende zurück
(öffentliche Member-Funktion)
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)
fügt eine Reihe von Elementen ein
(öffentliche Elementfunktion)
(C++11)
Konstruiert Element direkt vor Ort
(öffentliche Elementfunktion)
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)
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)
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)