`set`-Klasse

Artikel
10/12/2023

Die Containerklasse set C++ Standard Library wird verwendet, um Daten aus einer Sammlung zu speichern und abzurufen. Die Werte der Elemente in den set Elementen sind eindeutig und dienen als Schlüsselwerte, nach denen die Daten automatisch sortiert werden. Der Wert eines Elements in einem set Element wird möglicherweise nicht direkt geändert. Stattdessen müssen Sie alte Werte löschen und Elemente mit neuen Werten einfügen.

Syntax

template <class Key,
    class Traits=less<Key>,
    class Allocator=allocator<Key>>
class set

Parameter

Key
Der in dem Satz zu speichernde Elementdatentyp.

Traits
Der Typ, der ein Funktionsobjekt bereitstellt, das zwei Elementwerte als Sortierschlüssel vergleichen kann, um deren relative Reihenfolge in dem Satz zu bestimmen. Dieses Argument ist optional, und das binäre Prädikat less <Key> ist der Standardwert.

In C++14 können Sie heterogene Suche aktivieren, indem Sie das std::less<> std::greater<> Prädikat angeben, das keine Typparameter enthält. Weitere Informationen finden Sie unter heterogenes Nachschlagen in Associative Containers .

Allocator
Der Typ, der das gespeicherte Zuordnungsobjekt darstellt, das Details zum Belegen und Freigeben des Arbeitsspeichers des Satzes kapselt. Dieses Argument ist optional, und der Standardwert ist allocator<Key>.

Hinweise

Ein C++-Standardbibliothekssatz ist:

Ein assoziativer Container, der ein Container variabler Größe ist, der den effizienten Abruf von Elementwerten auf Grundlage eines zugeordneten Schlüsselwert unterstützt. Außerdem handelt es sich um einen einfachen assoziativen Container, da es sich bei den Elementwerten um die wichtigsten Werte handelt.
Umkehrbar, da ein bidirektionaler Iterator für den Zugriff auf die Elemente bereitgestellt wird.
Sortiert, da die Elemente anhand von Schlüsselwerten innerhalb des Containers mit einer angegebenen Vergleichsfunktion sortiert werden.
Insofern eindeutig, da jedes der Elemente einen eindeutigen Schlüssel aufweisen muss. Da der Satz auch ein einfacher assoziativer Container ist, sind seine Elemente ebenfalls eindeutig.

Ein Satz wird auch als Klassenvorlage beschrieben, da die bereitgestellte Funktionalität generisch und unabhängig von dem spezifischen Datentyp ist, der als Elemente enthalten ist. Der zu verwendende Datentyp wird stattdessen in der Klassenvorlage zusammen mit der Vergleichsfunktion und der Zuweisung als Parameter angegeben.

Die Auswahl des Containertyps sollte im Allgemeinen auf Grundlage des für die Anwendung erforderlichen Suchen und Einfügetyps erfolgen. Assoziative Container sind auf Such-, Einfüge- und Entfernvorgänge optimiert. Die Memberfunktionen, die diese Vorgänge explizit unterstützen, sind effizient, und zwar in einer Zeit, die im Durchschnitt proportional zum Logarithmus der Anzahl der Elemente im Container liegt. Durch das Einfügen von Elementen werden keine Iteratoren ungültig, und durch das Entfernen von Elementen werden nur die Iteratoren ungültig, die auf die entfernten Elemente verwiesen haben.

Der Satz sollte der ausgewählte assoziative Container sein, wenn die Bedingungen, mit denen die Werte von der Anwendung den Schlüsseln zugeordnet werden, erfüllt werden. Die Elemente eines Satzes sind eindeutig und dienen als eigene Sortierschlüssel. Ein Modell für diesen Typ der Struktur ist eine geordnete Liste von z. B. Wörtern, in denen die Wörter möglicherweise nur einmal auftreten. Wenn mehrfaches Vorkommen der Wörter zugelassen wird, ist eine Multimenge die geeignete Containerstruktur. Wenn Werte einer Liste von eindeutigen Schlüsselwörtern hinzugefügt werden müssen, ist eine Zuordnung eine äquivalente Struktur, um diese Daten zu enthalten. Wenn die Schlüssel stattdessen nicht eindeutig sind, wäre ein Multimap der container der Wahl.

Der Satz sortiert die Reihenfolge, die es steuert, indem ein gespeichertes Funktionsobjekt vom Typ key_compareaufgerufen wird. Dieses gespeicherte Objekt ist eine Vergleichsfunktion, auf die durch Aufrufen der Memberfunktion key_compzugegriffen werden kann. Im Allgemeinen müssen die Elemente nur kleiner als vergleichbar sein, um diese Reihenfolge festzulegen, damit aufgrund zweier Elemente entweder festgestellt werden kann, dass sie gleichwertig sind (im Sinne, dass keines kleiner als der andere ist) oder dass ein Element kleiner als der andere ist. Dies führt zu einer Sortierung zwischen den nicht gleichwertigen Elementen. Etwas technischer betrachtet ist die Vergleichsfunktion ein binäres Prädikat, das eine strenge schwache Sortierung im mathematischen Sinn verursacht. Ein binäres Prädikat f(x,y) ist ein Funktionsobjekt mit zwei Argumentobjekten x und y und einem Rückgabewert von true oder false. Eine sortierung, die einem Satz auferlegt wird, ist eine strenge schwache Sortierung, wenn das binäre Prädikat irreflexiv, antisymmetrisch und transitiv ist und wenn die Äquivalenz transitiv ist, wobei zwei Objekte x und y definiert sind, um gleichwertig zu sein, wenn sowohl f x,y) als auch f(y,x) falsch sind. Wenn der stärkere Gleichheitszustand zwischen Schlüsseln die Äquivalenz ersetzt, erfolgt die Sortierung total (d. h., alle Elemente werden zueinander sortiert), und die verglichenen Schlüssel sind von den einander nicht mehr zu unterscheiden.

Der von der Setklasse bereitgestellte Iterator ist ein bidirektionaler Iterator, aber die Klassenmemberfunktionen insert und set verfügen über Versionen, die als Vorlagenparameter einen schwächeren Eingabe-Iterator verwenden, dessen Funktionalitätsanforderungen minimaler sind als die von der Klasse bidirektionaler Iteratoren garantierten. Die verschiedenen Iteratorkonzepte bilden eine Family, die durch Verfeinerungen in ihrer Funktionen verknüpft ist. Jedes Iteratorkonzept weist einen eigenen Satz von Anforderungen auf, und die damit funktionierenden Algorithmen müssen die Annahmen hinsichtlich der von diesem Iteratortyp bereitgestellten Anforderungen begrenzen. Es kann davon ausgegangen werden, dass ein Eingabeiterator möglicherweise so dereferenziert wird, dass er auf ein Objekt verweist und dieses möglicherweise zum folgenden Iterator in der Sequenz erhöht. Dies ist ein minimaler Satz von Funktionen, aber es genügt, sinnvoll über einen Bereich von Iteratoren [ First, Last) im Kontext der Memberfunktionen der Klasse zu sprechen.

Konstruktoren

Name	Beschreibung
`set`	Erstellt einen Satz, der leer oder die Kopie eines ganzen anderen Satzes oder eines Teils davon ist.

TypeDefs

Name	Beschreibung
`allocator_type`	Ein Typ, der die `allocator`-Klasse für das Set-Objekt darstellt.
`const_iterator`	Ein Typ, der einen bidirektionalen Iterator bereitstellt, der ein `const`-Element im Satz lesen kann.
`const_pointer`	Ein Typ, der einen Zeiger auf ein `const`-Element in einem Satz bereitstellt.
`const_reference`	Ein Typ, der einen Verweis auf ein `const` Element bereitstellt, das in einem Satz zum Lesen und Ausführen von `const` Vorgängen gespeichert ist.
`const_reverse_iterator`	Ein Typ, der einen bidirektionalen Iterator bereitstellt, mit dem jedes `const`-Element im Satz gelesen werden kann.
`difference_type`	Ein Ganzzahltyp mit Vorzeichen, der dazu verwendet werden kann, die Anzahl von Elementen eines Satzes in einem Bereich zwischen Elementen darzustellen, auf die von Iteratoren gezeigt wird.
`iterator`	Ein Typ, der einen bidirektionalen Iterator bereitstellt, mit dem jedes Element in einem Satz gelesen oder geändert werden kann.
`key_compare`	Eine Typ, der ein Funktionsobjekt bereitstellt, das zwei Sortierschlüssel vergleichen kann, um die relative Position von zwei Elementen im Satz zu bestimmen.
`key_type`	Der Typ beschreibt ein Objekt, das als Element eines Satzes in seiner Kapazität als Sortierschlüssel gespeichert wird.
`pointer`	Ein Typ, der einen Zeiger auf ein Element in einem Satz bereitstellt.
`reference`	Ein Typ, der einen Verweis auf ein in einem Satz gespeichertes Element bereitstellt.
`reverse_iterator`	Ein Typ, der einen bidirektionalen Iterator bereitstellt, mit dem ein Element in einem umgekehrten Satz gelesen oder geändert werden kann.
`size_type`	Ein Ganzzahltyp ohne Vorzeichen, der die Anzahl von Elementen in einem Satz darstellen kann.
`value_compare`	Der Typ, der ein Funktionsobjekt bereitstellt, das zwei Elemente vergleichen kann, um die relative Position im Satz zu bestimmen.
`value_type`	Der Typ beschreibt ein Objekt, das als Element eines Satzes in seiner Kapazität als Wert gespeichert wird.

Funktionen

