`set` Klasa

Artykuł
10/12/2023

Klasa set kontenera biblioteki standardowej języka C++ służy do przechowywania i pobierania danych z kolekcji. Wartości elementów w obiekcie set są unikatowe i służą jako wartości klucza, zgodnie z którymi dane są automatycznie uporządkowane. Wartość elementu w elemecie set może nie zostać zmieniona bezpośrednio. Zamiast tego musisz usunąć stare wartości i wstawić elementy z nowymi wartościami.

Składnia

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

Parametry

Key
Typ danych elementu, który ma być przechowywany w zestawie.

Traits
Typ, który dostarcza obiekt funkcji, która może porównać dwie wartości elementów jako klucze sortowania, aby określić ich względną kolejność w zestawie. Ten argument jest opcjonalny, a predykat less <Key> binarny jest wartością domyślną.

W języku C++14 można włączyć heterogeniczne wyszukiwanie, określając std::less<> predykat lub std::greater<> bez parametrów typu. Aby uzyskać więcej informacji, zobacz Heterogeniczne wyszukiwanie w kontenerach asocjacyjnych.

Allocator
Typ reprezentujący przechowywany obiekt alokatora, który hermetyzuje szczegóły dotyczące alokacji zestawu i dezalokacji pamięci. Ten argument jest opcjonalny, a wartość domyślna to allocator<Key>.

Uwagi

Zestaw standardowej biblioteki języka C++ to:

Kontenerem asocjacyjnym, który jest kontenerem o zmiennym rozmiarze, obsługującym efektywne pobieranie wartości elementu w oparciu o wartość skojarzonego klucza. Jest to również prosty kontener asocjacyjny, ponieważ jego wartości elementów są jego wartościami kluczowymi.
Odwracalny, ponieważ zapewnia dwukierunkowy iterator do dostępu do jego elementów.
Posortowany, ponieważ jego elementy są uporządkowane według wartości kluczy w kontenerze zgodnie z określoną funkcją porównywania.
Unikatowy w tym sensie, że każdy z jego elementów musi mieć unikatowy klucz. Ponieważ zestaw jest również prostym kontenerem asocjacyjnym, jego elementy są również unikatowe.

Zestaw jest również opisany jako szablon klasy, ponieważ funkcje, które udostępniają, są ogólne i niezależne od określonego typu danych zawartych jako elementy. Typ danych, który ma być użyty, jest zamiast tego określony jako parametr w klasie szablonu wraz z funkcją porównania i alokatorem.

Wybór typu kontenera powinien ogólnie być oparty o typ wyszukiwania i wstawiania wymagany przez aplikację. Kontenery asocjacyjne są zoptymalizowane dla operacji wyszukiwania, wstawiania i usuwania. Funkcje składowe, które jawnie obsługują te operacje, są wydajne, wykonując je w czasie, który jest średnio proporcjonalny do logarytmu liczby elementów w kontenerze. Wstawianie elementów powoduje unieważnienie żadnych iteratorów i usunięcie elementów unieważnia tylko te iteratory wskazujące na usunięte elementy.

Zestaw powinien być kontenerem asocjacyjnym z wyboru, gdy warunki kojarzenia wartości z kluczami są spełnione przez aplikację. Elementy zestawu są unikatowe i służą jako ich własne klucze sortowania. Model dla tego typu konstrukcji jest uporządkowaną listą, np. wyrazów, w których wyrazy mogą występować tylko raz. Jeżeli zezwolono na wiele wystąpień wyrazów, odpowiednią strukturą kontenera będzie multiset. Gdyby wartości potrzebowały dołączenia do listy unikatowych słów kluczowych, mapa byłaby odpowiednią strukturą zawierającą te dane. Jeśli zamiast tego klucze nie są unikatowe, multimapa będzie wybranym kontenerem.

Zestaw porządkuje sekwencję steruje nią przez wywołanie przechowywanego obiektu funkcji typu key_compare. Ten przechowywany obiekt jest funkcją porównania, która może być dostępna przez wywołanie funkcji key_compskładowej . Ogólnie rzecz biorąc, elementy muszą być jedynie mniej niż porównywalne do ustalenia tego porządku, tak aby, biorąc pod uwagę dwa elementy, można określić, że są one równoważne (w sensie, że ani nie jest mniejszy niż drugi) lub że jeden jest mniejszy niż drugi. Skutkuje to ustaleniem kolejności dla elementów nierównoważnych. Ze strony bardziej technicznej, funkcja porównywania jest predykatem binarnym, który wymusza ścisłe słabe porządkowanie w standardowym sensie matematycznym. Predykat binarny f(x,y) jest obiektem funkcji, który ma dwa obiekty argumentów x i y oraz zwracaną wartość true lub false. Kolejność nałożona na zestaw jest ścisłym słabym uporządkowaniem, jeśli predykat binarny jest nieugięty, antysymetryczny i przechodni, a jeśli równoważność jest przechodnia, gdzie dwa obiekty x i y są definiowane jako równoważne, gdy oba f x,y) i f(y,x) są fałszywe. Jeśli silniejszy warunek równości pomiędzy kluczami zastąpi ten równoważności, to porządkowanie będzie całkowite (w sensie, że wszystkie elementy są uporządkowane względem siebie), a dopasowane klucze będą od siebie nieodróżnialne.

Iterator dostarczany przez klasę zestawu jest iteratorem dwukierunkowym, ale funkcje insert składowe klasy i set mają wersje, które przyjmują jako parametry szablonu słabszy iterator wejściowy, którego wymagania dotyczące funkcjonalności są bardziej minimalne niż te gwarantowane przez klasę iteratorów dwukierunkowych. Pojęcia innych iteratorów formują rodzinę powiązaną przez udoskonalenia w ich funkcjonalnościach. Każde pojęcie iteratora ma swój własny zestaw wymagań, a algorytmy z nimi pracujące muszą ograniczać swoje założenia co do wymagań dostarczonych przez tego typu iterator. Można założyć, że z iteratora danych wejściowych można usunąć odwołanie, aby odwołać się do obiektu, a także, że może on być zwiększony do następnego iteratora w sekwencji. Jest to minimalny zestaw funkcji, ale wystarczy, aby móc mówić znacząco o zakresie iteratorów [ First, Last) w kontekście funkcji składowych klasy.

Konstruktory

Nazwa/nazwisko	opis
`set`	Konstruuje zestaw, który jest pusty lub jest kopią całości lub części innego zestawu.

Typedefs

Nazwa/nazwisko	opis
`allocator_type`	Typ reprezentujący klasę `allocator` dla obiektu zestawu.
`const_iterator`	Typ, który udostępnia iterator dwukierunkowy, który może odczytać `const` element w zestawie.
`const_pointer`	Typ, który dostarcza wskaźnik do `const` elementu w zestawie.
`const_reference`	Typ, który zawiera odwołanie do elementu przechowywanego `const` w zestawie na potrzeby odczytywania i wykonywania `const` operacji.
`const_reverse_iterator`	Typ, który udostępnia iterator dwukierunkowy, który może odczytywać dowolny `const` element w zestawie.
`difference_type`	Typ liczby całkowitej ze znakiem, który może służyć do reprezentowania liczby elementów zestawu w zakresie pomiędzy elementami wskazywanymi przez iteratory.
`iterator`	Typ, który dostarcza iterator dwukierunkowy do odczytu i modyfikacji dowolnego elementu w zestawie.
`key_compare`	Typ, który dostarcza obiekt funkcji, która może porównać dwa klucze sortowania, aby określić względną kolejność dwóch elementów w zestawie.
`key_type`	Typ opisuje obiekt zapisany jako element zestawu w charakterze klucza sortowania.
`pointer`	Typ, który dostarcza wskaźnik do elementu w zestawie.
`reference`	Typ, który zawiera odwołanie do elementu przechowywanego w zestawie.
`reverse_iterator`	Typ, który dostarcza iterator dwukierunkowy do odczytu i modyfikacji elementu w odwróconym zestawie.
`size_type`	Typ całkowitoliczbowy bez znaku, który może reprezentować liczbę elementów w zestawie.
`value_compare`	Typ, który dostarcza obiekt funkcji, która może porównać dwa elementy jako klucze sortowania, aby określić ich względną kolejność w zestawie.
`value_type`	Typ opisuje obiekt zapisany jako element zestawu w charakterze wartości.

Funkcje

Nazwa/nazwisko	opis
`begin`	Zwraca iterator, który adresuje pierwszy element w obiekcie `set`.
`cbegin`	Zwraca iterator const, który adresuje pierwszy element w elemecie `set`.
`cend`	Zwraca iterator const, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w elemecie `set`.
`clear`	Usuwa wszystkie elementy elementu `set`.
`contains`^C++20	Sprawdź, czy w elemecie znajduje się element z określonym kluczem `set`.
`count`	Zwraca liczbę elementów w kluczu `set` , których klucz pasuje do klucza określonego parametrem.
`crbegin`	Zwraca iterator const odnoszący się do pierwszego elementu w odwróconym `set`obiekcie .
`crend`	Zwraca iterator const, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w odwróconym elemecie `set`.
`emplace`	Wstawia element skonstruowany w miejscu do elementu `set`.
`emplace_hint`	Wstawia element skonstruowany w miejscu do `set`elementu z wskazówką umieszczania.
`empty`	Sprawdza, czy element `set` jest pusty.
`end`	Zwraca iterator, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w elemecie `set`.
`equal_range`	Zwraca parę iteratorów odpowiednio do pierwszego elementu w `set` obiekcie z kluczem większym niż określony klucz i do pierwszego elementu w `set` obiekcie z kluczem równym lub większym niż klucz.
`erase`	Usuwa element lub zakres elementów w zestawie z określonych pozycji lub usuwa elementy, które odpowiadają określonemu kluczowi.
`find`	Zwraca iterator odnoszący się do lokalizacji elementu w obiekcie `set` , który ma klucz odpowiadający określonemu kluczowi.
`get_allocator`	Zwraca kopię obiektu używanego `allocator` do konstruowania obiektu `set`.
`insert`	Wstawia element lub zakres elementów do elementu `set`.
`key_comp`	Pobiera kopię obiektu porównania używanego do zamawiania kluczy w obiekcie `set`.
`lower_bound`	Zwraca iterator do pierwszego elementu w zestawie, z kluczem, który jest równy lub większy od określonego klucza.
`max_size`	Zwraca maksymalną długość obiektu `set`.
`rbegin`	Zwraca iterator odnoszący się do pierwszego elementu w odwróconym `set`obiekcie .
`rend`	Zwraca iterator, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w odwróconym elemecie `set`.
`size`	Zwraca liczbę elementów w elem.`set`
`swap`	Wymienia elementy dwóch `set`s.
`upper_bound`	Zwraca iterator do pierwszego elementu w obiekcie `set` z kluczem większym niż określony klucz.
`value_comp`	Pobiera kopię obiektu porównania używanego do porządkowenia wartości elementów w obiekcie `set`.