Name	Beschreibung
`begin`	Gibt einen Iterator zurück, der auf das erste Element im `set`-Objekt verweist.
`cbegin`	Gibt einen konstanten Iterator zurück, der das erste Element in der `set` adressiert.
`cend`	Gibt einen konstanten Iterator zurück, der den Speicherort adressiert, der dem letzten Element eines `set`-Elements nachfolgt.
`clear`	Löscht alle Elemente einer `set` auf.
`contains`^C++20	Überprüfen Sie, ob ein Element mit dem angegebenen Schlüssel in der .`set`
`count`	Gibt die Anzahl von Elementen in einem `set`-Element zurück, dessen Schlüssel dem von einem Parameter angegebenen Schlüssel entspricht.
`crbegin`	Gibt einen konstanten Iterator zurück, der das erste Element im umgekehrten `set`-Element adressiert.
`crend`	Gibt einen konstanten Iterator zurück, der den Speicherort adressiert, der dem letzten Element eines umgekehrten `set`-Elements nachfolgt.
`emplace`	Fügt ein Element ein, das vor Ort in ein `set`-Element erstellt wird.
`emplace_hint`	Fügt ein Element ein, das vor Ort mit einem Platzierungshinweis in ein `set`-Element erstellt wird.
`empty`	Testet, ob ein `set`-Element leer ist.
`end`	Gibt einen Iterator zurück, der den Speicherort adressiert, der dem letzten Element einem `set`-Element nachfolgt.
`equal_range`	Gibt ein Iteratorpaar jeweils bezogen auf das erste Element in einem `set`-Objekt mit einem Schlüssel zurück, der größer als ein bestimmter Schlüssel ist, bzw. bezogen auf das erste Element im `set`-Objekt mit einem Schlüssel, der größer oder gleich dem Schlüssel ist.
`erase`	Es wird ein Element oder ein Bereich von Elementen in einem Satz von angegebenen Speicherorten entfernt, oder es werden die einem angegebenen Schlüssel entsprechenden Elemente entfernt.
`find`	Gibt einen Iterator zurück, der die Position eines Elements in einem `set`-Element adressiert, das einen Schlüssel aufweist, der einen angegebenen Schlüssel entspricht.
`get_allocator`	Gibt eine Kopie des zum Erstellen von `allocator` verwendeten `set`-Objekts zurück.
`insert`	Fügt ein Element oder einen Elementbereich in ein `set`-Element ein.
`key_comp`	Ruft eine Kopie des Vergleichsobjekts ab, das zum Sortieren der Schlüssel in `set` verwendet wird.
`lower_bound`	Gibt einen Iterator zum ersten Element in einem Satz mit einem Schlüssel zurück, der gleich oder größer als ein angegebener Schlüssel ist.
`max_size`	Gibt die Maximallänge der `set` zurück.
`rbegin`	Gibt einen Iterator zurück, der das erste Element in einem umgekehrten `set`-Element adressiert.
`rend`	Gibt einen Iterator zurück, der den Speicherort adressiert, der dem letzten Element eines umgekehrten `set`-Elements nachfolgt.
`size`	Gibt die Anzahl von Elementen in der `set` zurück.
`swap`	Tauscht die Elemente zweier `set`n.
`upper_bound`	Gibt einen Iterator zum ersten Element in einem `set`-Element mit einem Schlüssel zurück, der größer als ein angegebener Schlüssel ist.
`value_comp`	Ruft eine Kopie des Vergleichsobjekts ab, das zum Sortieren der Elementwerte in `set` verwendet wird.

Operatoren

Name	Beschreibung
`operator=`	Ersetzt die Elemente eines Satzes durch eine Kopie eines anderen Satzes.

`allocator_type`

Ein Typ, der die Zuweisungsklasse für das Set-Objekt darstellt.

typedef Allocator allocator_type;

Hinweise

allocator_type ist ein Synonym für den Vorlagenparameter Allocator.

Gibt das Funktionsobjekt zurück, das dem Vorlagenparameter Allocator entspricht und von einer Multimenge verwendet wird, um die jeweiligen Elemente zu sortieren.

Weitere Informationen Allocatorfinden Sie im Abschnitt "Hinweise" des set Themas "Klasse ".

Beispiel

Sehen Sie sich das Beispiel für ein Beispiel an get_allocator , das allocator_typeverwendet wird.

`begin`

Gibt einen Iterator zurück, der das erste Element im Satz adressiert.

const_iterator begin() const;

iterator begin();

Rückgabewert

Ein bidirektionaler Iterator, der das erste Element in der Menge adressiert oder auf den Speicherort hinweist, der auf eine leere Menge folgt.

Hinweise

Wenn der Rückgabewert begin eines const_iteratorObjekts zugewiesen ist, können die Elemente im Set-Objekt nicht geändert werden. Wenn der Rückgabewert begin einem iteratorzugewiesen ist, können die Elemente im Set-Objekt geändert werden.

Beispiel

// set_begin.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;
   set <int>::iterator s1_Iter;
   set <int>::const_iterator s1_cIter;

   s1.insert( 1 );
   s1.insert( 2 );
   s1.insert( 3 );

   s1_Iter = s1.begin( );
   cout << "The first element of s1 is " << *s1_Iter << endl;

   s1_Iter = s1.begin( );
   s1.erase( s1_Iter );

   // The following 2 lines would err because the iterator is const
   // s1_cIter = s1.begin( );
   // s1.erase( s1_cIter );

   s1_cIter = s1.begin( );
   cout << "The first element of s1 is now " << *s1_cIter << endl;
}

The first element of s1 is 1
The first element of s1 is now 2

`cbegin`

Gibt einen const-Iterator zurück, mit dem das erste Element im Bereich behandelt wird.

const_iterator cbegin() const;

Rückgabewert

Ein bidirektionaler const-Access-Iterator, der auf das erste Element des Bereichs zeigt oder auf die Position direkt hinter dem Ende eines leeren Bereichs (für einen leeren Bereich gilt cbegin() == cend()).

Hinweise

Mit dem Rückgabewert von cbegin, die Elemente im Bereich können nicht geändert werden.

Sie können diese Memberfunktion anstelle der begin()-Memberfunktion verwenden, um sicherzustellen, dass der Rückgabewert const_iterator ist. In der Regel wird sie zusammen mit dem auto Stichwort "Typabzug" verwendet, wie im folgenden Beispiel gezeigt. Im folgenden Beispiel ist Container ein beliebiger änderbarer (Nicht-const-)Container, der begin() und cbegin() unterstützt.

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

`cend`

Gibt einen const-Iterator zurück, der den Speicherort adressiert, der dem letzten Element eines Bereichs unmittelbar nachfolgt.

const_iterator cend() const;

Rückgabewert

Ein bidirektionaler const-Access-Iterator, der auf eine Position unmittelbar nach dem Ende des Bereichs verweist.

Hinweise

cend wird verwendet, um zu testen, ob ein Iterator das Ende seines Bereichs übergeben hat.

Sie können diese Memberfunktion anstelle der end()-Memberfunktion verwenden, um sicherzustellen, dass der Rückgabewert const_iterator ist. In der Regel wird sie zusammen mit dem auto Stichwort "Typabzug" verwendet, wie im folgenden Beispiel gezeigt. Im folgenden Beispiel ist Container ein beliebiger änderbarer (Nicht-const-)Container, der end() und cend() unterstützt.

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

Der zurückgegebene cend Wert sollte nicht abgeleitet werden.

`clear`

Löscht alle Elemente eines Satzes.

void clear();

Beispiel

// set_clear.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;

   s1.insert( 1 );
   s1.insert( 2 );

   cout << "The size of the set is initially " << s1.size( )
        << "." << endl;

   s1.clear( );
   cout << "The size of the set after clearing is "
        << s1.size( ) << "." << endl;
}

The size of the set is initially 2.
The size of the set after clearing is 0.

`const_iterator`

Ein Typ, der einen bidirektionalen Iterator bereitstellt, der ein const-Element im Satz lesen kann.

typedef implementation-defined const_iterator;

Hinweise

Ein Typ const_iterator kann nicht verwendet werden, um den Wert eines Elements zu ändern.

Beispiel

Sehen Sie sich das Beispiel für ein Beispiel an begin , das const_iteratorverwendet wird.

`const_pointer`

Ein Typ, der einen Zeiger auf ein const-Element in einem Satz bereitstellt.

typedef typename allocator_type::const_pointer const_pointer;

Hinweise

Ein Typ const_pointer kann nicht verwendet werden, um den Wert eines Elements zu ändern.

In den meisten Fällen sollte eine const_iterator verwendet werden, um auf die Elemente in einem Const Set-Objekt zuzugreifen.

`const_reference`

Ein Typ, der einen Verweis auf ein const Element bereitstellt, das in einem Satz zum Lesen und Ausführen von const Vorgängen gespeichert ist.

typedef typename allocator_type::const_reference const_reference;

Beispiel

// set_const_ref.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;

   s1.insert( 10 );
   s1.insert( 20 );

   // Declare and initialize a const_reference &Ref1
   // to the 1st element
   const int &Ref1 = *s1.begin( );

   cout << "The first element in the set is "
        << Ref1 << "." << endl;

   // The following line would cause an error because the
   // const_reference can't be used to modify the set
   // Ref1 = Ref1 + 5;
}

The first element in the set is 10.

`const_reverse_iterator`

Ein Typ, der einen bidirektionalen Iterator bereitstellt, mit dem jedes const-Element im Satz gelesen werden kann.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Hinweise

Ein Typ const_reverse_iterator kann den Wert eines Elements nicht ändern und wird verwendet, um den Satz umgekehrt zu durchlaufen.

Beispiel

Ein Beispiel für rend das Deklarieren und Verwenden der const_reverse_iteratorDatei finden Sie im Beispiel.

`contains`

Überprüfen Sie, ob ein Element mit dem angegebenen Schlüssel in der .set

bool contains(const Key& key) const;
template<class K> bool contains(const K& key) const;

Parameter