Operatory

Nazwa/nazwisko	opis
`operator=`	Zastępuje elementy zestawu kopią innego zestawu.

`allocator_type`

Typ reprezentujący klasę alokatora dla obiektu zestawu.

typedef Allocator allocator_type;

Uwagi

allocator_type jest synonimem parametru Allocatorszablonu .

Zwraca obiekt funkcji, który jest używany przez multiset do zamawiania jego elementów, który jest parametrem Allocatorszablonu .

Aby uzyskać więcej informacji na temat Allocator, zobacz sekcję set Uwagi w temacie Klasa .

Przykład

Zobacz przykład, aby get_allocator zapoznać się z przykładem, który używa elementu allocator_type.

`begin`

Zwraca iterator, który dotyczy pierwszego elementu w zestawie.

const_iterator begin() const;

iterator begin();

Wartość zwracana

Iterator dwukierunkowy odnoszący się do pierwszego elementu w zestawie lub lokalizacji, która zakończyła się powodzeniem pustego zestawu.

Uwagi

Jeśli zwracana wartość begin elementu jest przypisana do const_iteratorobiektu , nie można modyfikować elementów w obiekcie zestawu. Jeśli wartość zwracana begin elementu jest przypisana do iteratorobiektu , można zmodyfikować elementy w obiekcie set.

Przykład

// 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`

const Zwraca iterator, który adresuje pierwszy element w zakresie.

const_iterator cbegin() const;

Wartość zwracana

const Iterator dostępu dwukierunkowego, który wskazuje pierwszy element zakresu lub lokalizację tuż poza końcem pustego zakresu (dla pustego zakresu, cbegin() == cend()).

Uwagi

Przy zwracanej wartości cbeginelementu nie można modyfikować elementów w zakresie.

Możesz użyć tej funkcji składowej zamiast funkcji składowej begin() , aby zagwarantować, że zwracana wartość to const_iterator. Zazwyczaj jest używany w połączeniu ze auto słowem kluczowym potrącenia typu, jak pokazano w poniższym przykładzie. W tym przykładzie rozważmy Container , aby być kontenerem modyfikowalnym (innym niż const) jakiegokolwiek rodzaju, który obsługuje begin() i cbegin().

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

// i2 is Container<T>::const_iterator

`cend`

Zwraca iterator, który adresuje lokalizację const tuż poza ostatnim elementem w zakresie.

const_iterator cend() const;

Wartość zwracana

const Iterator dostępu dwukierunkowego, który wskazuje tuż poza końcem zakresu.

Uwagi

cend służy do testowania, czy iterator przeszedł koniec jego zakresu.

Możesz użyć tej funkcji składowej zamiast funkcji składowej end() , aby zagwarantować, że zwracana wartość to const_iterator. Zazwyczaj jest używany w połączeniu ze auto słowem kluczowym potrącenia typu, jak pokazano w poniższym przykładzie. W tym przykładzie rozważmy Container , aby być kontenerem modyfikowalnym (innym niż const) jakiegokolwiek rodzaju, który obsługuje end() i cend().

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

// i2 is Container<T>::const_iterator

Wartość zwracana przez cend nie powinna być wyłuszczone.

`clear`

Usuwa wszystkie elementy zestawu.

void clear();

Przykład

// 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`

Typ, który udostępnia iterator dwukierunkowy, który może odczytać const element w zestawie.

typedef implementation-defined const_iterator;

Uwagi

Nie można użyć typu const_iterator do modyfikowania wartości elementu.

Przykład

Zobacz przykład, aby begin zapoznać się z przykładem, który używa elementu const_iterator.

`const_pointer`

Typ, który dostarcza wskaźnik do const elementu w zestawie.

typedef typename allocator_type::const_pointer const_pointer;

Uwagi

Nie można użyć typu const_pointer do modyfikowania wartości elementu.

W większości przypadków const_iterator element powinien być używany do uzyskiwania dostępu do elementów w obiekcie const set.

`const_reference`

Typ, który zawiera odwołanie do elementu przechowywanego const w zestawie na potrzeby odczytywania i wykonywania const operacji.

typedef typename allocator_type::const_reference const_reference;

Przykład

// 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`

Typ, który udostępnia iterator dwukierunkowy, który może odczytywać dowolny const element w zestawie.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Uwagi

Typ const_reverse_iterator nie może modyfikować wartości elementu i jest używany do iterowania przez zestaw w odwrotnej kolejności.

Przykład

Zobacz przykład, aby zapoznać się z przykładem rend deklarowania i używania elementu const_reverse_iterator.

`contains`

Sprawdź, czy w elemecie znajduje się element z określonym kluczem set.

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

Parametry

K
Typ klucza.

key
Wartość klucza elementu do wyszukania.

Wartość zwracana

true jeśli element znajduje się w elemecie set; false w przeciwnym razie.

Uwagi

contains() jest nowy w języku C++20. Aby go użyć, określ lub nowszą /std:c++20 opcję kompilatora.

template<class K> bool contains(const K& key) const Uczestniczy tylko w rozwiązywaniu przeciążeń, jeśli key_compare jest przezroczysty. Aby uzyskać więcej informacji, zobacz Heterogeniczne wyszukiwanie w kontenerach asocjacyjnych.

Przykład

// 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`

Zwraca liczbę elementów w zestawie, których klucz pasuje do klucza określonego jako parametr.

size_type count(const Key& key) const;

Parametry

key
Klucz elementów do dopasowania z zestawu.

Wartość zwracana

1 jeśli zestaw zawiera element, którego klucz sortowania pasuje do klucza parametru. 0, jeśli zestaw nie zawiera elementu z pasującym kluczem.

Uwagi

Funkcja składowa zwraca liczbę elementów w następującym zakresie:

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

Przykład

W poniższym przykładzie pokazano użycie funkcji składowej set::count .

// 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`

Zwraca iterator const, który dotyczy pierwszego elementu w odwróconym zestawie.

const_reverse_iterator crbegin() const;

Wartość zwracana

Odwrotny iterator dwukierunkowy odnoszący się do pierwszego elementu w odwróconym zestawie lub odnoszący się do tego, co było ostatnim elementem w nierewersowanym zestawie.

Uwagi

crbegin jest używany z zestawem odwróconym, tak jak begin jest używany z zestawem.

Przy zwracanej wartości crbeginelementu nie można zmodyfikować obiektu zestawu.

Przykład

// 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`

Zwraca iterator const, który dotyczy lokalizacji następującej po ostatnim elemencie w odwróconym zestawie.

const_reverse_iterator crend() const;

Wartość zwracana

Odwrotny iterator dwukierunkowy, który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w odwróconym zestawie (lokalizacja, która poprzedzała pierwszy element w niereversed set).

Uwagi

crend jest używany z zestawem odwróconym, tak jak end jest używany z zestawem.

Przy zwracanej wartości crendelementu nie można zmodyfikować obiektu zestawu. Wartość zwracana przez crend nie powinna być wyłuszczone.

crend można użyć do sprawdzenia, czy iterator odwrotny osiągnął koniec zestawu.

Przykład

// 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`

Typ liczby całkowitej ze znakiem, który może służyć do reprezentowania liczby elementów zestawu w zakresie pomiędzy elementami wskazywanymi przez iteratory.

typedef typename allocator_type::difference_type difference_type;

Uwagi

Jest difference_type to typ zwracany podczas odejmowania lub przyrostowania przez iteratory kontenera. Element difference_type jest zwykle używany do reprezentowania liczby elementów w zakresie [pierwszy, ostatni) między iteratorami first i last, zawiera element wskazywany przez first i zakres elementów do, ale nie uwzględnia elementu wskazywanego przez last.

Mimo difference_type że jest dostępna dla wszystkich iteratorów, które spełniają wymagania iteratora wejściowego, który obejmuje klasę iteratorów dwukierunkowych obsługiwanych przez kontenery odwracalne, takie jak zestaw, odejmowanie między iteratorami jest obsługiwane tylko przez iteratory dostępu losowego udostępniane przez kontener dostępu losowego, taki jak wektor.

Przykład

// 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`

Wstawia element skonstruowany na miejscu (nie są wykonywane żadne operacje kopiowania ani przenoszenia).

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

Parametry

args
Argumenty przekazywane do konstruowania elementu, który ma zostać wstawiony do zestawu, chyba że zawiera już element, którego wartość jest równoważnie uporządkowana.

Wartość zwracana

Element pair , którego składnik logiczny zwraca wartość true, jeśli zostało wykonane wstawienie, i false, jeśli mapa zawiera już element, którego wartość miała równoważną wartość w kolejności. Składnik iteratora pary wartości zwraca adres, w którym wstawiono nowy element (jeśli składnik logiczny ma wartość true) lub gdzie element został już zlokalizowany (jeśli składnik logiczny jest fałszywy).

Uwagi

Ta funkcja nie unieważnia iteratorów ani odwołań.

W przypadku zgłoszenia wyjątku stan kontenera nie jest modyfikowany podczas zastępowania.

Przykład

// 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`

Wstawia element skonstruowany na miejscu (nie są wykonywane żadne operacje kopiowania lub przenoszenia) z wskazówką umieszczania.

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

Parametry

args
Argumenty przekazywane do konstruowania elementu, który ma zostać wstawiony do zestawu, chyba że zestaw zawiera już ten element lub, ogólnie rzecz biorąc, chyba że zawiera już element, którego wartość jest równoważnie uporządkowana.

where
Miejsce, w którym należy rozpocząć wyszukiwanie poprawnego punktu wstawiania. (Jeśli ten punkt bezpośrednio poprzedza where, wstawienie może wystąpić w amortyzowanym czasie stałym zamiast czasu logarytmicznych).