K
Der Typ des Schlüssels.

key
Der Schlüsselwert des Elements, nach dem gesucht werden soll.

Rückgabewert

true wenn das Element im set; false gefunden wird, andernfalls.

Hinweise

contains() ist neu in C++20. Geben Sie die /std:c++20 Compileroption an, um sie zu verwenden.

template<class K> bool contains(const K& key) const nimmt nur an der Überladungsauflösung teil, wenn key_compare dies transparent ist. Weitere Informationen finden Sie unter heterogene Suche in assoziativen Containern .

Beispiel

// Requires /std:c++20 or /std:c++latest
#include <set>
#include <iostream>

int main()
{
    std::set<int> theSet = {1, 2};

    std::cout << std::boolalpha; // so booleans show as 'true' or 'false'
    std::cout << theSet.contains(2) << '\n';
    std::cout << theSet.contains(3) << '\n';

    return 0;
}

true
false

`count`

Gibt die Anzahl von Elementen in einem Satz zurück, dessen Schlüssel dem von einem Parameter angegebenen Schlüssel entspricht.

size_type count(const Key& key) const;

Parameter

key
Der Schlüssel der Elemente, die aus einem Satz abgeglichen werden.

Rückgabewert

1, wenn der Satz ein Element enthält, dessen Sortierschlüssel mit dem Parameterschlüssel übereinstimmt. 0, wenn der Satz kein Element mit einem übereinstimmenden Schlüssel enthält.

Hinweise

Die Memberfunktion gibt die Anzahl der Elemente im folgenden Bereich zurück:

[ lower_bound(key), upper_bound(key) ).

Beispiel

Im folgenden Beispiel wird die Verwendung der set::count Memberfunktion veranschaulicht.

// set_count.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main()
{
    using namespace std;
    set<int> s1;
    set<int>::size_type i;

    s1.insert(1);
    s1.insert(1);

    // Keys must be unique in set, so duplicates are ignored
    i = s1.count(1);
    cout << "The number of elements in s1 with a sort key of 1 is: "
         << i << "." << endl;

    i = s1.count(2);
    cout << "The number of elements in s1 with a sort key of 2 is: "
         << i << "." << endl;
}

The number of elements in s1 with a sort key of 1 is: 1.
The number of elements in s1 with a sort key of 2 is: 0.

`crbegin`

Gibt einen const-Iterator zurück, der das erste Element in einer umgekehrten Menge adressiert.

const_reverse_iterator crbegin() const;

Rückgabewert

Ein konstanter umgekehrter bidirektionaler Iterator, mit dem das erste Element in einer umgekehrten Menge adressiert wird (bzw. mit dem das ehemals letzte Element in der nicht umgekehrten Menge adressiert wird).

Hinweise

crbegin wird mit einem umgekehrten Satz verwendet, genau wie begin bei einem Satz.

Mit dem Rückgabewert von crbegin, das set-Objekt kann nicht geändert werden.

Beispiel

// set_crbegin.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;
   set <int>::const_reverse_iterator s1_crIter;

   s1.insert( 10 );
   s1.insert( 20 );
   s1.insert( 30 );

   s1_crIter = s1.crbegin( );
   cout << "The first element in the reversed set is "
        << *s1_crIter << "." << endl;
}

The first element in the reversed set is 30.

`crend`

Gibt einen const-Iterator zurück, der den Speicherort adressiert, der dem letzten Element einer umgekehrten Menge nachfolgt.

const_reverse_iterator crend() const;

Rückgabewert

Ein bidirektionaler const_reverse-Iterator, der den Standort anspricht, der dem letzten Element in einer umgekehrten Menge nachfolgt (der Speicherort, der dem ersten Element in der nicht umgekehrten Menge vorangegangen war).

Hinweise

crend wird mit einem umgekehrten Satz verwendet, genau wie end bei einem Satz.

Mit dem Rückgabewert von crend, das set-Objekt kann nicht geändert werden. Der zurückgegebene crend Wert sollte nicht abgeleitet werden.

crend kann verwendet werden, um zu testen, ob das Ende der Menge von einem umgekehrten Iterator erreicht wurde.

Beispiel

// set_crend.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main() {
   using namespace std;
   set <int> s1;
   set <int>::const_reverse_iterator s1_crIter;

   s1.insert( 10 );
   s1.insert( 20 );
   s1.insert( 30 );

   s1_crIter = s1.crend( );
   s1_crIter--;
   cout << "The last element in the reversed set is "
        << *s1_crIter << "." << endl;
}

`difference_type`

Ein Ganzzahltyp mit Vorzeichen, der dazu verwendet werden kann, die Anzahl von Elementen eines Satzes in einem Bereich zwischen Elementen darzustellen, auf die von Iteratoren gezeigt wird.

typedef typename allocator_type::difference_type difference_type;

Hinweise

difference_type ist der Typ, der beim Subtrahieren oder Inkrementieren über Iteratoren des Containers zurückgegeben wird. difference_type wird normalerweise verwendet, um die Anzahl von Elementen im Bereich (first, last) zwischen den Iteratoren first und last darzustellen. Dazu gehört das Element, auf das durch first gezeigt wird und der Bereich von Elementen bis zu (aber nicht einschließlich) dem Element, auf das durch last gezeigt wird.

Obwohl difference_type für alle Iteratoren verfügbar ist, die die Anforderungen eines Eingabe-Iterators erfüllen, die die Klasse bidirektionaler Iteratoren enthält, die von umkehrbaren Containern wie Set unterstützt werden, wird die Subtraktion zwischen Iteratoren nur von Iteratoren mit wahlfreiem Zugriff unterstützt, die von einem Zufallszugriffscontainer wie Vektor bereitgestellt werden.

Beispiel

// set_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <set>
#include <algorithm>

int main( )
{
   using namespace std;

   set <int> s1;
   set <int>::iterator s1_Iter, s1_bIter, s1_eIter;

   s1.insert( 20 );
   s1.insert( 10 );
   s1.insert( 20 );   // won't insert as set elements are unique

   s1_bIter = s1.begin( );
   s1_eIter = s1.end( );

   set <int>::difference_type   df_typ5, df_typ10, df_typ20;

   df_typ5 = count( s1_bIter, s1_eIter, 5 );
   df_typ10 = count( s1_bIter, s1_eIter, 10 );
   df_typ20 = count( s1_bIter, s1_eIter, 20 );

   // the keys, and hence the elements of a set are unique,
   // so there's at most one of a given value
   cout << "The number '5' occurs " << df_typ5
        << " times in set s1.\n";
   cout << "The number '10' occurs " << df_typ10
        << " times in set s1.\n";
   cout << "The number '20' occurs " << df_typ20
        << " times in set s1.\n";

   // count the number of elements in a set
   set <int>::difference_type  df_count = 0;
   s1_Iter = s1.begin( );
   while ( s1_Iter != s1_eIter)
   {
      df_count++;
      s1_Iter++;
   }

   cout << "The number of elements in the set s1 is: "
        << df_count << "." << endl;
}

The number '5' occurs 0 times in set s1.
The number '10' occurs 1 times in set s1.
The number '20' occurs 1 times in set s1.
The number of elements in the set s1 is: 2.

`emplace`

Es wird ein Element eingefügt, das vor Ort konstruiert wird (keine Kopieren- oder Verschiebevorgänge werden ausgeführt).

template <class... Args>
pair<iterator, bool>
emplace(
    Args&&... args);

Parameter

args
Die Argumente, die zum Erstellen eines in den Satz einzufügenden Elements weitergeleitet werden, es sei denn, es ist bereits ein Element enthalten, dessen Wert gleichwertig sortiert wird.

Rückgabewert

Eine pair Bool-Komponente gibt "true" zurück, wenn eine Einfügung vorgenommen wurde, und "false", wenn die Zuordnung bereits ein Element enthielt, dessen Wert einen entsprechenden Wert in der Sortierung aufweist. Die Iteratorkomponente des Rückgabewertpaars gibt die Adresse zurück, an der ein neues Element eingefügt wurde (die boolesche Komponente ist "True"), oder wenn das Element bereits lokalisiert wurde (die boolesche Komponente ist "False").

Hinweise

Durch diese Funktion werden keine Iteratoren oder Verweise ungültig.

Wenn eine Ausnahme ausgelöst wird, wird der Containerstatus während der Emplacement nicht geändert.

Beispiel

// set_emplace.cpp
// compile with: /EHsc
#include <set>
#include <string>
#include <iostream>

using namespace std;

template <typename S> void print(const S& s) {
    cout << s.size() << " elements: ";

    for (const auto& p : s) {
        cout << "(" << p << ") ";
    }

    cout << endl;
}

int main()
{
    set<string> s1;

    auto ret = s1.emplace("ten");

    if (!ret.second){
        cout << "Emplace failed, element with value \"ten\" already exists."
            << endl << "  The existing element is (" << *ret.first << ")"
            << endl;
        cout << "set not modified" << endl;
    }
    else{
        cout << "set modified, now contains ";
        print(s1);
    }
    cout << endl;

    ret = s1.emplace("ten");

    if (!ret.second){
        cout << "Emplace failed, element with value \"ten\" already exists."
            << endl << "  The existing element is (" << *ret.first << ")"
            << endl;
    }
    else{
        cout << "set modified, now contains ";
        print(s1);
    }
    cout << endl;
}

`emplace_hint`

Fügt ein Element mit einem Platzierungshinweis ein, das vor Ort erstellt wird (Es werden keine Kopier- oder Verschiebevorgänge ausgeführt).

template <class... Args>
iterator emplace_hint(
    const_iterator where,
    Args&&... args);

Parameter

args
Die zum Erstellen eines in den Satz einzufügenden Elements weitergeleiteten Argumente, es sei denn, der Satz enthält dieses Element bereits, oder üblicher, es sei denn, ein Element, dessen Wert gleichwertig sortiert wird, ist bereits enthalten.