Wartość zwracana

Iterator nowo wstawiony element.

Jeśli wstawianie nie powiodło się, ponieważ element już istnieje, zwraca iterator do istniejącego elementu.

Uwagi

Ta funkcja nie unieważnia iteratorów ani odwołań.

W przypadku zgłoszenia wyjątku stan kontenera nie jest modyfikowany podczas zastępowania.

Przykład

// 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`

Sprawdza, czy zestaw jest pusty.

bool empty() const;

Wartość zwracana

true jeśli zestaw jest pusty; false jeśli zestaw nie jest żaden.

Przykład

// 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`

Zwraca iterator poza końcem.

const_iterator end() const;

iterator end();

Wartość zwracana

Iterator przeszłości. Jeśli zestaw jest pusty, to set::end() == set::begin().

Uwagi

end służy do testowania, czy iterator przeszedł koniec zestawu.

Wartość zwracana przez end nie powinna być wyłuszczone.

Aby zapoznać się z przykładem kodu, zobacz set::find.

`equal_range`

Zwraca parę iteratorów odpowiednio do pierwszego elementu w zestawie z kluczem większym lub równym określonemu kluczowi i pierwszemu elementowi w zestawie z kluczem większym niż klucz.

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

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

Parametry

key
Klucz argumentu do porównania z kluczem sortowania elementu z przeszukiwanego zestawu.

Wartość zwracana

Para iteratorów, w których pierwszy jest lower_bound kluczem, a drugi jest upper_bound kluczem.

Aby uzyskać dostęp do pierwszego iteratora pary pr zwróconej przez funkcję składową, użyj polecenia pr. najpierw i aby wyłusić iterator dolnej granicy, użyj *( pr. pierwszy). Aby uzyskać dostęp do drugiego iteratora pary pr zwróconej przez funkcję składową, użyj polecenia pr. drugi i aby wyłuskać iterator górnej granicy, użyj *( pr. sekunda).

Przykład

// 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`

Usuwa element lub zakres elementów w zestawie z określonych pozycji lub usuwa elementy, które odpowiadają określonemu kluczowi.

iterator erase(
    const_iterator Where);

iterator erase(
    const_iterator First,
    const_iterator Last);

size_type erase(
    const key_type& Key);

Parametry

Where
Położenie elementu do usunięcia.

First
Pozycja pierwszego elementu do usunięcia.

Last
Pozycja tuż poza ostatnim elementem, który ma zostać usunięty.

Key
Wartość klucza elementów do usunięcia.

Wartość zwracana

W przypadku pierwszych dwóch funkcji składowych iterator dwukierunkowy, który wyznacza pierwszy element pozostały poza usuniętymi elementami lub elementem, który jest końcem zestawu, jeśli taki element nie istnieje.

W przypadku trzeciej funkcji składowej zwraca liczbę elementów, które zostały usunięte z zestawu.

Przykład

// 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`

Zwraca iterator odwołujący się do lokalizacji elementu w zestawie, który ma klucz odpowiadający określonemu kluczowi.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parametry

key
Wartość klucza, która ma być dopasowywana przez klucz sortowania elementu z przeszukiwanego zestawu.

Wartość zwracana

Iterator odwołujący się do lokalizacji elementu z określonym kluczem lub lokalizacji, która zakończyła się powodzeniem ostatniego elementu w zestawie (set::end()), jeśli nie zostanie znalezione dopasowanie klucza.

Uwagi

Funkcja składowa zwraca iterator, który odwołuje się do elementu w zestawie, którego klucz jest odpowiednikiem klucza argumentu w predykacie binarnym, który wywołuje kolejność na podstawie relacji mniejszej niż porównywalność.

Jeśli wartość zwracana find elementu jest przypisana do const_iteratorobiektu , nie można zmodyfikować obiektu zestawu. Jeśli zwracana wartość find elementu jest przypisana do iteratorobiektu , można zmodyfikować obiekt zestawu

Przykład

// 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`

Zwraca kopię obiektu alokatora używanego do konstruowania zestawu.

allocator_type get_allocator() const;

Wartość zwracana

Alokator używany przez zestaw do zarządzania pamięcią, czyli parametr Allocatorszablonu .

Aby uzyskać więcej informacji na temat Allocator, zobacz sekcję set Uwagi w temacie Klasa .

Uwagi

Alokatory dla klasy zestawu określają sposób zarządzania magazynem przez klasę. Domyślne alokatory dostarczane z klasami kontenerów biblioteki standardowej języka C++ są wystarczające dla większości potrzeb programistycznych. Pisanie i używanie własnej klasy alokatora jest zaawansowanym tematem języka C++.

Przykład

// 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

Wstawia element lub zakres elementów do zestawu.

// (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);

Parametry

Val
Wartość elementu, który ma zostać wstawiony do zestawu, chyba że zawiera już element, którego wartość jest równoważnie uporządkowana.

Where
Miejsce, w którym należy rozpocząć wyszukiwanie poprawnego punktu wstawiania. (Jeśli ten punkt bezpośrednio poprzedza Gdzie, wstawianie może wystąpić w amortyzowanym stałym czasie zamiast czasu logarytmicznych.

ValTy
Parametr szablonu, który określa typ argumentu, którego zestaw może użyć do konstruowania elementu value_type, i perfect-forwards Val jako argumentu.

First
Położenie pierwszego elementu do skopiowania.

Last
Pozycja tuż poza ostatnim elementem do skopiowania.

InputIterator
Argument funkcji szablonu spełniający wymagania iteratora wejściowego wskazujący elementy typu, które mogą służyć do konstruowania value_type obiektów.

IList
Element initializer_list , z którego mają być skopiowane elementy.

Wartość zwracana

Funkcje składowe z jednym elementem, (1) i (2), zwracają pair składnik, którego bool składnik ma wartość true, jeśli wstawienie zostało wykonane, i fałsz, jeśli zestaw zawierał już element równoważnej wartości w kolejności. Składnik iteratora pary return-value wskazuje nowo wstawiony element, jeśli bool składnik ma wartość true, lub do istniejącego elementu, jeśli bool składnik ma wartość false.

Funkcje składowe single-element-with-hint, (3) i (4), zwracają iterator wskazujący położenie, w którym nowy element został wstawiony do zestawu lub, jeśli element z równoważnym kluczem już istnieje, do istniejącego elementu.

Uwagi

Ta funkcja nie unieważnia iteratorów, wskaźników ani odwołań.

Podczas wstawiania tylko jednego elementu, jeśli zgłaszany jest wyjątek, stan kontenera nie jest modyfikowany. Podczas wstawiania wielu elementów, jeśli zostanie zgłoszony wyjątek, kontener pozostanie w nieokreślonym, ale prawidłowym stanie.

Aby uzyskać dostęp do składnika pair pr iteratora zwracanego przez funkcje składowe z jednym elementem, użyj polecenia pr.first; aby wyłusić iterator w zwróconej parze, użyj polecenia *pr.first, dając element. Aby uzyskać dostęp do bool składnika, użyj polecenia pr.second. Przykładowy kod można znaleźć w dalszej części tego artykułu.

Kontener value_type jest typedef, który należy do kontenera, a dla zestawu set<V>::value_type jest typem const V.

Funkcja składowa zakresu (5) wstawia sekwencję wartości elementów do zestawu odpowiadającego każdemu elementowi adresowanemu przez iterator w zakresie [First, Last); w związku z tym Last nie zostanie wstawiona. Funkcja end() składowa kontenera odwołuje się do pozycji tuż po ostatnim elemencie w kontenerze — na przykład instrukcja s.insert(v.begin(), v.end()); próbuje wstawić wszystkie elementy v do selementu . Wstawiane są tylko elementy, które mają unikatowe wartości w zakresie; duplikaty są ignorowane. Aby sprawdzić, które elementy są odrzucane, należy użyć wersji pojedynczego elementu programu insert.

Funkcja składowa listy inicjatora (6) używa elementu initializer_list do kopiowania elementów do zestawu.

W przypadku wstawiania elementu skonstruowanego na miejscu — czyli nie są wykonywane żadne operacje kopiowania lub przenoszenia — zobacz set::emplace i set::emplace_hint.

Przykład

// 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`

Typ, który zapewnia stały iterator dwukierunkowy, który może odczytywać dowolny element w zestawie.

typedef implementation-defined iterator;

Przykład

Zobacz przykład, aby zapoznać się z przykładem begin sposobu deklarowania i używania elementu iterator.

`key_comp`

Pobiera kopię obiektu porównania użytego do uporządkowania kluczy w zestawie.

key_compare key_comp() const;

Wartość zwracana

Zwraca obiekt funkcji używany przez zestaw w celu uporządkowania jego elementów, czyli parametru Traitsszablonu .

Aby uzyskać więcej informacji na temat Traitsprogramu , zobacz set temat Klasa .

Uwagi

Przechowywany obiekt definiuje funkcję składową:

operator bool()(const Key&_xVal, const Key&_yVal);

funkcja zwraca wartość true , jeśli _xVal poprzedza wartość i nie jest równa _yVal w kolejności sortowania.

Oba key_compare parametry i value_compare są synonimami parametru Traitsszablonu . Oba typy są udostępniane dla klas zestawu i wielu zestawów, w których są identyczne, w celu zachowania zgodności z klasami mapy i multimap, gdzie są one odrębne.

Przykład

// 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`

Typ, który dostarcza obiekt funkcji, która może porównać dwa klucze sortowania, aby określić względną kolejność dwóch elementów w zestawie.

typedef Traits key_compare;

Uwagi

key_compare jest synonimem parametru Traitsszablonu .

Aby uzyskać więcej informacji na temat Traitsprogramu , zobacz set temat Klasa .

Przykład

Zobacz przykład, aby zapoznać się z przykładem key_comp sposobu deklarowania i używania elementu key_compare.

`key_type`

Typ, który opisuje obiekt przechowywany jako element zestawu w jego pojemności jako klucz sortowania.

typedef Key key_type;

Uwagi

key_type jest synonimem parametru Keyszablonu .

Aby uzyskać więcej informacji na temat Key, zobacz sekcję set Uwagi w temacie Klasa .

Oba key_type parametry i value_type są synonimami parametru Keyszablonu . Oba typy są udostępniane dla klas zestawu i wielu zestawów, w których są identyczne, w celu zachowania zgodności z klasami mapy i multimap, gdzie są one odrębne.

Przykład

Zobacz przykład, aby zapoznać się z przykładem value_type sposobu deklarowania i używania elementu key_type.

`lower_bound`

Zwraca iterator do pierwszego elementu w zestawie, z kluczem, który jest równy lub większy od określonego klucza.

const_iterator lower_bound(const Key& key) const;

iterator lower_bound(const Key& key);

Parametry

key
Klucz argumentu do porównania z kluczem sortowania elementu z przeszukiwanego zestawu.

Wartość zwracana

Iterator lub const_iterator adresujący lokalizację elementu w zestawie, który ma klucz równy lub większy niż klucz argumentu lub który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w zestawie, jeśli nie zostanie znalezione dopasowanie klucza.

Przykład

// 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`

Zwraca maksymalną długość zestawu.

size_type max_size() const;

Wartość zwracana

Maksymalna możliwa długość zestawu.

Przykład

// 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=`

Zastępuje elementy tego set elementu przy użyciu elementów z innego setelementu .

set& operator=(const set& right);

set& operator=(set&& right);

Parametry

right
Element dostarczający set nowe elementy, które mają zostać przypisane do tego setelementu .

Uwagi

Pierwsza wersja operator= elementu używa odwołania lvalue dla rightelementu , aby skopiować elementy z right elementu do tego setelementu .

Druga wersja używa odwołania rvalue do prawej. Przenosi elementy z right elementu do tego setelementu .

Wszystkie elementy w tym set przed wykonaniem funkcji operatora zostaną odrzucone.

Przykład

// 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`

Typ, który dostarcza wskaźnik do elementu w zestawie.

typedef typename allocator_type::pointer pointer;

Uwagi

pointer Typ może służyć do modyfikowania wartości elementu.

W większości przypadków iterator element powinien być używany do uzyskiwania dostępu do elementów w obiekcie ustawionym.

`rbegin`

Zwraca iterator odnoszący się do pierwszego elementu w odwróconym zestawie.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Wartość zwracana

Iterator dwukierunkowy odwrotny odnoszący się do pierwszego elementu w odwróconym zestawie lub odnoszący się do tego, co było ostatnim elementem w nierewersowanym zestawie.

Uwagi

rbegin jest używany z zestawem odwróconym, tak jak begin jest używany z zestawem.

Jeśli wartość zwracana rbegin elementu jest przypisana do const_reverse_iteratorobiektu , nie można zmodyfikować obiektu zestawu. Jeśli zwracana wartość rbegin elementu jest przypisana do reverse_iteratorobiektu , można zmodyfikować obiekt zestawu.

rbegin można użyć do iterowania przez zestaw do tyłu.

Przykład

// 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`

Typ, który zawiera odwołanie do elementu przechowywanego w zestawie.

typedef typename allocator_type::reference reference;

Przykład

// 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`

Zwraca iterator odnoszący się do lokalizacji następującej po ostatnim elemencie w odwróconym zestawie.

const_reverse_iterator rend() const;

reverse_iterator rend();

Wartość zwracana

Uwagi

rend jest używany z zestawem odwróconym, tak jak end jest używany z zestawem.

Jeśli wartość zwracana rend elementu jest przypisana do const_reverse_iteratorobiektu , nie można zmodyfikować obiektu zestawu. Jeśli zwracana wartość rend elementu jest przypisana do reverse_iteratorobiektu , można zmodyfikować obiekt zestawu. Wartość zwracana przez rend nie powinna być wyłuszczone.

rend można użyć do sprawdzenia, czy iterator odwrotny osiągnął koniec zestawu.

Przykład

// 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`

Typ, który dostarcza iterator dwukierunkowy do odczytu i modyfikacji elementu w odwróconym zestawie.

typedef std::reverse_iterator<iterator> reverse_iterator;

Uwagi

Typ reverse_iterator służy do iterowania zestawu w odwrotnej kolejności.

Przykład

Zobacz przykład, aby zapoznać się z przykładem rbegin sposobu deklarowania i używania elementu reverse_iterator.

`set`

Konstruuje zestaw, który jest pusty lub jest kopią całości lub części innego zestawu.

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);