where
Die Position, an dem mit der Suche nach dem richtigen Einfügepunkt begonnen wird. (Wenn dieser Punkt where direkt vorausgeht, kann die Einfügung in amortisierter konstanter Zeit anstelle von logarithmischer Zeit eintreten.)

Rückgabewert

Ein Iterator zum neu eingefügten Element.

Wenn die Einfügung fehlerhaft war, da das Element bereits vorhanden ist, wird ein Iterator an das vorhandene Element zurückgegeben.

Hinweise

Durch diese Funktion werden keine Iteratoren oder Verweise ungültig.

Wenn eine Ausnahme ausgelöst wird, wird der Containerstatus während der Emplacement nicht geändert.

Beispiel

// set_emplace.cpp
// compile with: /EHsc
#include <set>
#include <string>
#include <iostream>

using namespace std;

template <typename S> void print(const S& s) {
    cout << s.size() << " elements: " << endl;

    for (const auto& p : s) {
        cout << "(" << p <<  ") ";
    }

    cout << endl;
}

int main()
{
    set<string> s1;

    // Emplace some test data
    s1.emplace("Anna");
    s1.emplace("Bob");
    s1.emplace("Carmine");

    cout << "set starting data: ";
    print(s1);
    cout << endl;

    // Emplace with hint
    // s1.end() should be the "next" element after this emplacement
    s1.emplace_hint(s1.end(), "Doug");

    cout << "set modified, now contains ";
    print(s1);
    cout << endl;
}

`empty`

Testet, ob ein Satz leer ist.

bool empty() const;

Rückgabewert

true wenn der Satz leer ist; false wenn der Satz nicht in Denkhaft ist.

Beispiel

// set_empty.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1, s2;
   s1.insert ( 1 );

   if ( s1.empty( ) )
      cout << "The set s1 is empty." << endl;
   else
      cout << "The set s1 is not empty." << endl;

   if ( s2.empty( ) )
      cout << "The set s2 is empty." << endl;
   else
      cout << "The set s2 is not empty." << endl;
}

The set s1 is not empty.
The set s2 is empty.

`end`

Gibt den "past-the-end"-Iterator zurück.

const_iterator end() const;

iterator end();

Rückgabewert

Der "past-the-end"-Iterator. Wenn der Satz leer ist, dann gilt set::end() == set::begin().

Hinweise

end wird verwendet, um zu testen, ob ein Iterator das Ende seines Satzes bestanden hat.

Der zurückgegebene end Wert sollte nicht abgeleitet werden.

Ein Codebeispiel finden Sie unter set::find.

`equal_range`

Gibt ein Iteratorpaar jeweils zum ersten set-Element mit einem Schlüssel zurück, der größer als oder gleich einem bestimmten Schlüssel ist, bzw. zum ersten set-Element mit einem Schlüssel, der größer als der Schlüssel ist.

pair <const_iterator, const_iterator> equal_range (const Key& key) const;

pair <iterator, iterator> equal_range (const Key& key);

Parameter

key
Der Argumentschlüssel, der mit dem Sortierschlüssel eines Elements aus der Menge verglichen wird, die durchsucht wird.

Rückgabewert

Ein Paar Iteratoren, bei denen der erste der lower_bound Schlüssel und der zweite der upper_bound Schlüssel ist.

Sie können auf den ersten Iterator eines von einer Memberfunktion zurückgegebenen Paars pr zugreifen, indem Sie pr. verwenden Sie zum Ableiten der unteren Iterator *( pr. zuerst). Sie können auf den zweiten Iterator eines von einer Memberfunktion zurückgegebenen Paars pr zugreifen, indem Sie pr. zweitens und zum Ableiten der oberen Begrenzungs iterator verwenden Sie *( pr. second).

Beispiel

// set_equal_range.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   typedef set<int, less< int > > IntSet;
   IntSet s1;
   set <int, less< int > > :: const_iterator s1_RcIter;

   s1.insert( 10 );
   s1.insert( 20 );
   s1.insert( 30 );

   pair <IntSet::const_iterator, IntSet::const_iterator> p1, p2;
   p1 = s1.equal_range( 20 );

   cout << "The upper bound of the element with "
        << "a key of 20 in the set s1 is: "
        << *(p1.second) << "." << endl;

   cout << "The lower bound of the element with "
        << "a key of 20 in the set s1 is: "
        << *(p1.first) << "." << endl;

   // Compare the upper_bound called directly
   s1_RcIter = s1.upper_bound( 20 );
   cout << "A direct call of upper_bound( 20 ) gives "
        << *s1_RcIter << "," << endl
        << "matching the 2nd element of the pair"
        << " returned by equal_range( 20 )." << endl;

   p2 = s1.equal_range( 40 );

   // If no match is found for the key,
   // both elements of the pair return end( )
   if ( ( p2.first == s1.end( ) ) && ( p2.second == s1.end( ) ) )
      cout << "The set s1 doesn't have an element "
           << "with a key less than 40." << endl;
   else
      cout << "The element of set s1 with a key >= 40 is: "
           << *(p1.first) << "." << endl;
}

The upper bound of the element with a key of 20 in the set s1 is: 30.
The lower bound of the element with a key of 20 in the set s1 is: 20.
A direct call of upper_bound( 20 ) gives 30,
matching the 2nd element of the pair returned by equal_range( 20 ).
The set s1 doesn't have an element with a key less than 40.

`erase`

Es wird ein Element oder ein Bereich von Elementen in einem Satz von angegebenen Speicherorten entfernt, oder es werden die einem angegebenen Schlüssel entsprechenden Elemente entfernt.

iterator erase(
    const_iterator Where);

iterator erase(
    const_iterator First,
    const_iterator Last);

size_type erase(
    const key_type& Key);

Parameter

Where
Die Position des zu entfernenden Elements.

First
Die Position des ersten zu entfernenden Elements.

Last
Die Position direkt hinter dem letzten zu entfernenden Element.

Key
Der Schlüsselwert der zu entfernenden Elemente.

Rückgabewert

Bei den ersten beiden Memberfunktionen ist es ein bidirektionaler Iterator, der das erste über die entfernten Elemente hinaus verbliebe Element festlegt, oder ein Element, das das Ende des Satzes darstellt, wenn kein solches Element vorhanden ist.

Für die dritte Memberfunktion wird die Anzahl der vom Satz entfernten Elemente zurück gegeben.

Beispiel

// set_erase.cpp
// compile with: /EHsc
#include <set>
#include <string>
#include <iostream>
#include <iterator> // next() and prev() helper functions

using namespace std;

using myset = set<string>;

void printset(const myset& s) {
    for (const auto& iter : s) {
        cout << " [" << iter << "]";
    }
    cout << endl << "size() == " << s.size() << endl << endl;
}

int main()
{
    myset s1;

    // Fill in some data to test with, one at a time
    s1.insert("Bob");
    s1.insert("Robert");
    s1.insert("Bert");
    s1.insert("Rob");
    s1.insert("Bobby");

    cout << "Starting data of set s1 is:" << endl;
    printset(s1);
    // The 1st member function removes an element at a given position
    s1.erase(next(s1.begin()));
    cout << "After the 2nd element is deleted, the set s1 is:" << endl;
    printset(s1);

    // Fill in some data to test with, one at a time, using an initializer list
    myset s2{ "meow", "hiss", "purr", "growl", "yowl" };

    cout << "Starting data of set s2 is:" << endl;
    printset(s2);
    // The 2nd member function removes elements
    // in the range [First, Last)
    s2.erase(next(s2.begin()), prev(s2.end()));
    cout << "After the middle elements are deleted, the set s2 is:" << endl;
    printset(s2);

    myset s3;

    // Fill in some data to test with, one at a time, using emplace
    s3.emplace("C");
    s3.emplace("C#");
    s3.emplace("D");
    s3.emplace("D#");
    s3.emplace("E");
    s3.emplace("E#");
    s3.emplace("F");
    s3.emplace("F#");
    s3.emplace("G");
    s3.emplace("G#");
    s3.emplace("A");
    s3.emplace("A#");
    s3.emplace("B");

    cout << "Starting data of set s3 is:" << endl;
    printset(s3);
    // The 3rd member function removes elements with a given Key
    myset::size_type count = s3.erase("E#");
    // The 3rd member function also returns the number of elements removed
    cout << "The number of elements removed from s3 is: " << count << "." << endl;
    cout << "After the element with a key of \"E#\" is deleted, the set s3 is:" << endl;
    printset(s3);
}

`find`

Gibt einen Iterator zurück, der auf den Speicherort eines Elements in einem Satz verweist, der einen Schlüssel gleich einem angegebenen Schlüssel aufweist.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parameter

key
Der Schlüsselwert, der mit dem Sortierschlüssel eines Elements aus dem zu durchsuchenden Satz übereinstimmt.

Rückgabewert

Ein Iterator, der auf den Speicherort eines Elements mit einem angegebenen Schlüssel verweist, oder der Speicherort, der dem letzten Element im Satz (set::end()) nachfolgt, wenn keine Übereinstimmung für den Schlüssel gefunden wird.

Hinweise

Die Memberfunktion gibt einen Iterator zurück, der auf ein Element in der Gruppe verweist, dessen Schlüssel dem Argumentschlüssel unter einem binären Prädikat entspricht, das eine Sortierung basierend auf einer Vergleichbarkeitsbeziehung auslöst.

Wenn der Rückgabewert find eines const_iteratorObjekts zugewiesen ist, kann das set-Objekt nicht geändert werden. Wenn der Rückgabewert find eines iteratorObjekts zugewiesen ist, kann das Set-Objekt geändert werden.

Beispiel