Parametry

Al
Klasa alokatora magazynu, która ma być używana dla tego obiektu zestawu, który domyślnie ma wartość Allocator.

Comp
Funkcja porównania typu const Traits używana do porządkowenia elementów w zestawie, która jest domyślnie ustawiona na Compare.

Rght
Zestaw, którego skonstruowany zestaw ma być kopią.

First
Położenie pierwszego elementu w zakresie elementów do skopiowania.

Last
Położenie pierwszego elementu poza zakresem elementów do skopiowania.

IList
Lista initializer_list, z której mają być skopiowane elementy.

Uwagi

Wszystkie konstruktory przechowują typ obiektu alokatora, który zarządza magazynem pamięci dla zestawu i który może zostać później zwrócony przez wywołanie metody get_allocator. Parametr alokatora jest często pomijany w deklaracjach klas i makrach przetwarzania wstępnego używanych do zastępowania alternatywnych alokatorów.

Wszystkie konstruktory inicjują zestawy.

Wszystkie konstruktory przechowują obiekt funkcji typu Traits , który jest używany do ustanowienia kolejności między kluczami zestawu i które można później zwrócić przez wywołanie metody key_comp.

Pierwsze trzy konstruktory określają pusty zestaw początkowy, drugi określający typ funkcji porównania (comp) do użycia w ustaleniu kolejności elementów, a trzeci jawnie określając typ alokatora (al). Słowo kluczowe explicit pomija niektóre rodzaje automatycznej konwersji typów.