// compile with: /EHsc /W4 /MTd
#include <set>
#include <iostream>
#include <vector>
#include <string>

using namespace std;

template <typename T> void print_elem(const T& t) {
    cout << "(" << t << ") ";
}

template <typename T> void print_collection(const T& t) {
    cout << t.size() << " elements: ";

    for (const auto& p : t) {
        print_elem(p);
    }
    cout << endl;
}

template <typename C, class T> void findit(const C& c, T val) {
    cout << "Trying find() on value " << val << endl;
    auto result = c.find(val);
    if (result != c.end()) {
        cout << "Element found: "; print_elem(*result); cout << endl;
    } else {
        cout << "Element not found." << endl;
    }
}

int main()
{
    set<int> s1({ 40, 45 });
    cout << "The starting set s1 is: " << endl;
    print_collection(s1);

    vector<int> v;
    v.push_back(43);
    v.push_back(41);
    v.push_back(46);
    v.push_back(42);
    v.push_back(44);
    v.push_back(44); // attempt a duplicate

    cout << "Inserting the following vector data into s1: " << endl;
    print_collection(v);

    s1.insert(v.begin(), v.end());

    cout << "The modified set s1 is: " << endl;
    print_collection(s1);
    cout << endl;
    findit(s1, 45);
    findit(s1, 6);
}

`get_allocator`

Gibt eine Kopie des allocator-Objekts zurück, das zum Erstellen der Menge verwendet wird.

allocator_type get_allocator() const;

Rückgabewert

Die Zuweisung, die von „set“ zur Arbeitsspeicherverwaltung verwendet wird, die der Vorlagenparameter Allocator ist.

Weitere Informationen Allocatorfinden Sie im Abschnitt "Hinweise" des set Themas "Klasse ".

Hinweise

Zuweisungen für Set-Klasse geben an, wie die Klasse einen Speicher verwaltet. Für die meisten Programmieranforderungen reichen die standardmäßigen allocator-Objekte mit Containerklassen der C++-Standardbibliothek aus. Schreiben und Verwenden Ihrer eigener Zuweisungsklasse ist ein C++ -Thema für Fortgeschrittene.

Beispiel

// set_get_allocator.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int>::allocator_type s1_Alloc;
   set <int>::allocator_type s2_Alloc;
   set <double>::allocator_type s3_Alloc;
   set <int>::allocator_type s4_Alloc;

   // The following lines declare objects
   // that use the default allocator.
   set <int> s1;
   set <int, allocator<int> > s2;
   set <double, allocator<double> > s3;

   s1_Alloc = s1.get_allocator( );
   s2_Alloc = s2.get_allocator( );
   s3_Alloc = s3.get_allocator( );

   cout << "The number of integers that can be allocated"
        << endl << "before free memory is exhausted: "
        << s2.max_size( ) << "." << endl;

   cout << "\nThe number of doubles that can be allocated"
        << endl << "before free memory is exhausted: "
        << s3.max_size( ) <<  "." << endl;

   // The following line creates a set s4
   // with the allocator of multiset s1.
   set <int> s4( less<int>( ), s1_Alloc );

   s4_Alloc = s4.get_allocator( );

   // Two allocators are interchangeable if
   // storage allocated from each can be
   // deallocated by the other
   if( s1_Alloc == s4_Alloc )
   {
      cout << "\nThe allocators are interchangeable."
           << endl;
   }
   else
   {
      cout << "\nThe allocators are not interchangeable."
           << endl;
   }
}

insert

Fügt ein Element oder einen Elementbereich in einen Satz ein.

// (1) single element
pair<iterator, bool> insert(
    const value_type& Val);

// (2) single element, perfect forwarded
template <class ValTy>
pair<iterator, bool>
insert(
    ValTy&& Val);

// (3) single element with hint
iterator insert(
    const_iterator Where,
    const value_type& Val);

// (4) single element, perfect forwarded, with hint
template <class ValTy>
iterator insert(
    const_iterator Where,
    ValTy&& Val);

// (5) range
template <class InputIterator>
void insert(
    InputIterator First,
    InputIterator Last);

// (6) initializer list
void insert(
    initializer_list<value_type>
IList);

Parameter

Val
Der Wert eines in den Satz einzufügenden Elements, es sei denn, es ist bereits ein Element enthalten, dessen Wert gleichwertig sortiert wird.

Where
Die Position, an dem mit der Suche nach dem richtigen Einfügepunkt begonnen wird. (Wenn dieser Punkt unmittelbar vorausgeht Dabei kann die Einfügung in amortisierter Konstantenzeit anstelle der logarithmischen Zeit erfolgen.)

ValTy
Vorlagenparameter, der den Argumenttyp angibt, den der Satz zum Erstellen eines Elements von value_typeVal als Argument verwenden kann.

First
Die Position des ersten zu kopierenden Elements.

Last
Die Position direkt über den letzten zu kopierenden Elements.

InputIterator
Vorlagenfunktionsargument, das den Anforderungen eines Eingabe-Iterators entspricht, der auf Elemente eines Typs verweist, die zum Erstellen value_type von Objekten verwendet werden können.

IList
Die initializer_list Elemente, von denen die Elemente kopiert werden sollen.

Rückgabewert

Die Elementfunktionen mit einem Element (1) und (2) geben eine pair Komponente zurück, deren bool Komponente wahr ist, wenn eine Einfügung vorgenommen wurde, und "false", wenn die Menge bereits ein Element mit einem entsprechenden Wert in der Sortierung enthielt. Die Iteratorkomponente des Rückgabewertpaars zeigt auf das neu eingefügten Element, wenn die bool-Komponente "true" lautet, oder auf das vorhandene Element, wenn die bool-Komponente "false" lautet.

Die Einzelelement-Memberfunktionen mit Hinweis (3) und (4) geben einen Iterator zurück, der auf die Position zeigt, an der das neue Element in den Satz eingefügt wurde, oder, falls ein Element mit einem entsprechenden Schlüssel bereits vorhanden ist, auf das vorhandene Element.

Hinweise

Durch diese Funktion werden keine Iteratoren, Zeiger oder Verweise ungültig.

Wenn eine Ausnahme ausgelöst wird, wird der Containerstatus während der Einfügung nur eines Elements nicht geändert. Wird beim Einfügen mehrerer Elementen eine Ausnahme ausgelöst, wird der Container in einem nicht angegebenen doch gültigen Zustand belassen.

Um auf die Iteratorkomponente eines Elements pair pr zuzugreifen, das von den Einzelelementfunktionen zurückgegeben wird, verwenden Sie ; pr.first, um den Iterator innerhalb des zurückgegebenen Paares abzuleiten, verwenden *pr.firstSie ein Element. Um auf die bool-Komponente zuzugreifen, verwenden Sie pr.second. Eine Beispiel finden Sie unter Beispielcode weiter unten in diesem Artikel.

Der value_type Container ist ein Typedef, der zum Container gehört, und für den Satz set<V>::value_type ein Typ const Vist.

Die Bereichsmemmfunktion (5) fügt die Abfolge von Elementwerten in einen Satz ein, der jedem Element entspricht, Last das von einem Iterator im Bereich [First, Last)adressiert wird; daher wird nicht eingefügt. Die Containermemberfunktion end() bezieht sich auf die Position direkt hinter dem letzten Element im Container. Z. B versucht die Anweisung s.insert(v.begin(), v.end()); alle Elemente von v in s einzufügen. Nur Elemente, die eindeutige Werte im Bereich aufweisen werden eingefügt. Duplikate werden ignoriert. Um zu betrachten welche Elemente abgelehnt werden, verwenden Sie die Einzelelementversionen von insert.

Die Initialisierungslistenelementfunktion (6) verwendet zum initializer_list Kopieren von Elementen in die Gruppe.

Informationen zum Einfügen eines direkt erstellten Elements , d. h. es werden keine Kopier- oder Verschiebungsvorgänge ausgeführt – siehe set::emplace und set::emplace_hint.

Beispiel

// set_insert.cpp
// compile with: /EHsc
#include <set>
#include <iostream>
#include <string>
#include <vector>

using namespace std;

template <typename S> void print(const S& s) {
    cout << s.size() << " elements: ";

    for (const auto& p : s) {
        cout << "(" << p << ") ";
    }

    cout << endl;
}

int main()
{
    // insert single values
    set<int> s1;
    // call insert(const value_type&) version
    s1.insert({ 1, 10 });
    // call insert(ValTy&&) version
    s1.insert(20);

    cout << "The original set values of s1 are:" << endl;
    print(s1);

    // intentionally attempt a duplicate, single element
    auto ret = s1.insert(1);
    if (!ret.second){
        auto elem = *ret.first;
        cout << "Insert failed, element with value 1 already exists."
            << endl << "  The existing element is (" << elem << ")"
            << endl;
    }
    else{
        cout << "The modified set values of s1 are:" << endl;
        print(s1);
    }
    cout << endl;

    // single element, with hint
    s1.insert(s1.end(), 30);
    cout << "The modified set values of s1 are:" << endl;
    print(s1);
    cout << endl;

    // The templatized version inserting a jumbled range
    set<int> s2;
    vector<int> v;
    v.push_back(43);
    v.push_back(294);
    v.push_back(41);
    v.push_back(330);
    v.push_back(42);
    v.push_back(45);

    cout << "Inserting the following vector data into s2:" << endl;
    print(v);

    s2.insert(v.begin(), v.end());

    cout << "The modified set values of s2 are:" << endl;
    print(s2);
    cout << endl;

    // The templatized versions move-constructing elements
    set<string>  s3;
    string str1("blue"), str2("green");

    // single element
    s3.insert(move(str1));
    cout << "After the first move insertion, s3 contains:" << endl;
    print(s3);

    // single element with hint
    s3.insert(s3.end(), move(str2));
    cout << "After the second move insertion, s3 contains:" << endl;
    print(s3);
    cout << endl;

    set<int> s4;
    // Insert the elements from an initializer_list
    s4.insert({ 4, 44, 2, 22, 3, 33, 1, 11, 5, 55 });
    cout << "After initializer_list insertion, s4 contains:" << endl;
    print(s4);
    cout << endl;
}

`iterator`

Ein Typ, der einen konstanten bidirektionalen Iterator bereitstellt, mit dem jedes set-Element gelesen oder geändert werden kann.

typedef implementation-defined iterator;

Beispiel

Ein Beispiel für das Deklarieren und Verwenden eines iteratorBeispiels finden Sie im Beispielbegin.

`key_comp`

Ruft eine Kopie des Vergleichsobjekts ab, das zum Sortieren der Schlüssel in einem Satz verwendet wird.

key_compare key_comp() const;

Rückgabewert

Gibt das Funktionsobjekt zurück, das eine Menge verwendet, um ihre Elemente zu sortieren, und das der Vorlagenparameter Traits ist.

Weitere Informationen Traitsfinden Sie im set Thema "Klasse ".

Hinweise

Das gespeicherte Objekt definiert die Memberfunktion

bool operator()(const Key&, const Key&;_yVal_xVal

gibt zurück true , wenn _xVal sie vorangestellt ist und nicht in der Sortierreihenfolge gleich ist _yVal .

Beide key_compare sind value_compare Synonyme für den Vorlagenparameter Traits. Beide Typen werden für die Set- und Multiset-Klassen bereitgestellt, bei denen sie identisch sind, zur Kompatibilität mit den Karten- und Multimap-Klassen, bei denen sie unterschiedlich sind.

Beispiel

// set_key_comp.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;

   set <int, less<int> > s1;
   set<int, less<int> >::key_compare kc1 = s1.key_comp( ) ;
   bool result1 = kc1( 2, 3 ) ;
   if( result1 == true )
   {
      cout << "kc1( 2,3 ) returns value of true, "
           << "where kc1 is the function object of s1."
           << endl;
   }
   else
   {
      cout << "kc1( 2,3 ) returns value of false "
           << "where kc1 is the function object of s1."
           << endl;
   }

   set <int, greater<int> > s2;
   set<int, greater<int> >::key_compare kc2 = s2.key_comp( ) ;
   bool result2 = kc2( 2, 3 ) ;
   if(result2 == true)
   {
      cout << "kc2( 2,3 ) returns value of true, "
           << "where kc2 is the function object of s2."
           << endl;
   }
   else
   {
      cout << "kc2( 2,3 ) returns value of false, "
           << "where kc2 is the function object of s2."
           << endl;
   }
}

kc1( 2,3 ) returns value of true, where kc1 is the function object of s1.
kc2( 2,3 ) returns value of false, where kc2 is the function object of s2.

`key_compare`

Eine Typ, der ein Funktionsobjekt bereitstellt, das zwei Sortierschlüssel vergleichen kann, um die relative Position von zwei Elementen im Satz zu bestimmen.

typedef Traits key_compare;

Hinweise

key_compare ist ein Synonym für den Vorlagenparameter Traits.

Weitere Informationen Traitsfinden Sie im set Thema "Klasse ".

Beispiel

Ein Beispiel für key_comp das Deklarieren und Verwenden key_comparefinden Sie im Beispiel.

`key_type`

Ein Typ, der ein Objekt beschreibt, das als Element eines Set-Objekt in seiner Eigenschaft als Sortierschlüssel gespeichert wird.

typedef Key key_type;

Hinweise

key_type ist ein Synonym für den Vorlagenparameter Key.

Weitere Informationen Keyfinden Sie im Abschnitt "Hinweise" des set Themas "Klasse ".

Beide key_type sind value_type Synonyme für den Vorlagenparameter Key. Beide Typen werden für die Set- und Multiset-Klassen bereitgestellt, bei denen sie identisch sind, zur Kompatibilität mit den Karten- und Multimap-Klassen, bei denen sie unterschiedlich sind.

Beispiel

Ein Beispiel für value_type das Deklarieren und Verwenden key_typefinden Sie im Beispiel.

`lower_bound`

Gibt einen Iterator zum ersten Element in einem Satz mit einem Schlüssel zurück, der gleich oder größer als ein angegebener Schlüssel ist.

const_iterator lower_bound(const Key& key) const;

iterator lower_bound(const Key& key);

Parameter

key
Der Argumentschlüssel, der mit dem Sortierschlüssel eines Elements aus der Menge verglichen wird, die durchsucht wird.

Rückgabewert

Ein Iterator oder const_iterator, der den Speicherort eines set-Elements mit einem Schlüssel adressiert, der gleich oder größer als der Argumentschlüssel ist, oder der den Speicherort des folgenden letzten set-Elements adressiert, wenn kein Treffer für den Schlüssel gefunden wird.

Beispiel

// set_lower_bound.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;
   set <int> :: const_iterator s1_AcIter, s1_RcIter;

   s1.insert( 10 );
   s1.insert( 20 );
   s1.insert( 30 );

   s1_RcIter = s1.lower_bound( 20 );
   cout << "The element of set s1 with a key of 20 is: "
        << *s1_RcIter << "." << endl;

   s1_RcIter = s1.lower_bound( 40 );

   // If no match is found for the key, end( ) is returned
   if ( s1_RcIter == s1.end( ) )
      cout << "The set s1 doesn't have an element "
           << "with a key of 40." << endl;
   else
      cout << "The element of set s1 with a key of 40 is: "
           << *s1_RcIter << "." << endl;

   // The element at a specific location in the set can be found
   // by using a dereferenced iterator that addresses the location
   s1_AcIter = s1.end( );
   s1_AcIter--;
   s1_RcIter = s1.lower_bound( *s1_AcIter );
   cout << "The element of s1 with a key matching "
        << "that of the last element is: "
        << *s1_RcIter << "." << endl;
}

The element of set s1 with a key of 20 is: 20.
The set s1 doesn't have an element with a key of 40.
The element of s1 with a key matching that of the last element is: 30.

`max_size`

Gibt die Maximallänge des Satzes zurück.

size_type max_size() const;

Rückgabewert

Die mögliche Maximallänge der Menge.

Beispiel

// set_max_size.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;
   set <int>::size_type i;

   i = s1.max_size( );
   cout << "The maximum possible length "
        << "of the set is " << i << "." << endl;
}

`operator=`

Ersetzt die Elemente dieses set mithilfe von Elementen eines anderen set.

set& operator=(const set& right);

set& operator=(set&& right);

Parameter

right
Die set, die neue, dieser set zuzuweisende Elemente bereitstellt.

Hinweise

Die erste Version von operator= verwendet einen lvalue-Verweis für right, um Elemente aus right nach set zu kopieren.

Die zweite Version verwendet einen Rvalue-Verweis für rechts. Er verschiebt Elemente aus right nach set.

Alle Elemente in dieser set werden verworfen, bevor die Operatorfunktion ausgeführt wird.

Beispiel

// set_operator_as.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
   {
   using namespace std;
   set<int> v1, v2, v3;
   set<int>::iterator iter;

   v1.insert(10);

   cout << "v1 = " ;
   for (iter = v1.begin(); iter != v1.end(); iter++)
      cout << *iter << " ";
   cout << endl;

   v2 = v1;
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << *iter << " ";
   cout << endl;

// move v1 into v2
   v2.clear();
   v2 = move(v1);
   cout << "v2 = ";
   for (iter = v2.begin(); iter != v2.end(); iter++)
      cout << *iter << " ";
   cout << endl;
   }

`pointer`

Ein Typ, der einen Zeiger auf ein Element in einem Satz bereitstellt.

typedef typename allocator_type::pointer pointer;

Hinweise

Ein Typ pointer kann verwendet werden, um den Wert eines Elements zu ändern.

In den meisten Fällen sollte ein iterator Objekt verwendet werden, um auf die Elemente in einem Set-Objekt zuzugreifen.

`rbegin`

Gibt einen Iterator zurück, der das erste Element in einem umgekehrten Satz adressiert.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Rückgabewert

Ein umgekehrter bidirektionaler Iterator, mit dem das erste Element in einer umgekehrten Menge adressiert wird, bzw. mit dem das ehemals letzte Element in der nicht umgekehrten Menge adressiert wird.

Hinweise

rbegin wird mit einem umgekehrten Satz verwendet, genau wie begin bei einem Satz.

Wenn der Rückgabewert rbegin eines const_reverse_iteratorObjekts zugewiesen ist, kann das set-Objekt nicht geändert werden. Wenn der Rückgabewert von rbegin einem reverse_iteratorzugewiesen wird, kann das Set-Objekt geändert werden.

Mit rbegin kann eine Menge rückwärts durchlaufen werden.

Beispiel

// set_rbegin.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;
   set <int>::iterator s1_Iter;
   set <int>::reverse_iterator s1_rIter;

   s1.insert( 10 );
   s1.insert( 20 );
   s1.insert( 30 );

   s1_rIter = s1.rbegin( );
   cout << "The first element in the reversed set is "
        << *s1_rIter << "." << endl;

   // begin can be used to start an iteration
   // through a set in a forward order
   cout << "The set is:";
   for ( s1_Iter = s1.begin( ) ; s1_Iter != s1.end( ); s1_Iter++ )
      cout << " " << *s1_Iter;
   cout << endl;

   // rbegin can be used to start an iteration
   // through a set in a reverse order
   cout << "The reversed set is:";
   for ( s1_rIter = s1.rbegin( ) ; s1_rIter != s1.rend( ); s1_rIter++ )
      cout << " " << *s1_rIter;
   cout << endl;

   // A set element can be erased by dereferencing to its key
   s1_rIter = s1.rbegin( );
   s1.erase ( *s1_rIter );

   s1_rIter = s1.rbegin( );
   cout << "After the erasure, the first element "
        << "in the reversed set is "<< *s1_rIter << "." << endl;
}