Czwarty konstruktor określa kopię zestawu right.

Następne trzy konstruktory używają initializer_list do określania elementów.

Następne trzy konstruktory kopiują zakres [ first, last) zestawu z rosnącą jawnością w określaniu typu funkcji porównania klasy Traits i Allocator.

Ósmy konstruktor określa kopię zestawu, przenosząc rightelement .

Przykład

// 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`

Zwraca liczbę elementów w zestawie.

size_type size() const;

Wartość zwracana

Bieżąca długość zestawu.

Przykład

// 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`

Typ całkowitoliczbowy bez znaku, który może reprezentować liczbę elementów w zestawie.

typedef typename allocator_type::size_type size_type;

Przykład

Zobacz przykład, aby size zapoznać się z przykładem sposobu deklarowania i używania size_type

`swap`

Zamienia elementy z dwóch zestawów.

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

Parametry

right
Zestaw argumentów dostarczający elementy do zamiany z zestawem docelowym.

Uwagi

Funkcja składowa unieważnia żadne odwołania, wskaźniki lub iteratory, które wyznaczają elementy w dwóch zestawach, których elementy są wymieniane.

Przykład

// 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`

Zwraca iterator do pierwszego elementu w zestawie z kluczem większym niż określony klucz.

const_iterator upper_bound(const Key& key) const;

iterator upper_bound(const Key& key);

Parametry

key
Klucz argumentu do porównania z kluczem sortowania elementu z przeszukiwanego zestawu.

Wartość zwracana

Obiekt iterator lub const_iterator adresujący lokalizację elementu w zestawie, który ma klucz większy niż klucz argumentu, lub który adresuje lokalizację, która zakończyła się powodzeniem ostatniego elementu w zestawie, jeśli nie zostanie znalezione dopasowanie klucza.

Przykład

// 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`

Pobiera kopię obiektu porównania, użytego do uporządkowania wartości elementów w zestawie.

value_compare value_comp() const;

Wartość zwracana

Zwraca obiekt funkcji używany przez zestaw w celu uporządkowania jego elementów, czyli parametru Traitsszablonu .

Aby uzyskać więcej informacji na temat Traitsprogramu , zobacz set temat Klasa .

Uwagi

Przechowywany obiekt definiuje funkcję składową:

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

funkcja zwraca wartość true , jeśli _xVal poprzedza wartość i nie jest równa _yVal w kolejności sortowania.

Oba value_compare parametry i key_compare są synonimami parametru Traitsszablonu . Oba typy są udostępniane dla klas zestawu i wielu zestawów, w których są identyczne, w celu zachowania zgodności z klasami mapy i multimap, gdzie są one odrębne.

Przykład

// 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`

Typ, który udostępnia obiekt funkcji, który może porównać dwie wartości elementów, aby określić ich względną kolejność w zestawie.

typedef key_compare value_compare;

Uwagi

value_compare jest synonimem parametru Traitsszablonu .

Aby uzyskać więcej informacji na temat Traitsprogramu , zobacz set temat Klasa .

Przykład

Zobacz przykład, aby zapoznać się z przykładem value_comp sposobu deklarowania i używania elementu value_compare.

`value_type`

Typ, który opisuje obiekt przechowywany jako element zestawu w jego pojemności jako wartość.

typedef Key value_type;

Uwagi

value_type jest synonimem parametru Keyszablonu .

Aby uzyskać więcej informacji na temat Key, zobacz sekcję set Uwagi w temacie Klasa .

Przykład

// 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.

Udostępnij za pośrednictwem

set Klasa

Składnia

Parametry

Uwagi

Konstruktory

Typedefs

Funkcje

Operatory

allocator_type

Uwagi

Przykład

begin

Wartość zwracana

Uwagi

Przykład

cbegin

Wartość zwracana

Uwagi

cend

Wartość zwracana

Uwagi

clear

Przykład

const_iterator

Uwagi

Przykład

const_pointer

Uwagi

const_reference

Przykład

const_reverse_iterator

Uwagi

Przykład

contains

Parametry

Wartość zwracana

Uwagi

Przykład

count

Parametry

Wartość zwracana

Uwagi

Przykład

crbegin

Wartość zwracana

Uwagi

Przykład

crend

Wartość zwracana

Uwagi

Przykład

difference_type

Uwagi

Przykład

emplace

Parametry

Wartość zwracana

Uwagi

Przykład

emplace_hint

Parametry

Wartość zwracana

Uwagi

Przykład

empty

Wartość zwracana

Przykład

end

Wartość zwracana

Uwagi

equal_range

Parametry

Wartość zwracana

Przykład

erase

Parametry

Wartość zwracana

Przykład

find

`set` Klasa

`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`