The first element in the reversed set is 30.
The set is: 10 20 30
The reversed set is: 30 20 10
After the erasure, the first element in the reversed set is 20.

`reference`

Ein Typ, der einen Verweis auf ein in einem Satz gespeichertes Element bereitstellt.

typedef typename allocator_type::reference reference;

Beispiel

// set_reference.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;

   s1.insert( 10 );
   s1.insert( 20 );

   // Declare and initialize a reference &Ref1 to the 1st element
   const int &Ref1 = *s1.begin( );

   cout << "The first element in the set is "
        << Ref1 << "." << endl;
}

The first element in the set is 10.

`rend`

Gibt einen Iterator zurück, der den Speicherort adressiert, der dem letzten Element eines umgekehrten Satzes nachfolgt.

const_reverse_iterator rend() const;

reverse_iterator rend();

Rückgabewert

Ein umgekehrter bidirektionaler Iterator, der den Standort anspricht, der dem letzten Element in einer umgekehrten Menge nachfolgt (der Speicherort, der dem ersten Element in der nicht umgekehrten Menge vorangegangen war).

Hinweise

rend wird mit einem umgekehrten Satz verwendet, genau wie end bei einem Satz.

Wenn der Rückgabewert rend eines const_reverse_iteratorObjekts zugewiesen ist, kann das set-Objekt nicht geändert werden. Wenn der Rückgabewert von rend einem reverse_iteratorzugewiesen wird, kann das Set-Objekt geändert werden. Der zurückgegebene rend Wert sollte nicht abgeleitet werden.

rend kann verwendet werden, um zu testen, ob das Ende der Menge von einem umgekehrten Iterator erreicht wurde.

Beispiel

// set_rend.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main() {
   using namespace std;
   set <int> s1;
   set <int>::iterator s1_Iter;
   set <int>::reverse_iterator s1_rIter;
   set <int>::const_reverse_iterator s1_crIter;

   s1.insert( 10 );
   s1.insert( 20 );
   s1.insert( 30 );

   s1_rIter = s1.rend( );
   s1_rIter--;
   cout << "The last element in the reversed set is "
        << *s1_rIter << "." << endl;

   // end can be used to terminate an iteration
   // through a set in a forward order
   cout << "The set is: ";
   for ( s1_Iter = s1.begin( ) ; s1_Iter != s1.end( ); s1_Iter++ )
      cout << *s1_Iter << " ";
   cout << "." << endl;

   // rend can be used to terminate an iteration
   // through a set in a reverse order
   cout << "The reversed set is: ";
   for ( s1_rIter = s1.rbegin( ) ; s1_rIter != s1.rend( ); s1_rIter++ )
      cout << *s1_rIter << " ";
   cout << "." << endl;

   s1_rIter = s1.rend( );
   s1_rIter--;
   s1.erase ( *s1_rIter );

   s1_rIter = s1.rend( );
   --s1_rIter;
   cout << "After the erasure, the last element in the "
        << "reversed set is " << *s1_rIter << "." << endl;
}

`reverse_iterator`

Ein Typ, der einen bidirektionalen Iterator bereitstellt, mit dem ein Element in einem umgekehrten Satz gelesen oder geändert werden kann.

typedef std::reverse_iterator<iterator> reverse_iterator;

Hinweise

Ein Typ reverse_iterator wird verwendet, um den Satz umgekehrt zu durchlaufen.

Beispiel

Ein Beispiel für rbegin das Deklarieren und Verwenden reverse_iteratorfinden Sie im Beispiel.

`set`

Erstellt einen Satz, der leer oder die Kopie eines ganzen anderen Satzes oder eines Teils davon ist.

set();

explicit set(
    const Traits& Comp);

set(
    const Traits& Comp,
    const Allocator& Al);

set(
    const set& Right);

set(
    set&& Right);

set(
    initializer_list<Type> IList);

set(
    initializer_list<Type> IList,
    const Compare& Comp);

set(
    initializer_list<Type> IList,
    const Compare& Comp,
    const Allocator& Al);

template <class InputIterator>
set(
    InputIterator First,
    InputIterator Last);

template <class InputIterator>
set(
    InputIterator First,
    InputIterator Last,
    const Traits& Comp);

template <class InputIterator>
set(
    InputIterator First,
    InputIterator Last,
    const Traits& Comp,
    const Allocator& Al);

Parameter

Al
Die Speicher-Allocator-Klasse, die für dieses Setobjekt verwendet werden soll, das standardmäßig auf Allocator.

Comp
Die Vergleichsfunktion vom Typ const Traits, die verwendet wird, um die Elemente in dem Satz zu sortieren, dessen Standard Compare ist.

Rght
Der Satz, dessen Kopie der erstellte Satz sein soll.

First
Die Position des ersten Elements in dem zu kopierenden Elementbereich.

Last
Die Position des ersten Elements nach dem zu kopierenden Elementbereich.

IList
Das initializer_list-Element, aus dem die Elemente kopiert werden sollen.

Hinweise

Alle Konstruktoren speichern einen Typ von Allocator-Objekt, der den Speicherspeicher für den Satz verwaltet und die später durch Aufrufen get_allocatorzurückgegeben werden kann. Der Zuweisungsparameter wird häufig aus den Klassendeklarationen und den Vorverarbeitungsmakros weggelassen, die zum Ersetzen alternativer Zuweisungen verwendet werden.

Alle Konstruktoren initialisieren die Sätze.

Alle Konstruktoren speichern ein Funktionsobjekt vom Typ Traits , das zum Einrichten einer Reihenfolge zwischen den Schlüsseln des Satzes verwendet wird und die später durch Aufrufen key_compzurückgegeben werden kann.

Die ersten drei Konstruktoren geben einen leeren ursprünglichen Satz an. Dabei gibt der Zweite den Typ der Vergleichsfunktion (comp) an, die zum Angeben der Reihenfolge der Elemente verwendet wird, und der Dritte gibt explizit den zu verwendenden Zuweisungstyp (al) an. Mit dem Schlüsselwort explicit werden bestimmte Arten automatischer Typumwandlung unterdrückt.

Der vierte Konstruktor gibt eine Kopie des right-Satzes an.

Die folgenden drei Konstruktoren verwenden ein initializer_list-Element, um Elemente anzugeben.

Die nächsten drei Konstruktoren kopieren den Bereich [ first, last) eines Satzes mit zunehmender Explizitkeit beim Angeben des Typs der Vergleichsfunktion der Klasse Traits und Allocator.

Der achte Konstruktor gibt eine Kopie des Satzes an, indem right verschoben wird.

Beispiel

// set_set.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main()
{
    using namespace std;

    // Create an empty set s0 of key type integer
    set <int> s0;

    // Create an empty set s1 with the key comparison
    // function of less than, then insert 4 elements
    set <int, less<int> > s1;
    s1.insert(10);
    s1.insert(20);
    s1.insert(30);
    s1.insert(40);

    // Create an empty set s2 with the key comparison
    // function of less than, then insert 2 elements
    set <int, less<int> > s2;
    s2.insert(10);
    s2.insert(20);

    // Create a set s3 with the
    // allocator of set s1
    set <int>::allocator_type s1_Alloc;
    s1_Alloc = s1.get_allocator();
    set <int> s3(less<int>(), s1_Alloc);
    s3.insert(30);

    // Create a copy, set s4, of set s1
    set <int> s4(s1);

    // Create a set s5 by copying the range s1[ first,  last)
    set <int>::const_iterator s1_bcIter, s1_ecIter;
    s1_bcIter = s1.begin();
    s1_ecIter = s1.begin();
    s1_ecIter++;
    s1_ecIter++;
    set <int> s5(s1_bcIter, s1_ecIter);

    // Create a set s6 by copying the range s4[ first,  last)
    // and with the allocator of set s2
    set <int>::allocator_type s2_Alloc;
    s2_Alloc = s2.get_allocator();
    set <int> s6(s4.begin(), ++s4.begin(), less<int>(), s2_Alloc);

    cout << "s1 =";
    for (auto i : s1)
        cout << " " << i;
    cout << endl;

    cout << "s2 = " << *s2.begin() << " " << *++s2.begin() << endl;

    cout << "s3 =";
    for (auto i : s3)
        cout << " " << i;
    cout << endl;

    cout << "s4 =";
    for (auto i : s4)
        cout << " " << i;
    cout << endl;

    cout << "s5 =";
    for (auto i : s5)
        cout << " " << i;
    cout << endl;

    cout << "s6 =";
    for (auto i : s6)
        cout << " " << i;
    cout << endl;

    // Create a set by moving s5
    set<int> s7(move(s5));
    cout << "s7 =";
    for (auto i : s7)
        cout << " " << i;
    cout << endl;

    // Create a set with an initializer_list
    cout << "s8 =";
    set<int> s8{ { 1, 2, 3, 4 } };
    for (auto i : s8)
        cout << " " << i;
    cout << endl;

    cout << "s9 =";
    set<int> s9{ { 5, 6, 7, 8 }, less<int>() };
    for (auto i : s9)
        cout << " " << i;
    cout << endl;

    cout << "s10 =";
    set<int> s10{ { 10, 20, 30, 40 }, less<int>(), s9.get_allocator() };
    for (auto i : s10)
        cout << " " << i;
    cout << endl;
}

s1 = 10 20 30 40s2 = 10 20s3 = 30s4 = 10 20 30 40s5 = 10 20s6 = 10s7 = 10 20s8 = 1 2 3 4s9 = 5 6 7 8s10 = 10 20 30 40

`size`

Gibt die Anzahl der Elemente im Satz zurück.

size_type size() const;

Rückgabewert

Die aktuelle Länge der Menge.

Beispiel

// set_size.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;
   set <int> :: size_type i;

   s1.insert( 1 );
   i = s1.size( );
   cout << "The set length is " << i << "." << endl;

   s1.insert( 2 );
   i = s1.size( );
   cout << "The set length is now " << i << "." << endl;
}

The set length is 1.
The set length is now 2.

`size_type`

Ein Ganzzahltyp ohne Vorzeichen, der die Anzahl von Elementen in einem Satz darstellen kann.

typedef typename allocator_type::size_type size_type;

Beispiel

Ein Beispiel für size das Deklarieren und Verwenden finden Sie im Beispiel size_type

`swap`

Tauscht die Elemente zweier Sätze aus.

void swap(
    set<Key, Traits, Allocator>& right);

Parameter

right
Das set-Argument, das die Elemente bereitstellt, die mit der Zielmenge getauscht werden sollen.

Hinweise

Die Memberfunktion macht keine Verweise, Zeiger oder Iteratoren ungültig, die Elemente in zwei Mengen bezeichnet, deren Elemente ausgetauscht werden.

Beispiel

// set_swap.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1, s2, s3;
   set <int>::iterator s1_Iter;

   s1.insert( 10 );
   s1.insert( 20 );
   s1.insert( 30 );
   s2.insert( 100 );
   s2.insert( 200 );
   s3.insert( 300 );

   cout << "The original set s1 is:";
   for ( s1_Iter = s1.begin( ); s1_Iter != s1.end( ); s1_Iter++ )
      cout << " " << *s1_Iter;
   cout   << "." << endl;

   // This is the member function version of swap
   s1.swap( s2 );

   cout << "After swapping with s2, list s1 is:";
   for ( s1_Iter = s1.begin( ); s1_Iter != s1.end( ); s1_Iter++ )
      cout << " " << *s1_Iter;
   cout  << "." << endl;

   // This is the specialized template version of swap
   swap( s1, s3 );

   cout << "After swapping with s3, list s1 is:";
   for ( s1_Iter = s1.begin( ); s1_Iter != s1.end( ); s1_Iter++ )
      cout << " " << *s1_Iter;
   cout   << "." << endl;
}

The original set s1 is: 10 20 30.
After swapping with s2, list s1 is: 100 200.
After swapping with s3, list s1 is: 300.

`upper_bound`

Gibt einen Iterator zum ersten set-Element mit einem Schlüssel zurück, der größer ist als ein angegebener Schlüssel.

const_iterator upper_bound(const Key& key) const;

iterator upper_bound(const Key& key);

Parameter

key
Der Argumentschlüssel, der mit dem Sortierschlüssel eines Elements aus der Menge verglichen wird, die durchsucht wird.

Rückgabewert

Eine iterator oder const_iterator die die Position eines Elements in einem Satz adressiert, der mit einem Schlüssel größer als dem Argumentschlüssel ist, oder die die Position adressiert, die das letzte Element im Satz erfolgreich ist, wenn keine Übereinstimmung für den Schlüssel gefunden wird.

Beispiel

// set_upper_bound.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;
   set <int> :: const_iterator s1_AcIter, s1_RcIter;

   s1.insert( 10 );
   s1.insert( 20 );
   s1.insert( 30 );

   s1_RcIter = s1.upper_bound( 20 );
   cout << "The first element of set s1 with a key greater "
        << "than 20 is: " << *s1_RcIter << "." << endl;

   s1_RcIter = s1.upper_bound( 30 );

   // If no match is found for the key, end( ) is returned
   if ( s1_RcIter == s1.end( ) )
      cout << "The set s1 doesn't have an element "
           << "with a key greater than 30." << endl;
   else
      cout << "The element of set s1 with a key > 40 is: "
           << *s1_RcIter << "." << endl;

   // The element at a specific location in the set can be found
   // by using a dereferenced iterator addressing the location
   s1_AcIter = s1.begin( );
   s1_RcIter = s1.upper_bound( *s1_AcIter );
   cout << "The first element of s1 with a key greater than"
        << endl << "that of the initial element of s1 is: "
        << *s1_RcIter << "." << endl;
}

The first element of set s1 with a key greater than 20 is: 30.
The set s1 doesn't have an element with a key greater than 30.
The first element of s1 with a key greater than
that of the initial element of s1 is: 20.

`value_comp`

Ruft eine Kopie des Vergleichsobjekts ab, das zum Sortieren der Elementwerte in einem Satz verwendet wird.

value_compare value_comp() const;

Rückgabewert

Gibt das Funktionsobjekt zurück, das eine Menge verwendet, um ihre Elemente zu sortieren, und das der Vorlagenparameter Traits ist.

Weitere Informationen Traitsfinden Sie im set Thema "Klasse ".

Hinweise

Das gespeicherte Objekt definiert die Memberfunktion

bool operator(const Key&, const Key&_xVal_yVal);

gibt zurück true , wenn _xVal sie vorangestellt ist und nicht in der Sortierreihenfolge gleich ist _yVal .

Beide value_compare sind key_compare Synonyme für den Vorlagenparameter Traits. Beide Typen werden für die Set- und Multiset-Klassen bereitgestellt, bei denen sie identisch sind, zur Kompatibilität mit den Karten- und Multimap-Klassen, bei denen sie unterschiedlich sind.

Beispiel

// set_value_comp.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;

   set <int, less<int> > s1;
   set <int, less<int> >::value_compare vc1 = s1.value_comp( );
   bool result1 = vc1( 2, 3 );
   if( result1 == true )
   {
      cout << "vc1( 2,3 ) returns value of true, "
           << "where vc1 is the function object of s1."
           << endl;
   }
   else
   {
      cout << "vc1( 2,3 ) returns value of false, "
           << "where vc1 is the function object of s1."
           << endl;
   }

   set <int, greater<int> > s2;
   set<int, greater<int> >::value_compare vc2 = s2.value_comp( );
   bool result2 = vc2( 2, 3 );
   if( result2 == true )
   {
      cout << "vc2( 2,3 ) returns value of true, "
           << "where vc2 is the function object of s2."
           << endl;
   }
   else
   {
      cout << "vc2( 2,3 ) returns value of false, "
           << "where vc2 is the function object of s2."
           << endl;
   }
}

vc1( 2,3 ) returns value of true, where vc1 is the function object of s1.
vc2( 2,3 ) returns value of false, where vc2 is the function object of s2.

`value_compare`

Der Typ, der ein Funktionsobjekt bereitstellt, das zwei Elemente vergleichen kann, um die relative Position in der Menge zu bestimmen.

typedef key_compare value_compare;

Hinweise

value_compare ist ein Synonym für den Vorlagenparameter Traits.

Weitere Informationen Traitsfinden Sie im set Thema "Klasse ".

Beispiel

Ein Beispiel für value_comp das Deklarieren und Verwenden value_comparefinden Sie im Beispiel.

`value_type`

Ein Typ, der ein Objekt beschreibt, das als Element einer Menge in seiner Eigenschaft als Wert gespeichert wird.

typedef Key value_type;

Hinweise

value_type ist ein Synonym für den Vorlagenparameter Key.

Weitere Informationen Keyfinden Sie im Abschnitt "Hinweise" des set Themas "Klasse ".

Beispiel

// set_value_type.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   set <int> s1;
   set <int>::iterator s1_Iter;

   set <int>::value_type svt_Int;   // Declare value_type
   svt_Int = 10;            // Initialize value_type

   set <int> :: key_type skt_Int;   // Declare key_type
   skt_Int = 20;             // Initialize key_type

   s1.insert( svt_Int );         // Insert value into s1
   s1.insert( skt_Int );         // Insert key into s1

   // A set accepts key_types or value_types as elements
   cout << "The set has elements:";
   for ( s1_Iter = s1.begin( ) ; s1_Iter != s1.end( ); s1_Iter++)
      cout << " " << *s1_Iter;
   cout << "." << endl;
}

The set has elements: 10 20.

Freigeben über

set-Klasse

Syntax

Parameter

Hinweise

Konstruktoren

TypeDefs

Funktionen

Operatoren

allocator_type

Hinweise

Beispiel

begin

Rückgabewert

Hinweise

Beispiel

cbegin

Rückgabewert

Hinweise

cend

Rückgabewert

Hinweise

clear

Beispiel

const_iterator

Hinweise

Beispiel

const_pointer

Hinweise

const_reference

Beispiel

const_reverse_iterator

Hinweise

Beispiel

contains

Parameter

Rückgabewert

Hinweise

Beispiel

count

Parameter

Rückgabewert

Hinweise

Beispiel

crbegin

Rückgabewert

Hinweise

Beispiel

crend

Rückgabewert

Hinweise

Beispiel

difference_type

Hinweise

Beispiel

emplace

Parameter

Rückgabewert

Hinweise

Beispiel

emplace_hint

Parameter

Rückgabewert

Hinweise

Beispiel

empty

Rückgabewert

Beispiel

end

Rückgabewert

Hinweise

equal_range

Parameter

Rückgabewert

Beispiel

erase

Parameter

Rückgabewert

Beispiel

find

`set`-Klasse

`allocator_type`

`begin`

`cbegin`

`cend`

`clear`

`const_iterator`

`const_pointer`

`const_reference`

`const_reverse_iterator`

`contains`

`count`

`crbegin`

`crend`

`difference_type`

`emplace`

`emplace_hint`

`empty`

`end`

`equal_range`

`erase`

`find`

`get_allocator`

`iterator`

`key_comp`

`key_compare`

`key_type`

`lower_bound`

`max_size`

`operator=`

`pointer`

`rbegin`

`reference`

`rend`

`reverse_iterator`

`set`

`size`

`size_type`

`swap`

`upper_bound`

`value_comp`