`set` Třída

Článek
10/12/2023

Třída set kontejneru standardní knihovny C++ slouží k ukládání a načítání dat z kolekce. Hodnoty prvků v objektu set jsou jedinečné a slouží jako klíčové hodnoty, podle kterých jsou data automaticky seřazena. Hodnotu prvku v elementu set nelze změnit přímo. Místo toho musíte odstranit staré hodnoty a vložit prvky s novými hodnotami.

Syntaxe

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

Parametry

Key
Typ dat prvku, který bude uložen do sady.

Traits
Typ poskytující objekt funkce, který může porovnat dvě hodnoty prvků pro určení jejich relativního pořadí v sadě. Tento argument je nepovinný a binární predikát less <Key> je výchozí hodnota.

V jazyce C++14 můžete povolit heterogenní vyhledávání zadáním std::less<> nebo std::greater<> predikátu, který neobsahuje parametry typu. Další informace najdete v tématu Heterogenní vyhledávání v asociativních kontejnerech .

Allocator
Typ představující uložený objekt alokátoru, který zapouzdřuje informace o přidělování a navrácení paměti zpět sady. Tento argument je nepovinný a výchozí hodnota je allocator<Key>.

Poznámky

Sada standardní knihovny jazyka C++ je:

Asociativní kontejner, což je kontejner proměnné velikosti, který podporuje efektivní načtení hodnoty prvku založené na přiřazené hodnotě klíče. Je to také jednoduchý asociativní kontejner, protože jeho hodnoty prvků jsou jeho klíčové hodnoty.
Oboustranný, protože poskytuje obousměrný iterátor pro přístup k jeho prvkům.
Seřazený, protože jeho prvky jsou řazeny podle hodnot klíče v kontejneru podle zadané porovnávací funkce.
Jedinečný v tom smyslu, že každý z jeho prvků musí mít jedinečný klíč. Vzhledem k tomu, že je sada také jednoduchý asociativní kontejner, jeho prvky jsou také jedinečné.

Sada je také popsána jako šablona třídy, protože funkce, které poskytuje, jsou obecné a nezávislé na konkrétním typu dat obsažených jako prvky. Datový typ, který má být použit, je místo toho zadán jako parametr v šabloně třídy společně s funkcí porovnání a alokátorem.

Volba typu kontejneru by měla obecně vycházet z typu vyhledávání a vkládání vyžadovaného aplikací. Asociativní kontejnery jsou optimalizovány pro operace vyhledávání, vkládání a odstranění. Členské funkce, které explicitně podporují tyto operace, jsou efektivní a provádějí je v čase, který je v průměru úměrný logaritmus počtu prvků v kontejneru. Vkládání prvků zneplatní žádné iterátory a odebrání prvků zneplatní pouze iterátory, které odkazují na odebrané prvky.

Objekt sady (set) by měl být asociativní kontejner dle výběru, kdy jsou podmínky přiřazení hodnot k jejich klíčům splněny aplikací. Prvky sady jsou jedinečné a slouží jako vlastní klíče řazení. Model pro tento typ struktury je uspořádaný seznam slov, v němž se slova mohou vyskytovat pouze jednou. Pokud bylo povoleno více výskytů jednoho slova, je objekt multiset odpovídající strukturou kontejneru. Pokud hodnoty musí být připojeny k seznamu jedinečných klíčových slov, objekt map by byl vhodnou strukturou, který by měla tato data obsahovat. Pokud místo toho klíče nejsou jedinečné, pak by vícemap byl kontejner, který je volbou.

Sada pořadí, kterou řídí voláním uloženého objektu funkce typu key_compare. Tento uložený objekt je porovnávací funkce, ke které lze získat přístup voláním členské funkce key_comp. Obecně platí, že prvky musí být pouze menší než srovnatelné, aby bylo možné stanovit toto pořadí tak, aby vzhledem k jakýmkoli dvěma prvkům bylo zjištěno, že jsou ekvivalentní (ve smyslu, že ani jeden není menší než druhý), nebo že jeden je menší než druhý. To má za výsledek řazení mezi neekvivalentními prvky. Technicky je funkce porovnání binárním predikátem, který indukuje přísné slabé řazení, standardním matematickým způsobem. Binární predikát f(x;y) je objekt funkce, který má dva argumentové objekty x a y a návratovou true hodnotu nebo false. Řazení stanovené pro množinu je striktní slabé řazení, pokud je binární predikát neflexivní, antisymetrické a přechodné a pokud je ekvivalence tranzitivní, kde jsou dva objekty x a y definovány jako ekvivalentní, pokud jsou oba f x,y) a f(y;x) false. Pokud silnější podmínka rovnosti mezi klíči nahradí ekvivalenci, stane se pořadí celkovým (v tom smyslu, že všechny prvky jsou uspořádány ve vztahu k sobě navzájem) a odpovídající klíče budou od sebe nerozeznatelné.

Iterátor poskytovaný třídou set je obousměrný iterátor, ale členské funkce insert třídy a set mají verze, které berou jako parametry šablony slabší vstupní iterátor, jehož požadavky na funkčnost jsou více minimální než ty, které zaručuje třída obousměrných iterátorů. Různé koncepty iterátorů tvoří rodinu týkající se upřesnění jejich funkčnosti. Každý koncept iterátoru má vlastní sadu požadavků a algoritmy, které s nimi pracují, musí omezit jejich předpoklady na požadavky podle typu iterátoru. Lze předpokládat, že ke vstupnímu iterátoru lze přistoupit přes ukazatel pro odkazování na některý objekt a že může být zvýšen na další iterátor v pořadí. Jedná se o minimální sadu funkcí, ale stačí, abyste mohli smysluplně mluvit o rozsahu iterátorů [ , FirstLast) v kontextu členských funkcí třídy.

Konstruktory

Název	Popis
`set`	Zkonstruuje objekt set, který je prázdný nebo který je kopií celého nebo části některého jiného objektu set.

Typedefs

Název	Popis
`allocator_type`	Typ, který představuje `allocator` třídu pro objekt set.
`const_iterator`	Typ, který poskytuje obousměrný iterátor, který může číst `const` prvek v sadě.
`const_pointer`	Typ, který poskytuje ukazatel na `const` prvek v sadě.
`const_reference`	Typ, který poskytuje odkaz na `const` prvek uložený v sadě pro čtení a provádění `const` operací.
`const_reverse_iterator`	Typ, který poskytuje obousměrný iterátor, který může číst libovolný `const` prvek v sadě.
`difference_type`	Celočíselný typ se znaménkem, který slouží k vyjádření počtu prvků objektu set v rozsahu mezi prvky, na které odkazují iterátory.
`iterator`	Typ, který poskytuje obousměrný iterátor, který může číst nebo upravovat libovolný prvek v objektu set.
`key_compare`	Typ, který poskytuje objekt funkce, který může porovnat dva klíče řazení pro určení relativního pořadí dvou prvků v objektu set.
`key_type`	Typ popisuje objekt uložený jako prvek sady (objekt set) v jeho kapacitě jako klíč řazení.
`pointer`	Typ, který poskytuje ukazatel na prvek v objektu set.
`reference`	Typ, který poskytuje odkaz na prvek uložený v objektu set.
`reverse_iterator`	Typ, který poskytuje obousměrný iterátor, který může číst nebo upravovat prvek v obráceném objektu set.
`size_type`	Celočíselný typ bez znaménka představující počet prvků v objektu set.
`value_compare`	Typ poskytující objekt funkce, který může porovnat dva prvků pro určení jejich relativního pořadí v sadě.
`value_type`	Typ popisuje objekt uložený jako prvek sady (objekt set) v jeho kapacitě jako hodnotu.

Funkce

Název	Popis
`begin`	Vrátí iterátor, který řeší první prvek v objektu `set`.
`cbegin`	Vrátí iterátor const, který řeší první prvek v objektu `set`.
`cend`	Vrátí iterátor const, který řeší umístění úspěšné poslední prvek v objektu `set`.
`clear`	Vymaže všechny prvky .`set`
`contains`^C++20	Zkontrolujte, jestli existuje prvek se zadaným klíčem v objektu `set`.
`count`	Vrátí počet prvků v `set` klíči, jehož klíč odpovídá klíči zadanému parametrem.
`crbegin`	Vrátí konstantní iterátor adresovaný prvním prvkem v obráceném směru `set`.
`crend`	Vrátí const iterátor, který řeší umístění úspěšné poslední prvek v obráceném `set`stavu .
`emplace`	Vloží prvek vytvořený na místě do objektu `set`.
`emplace_hint`	Vloží prvek vytvořený na místě do objektu `set`, s tipem umístění.
`empty`	Testuje, jestli `set` je prázdný.
`end`	Vrátí iterátor, který řeší umístění úspěšné poslední prvek v objektu `set`.
`equal_range`	Vrátí dvojici iterátorů v uvedeném pořadí k prvnímu prvku v `set` klíči, který je větší než zadaný klíč, a k prvnímu prvku v `set` klíči, který je roven nebo větší než klíč.
`erase`	Odebere prvek nebo rozsah prvků v objektu set od zadané pozice nebo odebere prvky, které odpovídají zadanému klíči.
`find`	Vrátí iterátor adresovaný umístění prvku v objektu `set` , který má klíč ekvivalentní zadanému klíči.
`get_allocator`	Vrátí kopii objektu `allocator` použitého k vytvoření objektu `set`.
`insert`	Vloží prvek nebo oblast prvků do objektu `set`.
`key_comp`	Načte kopii objektu porovnání použitého k řazení klíčů v objektu `set`.
`lower_bound`	Vrátí iterátor na první prvek objektu set s klíčem, který je roven nebo větší než zadaný klíč.
`max_size`	Vrátí maximální délku `set`.
`rbegin`	Vrátí iterátor adresovaný prvním prvkem v obráceném směru `set`.
`rend`	Vrátí iterátor, který řeší umístění úspěšné poslední prvek v obráceném stavu `set`.
`size`	Vrátí počet prvků v sadě `set`.
`swap`	Vymění prvky dvou `set`s.
`upper_bound`	Vrátí iterátor na první prvek v klíči `set` , který je větší než zadaný klíč.
`value_comp`	Načte kopii objektu porovnání použitého k seřazení hodnot prvků v objektu `set`.

Operátory

Název	Popis
`operator=`	Nahradí prvky objektu set kopií jiného objektu set.

`allocator_type`

Typ, který představuje třídu alokátoru pro objekt set.

typedef Allocator allocator_type;

Poznámky

allocator_type je synonymem parametru Allocatoršablony .

Vrátí objekt funkce, který víceset používá k seřazení jeho prvků, což je parametr Allocatoršablony .

Další informace naleznete Allocatorv části Poznámky tématu předmětuset.

Příklad

Podívejte se na příklad get_allocator , který používá allocator_type.

`begin`

Vrátí iterátor adresující první prvek v sadě.

const_iterator begin() const;

iterator begin();

Návratová hodnota

Obousměrný iterátor adresující první prvek v sadě nebo umístění úspěšné prázdné sady.

Poznámky

Pokud je vrácená hodnota begin přiřazena k objektu const_iterator, nelze upravit prvky v objektu set. Pokud je vrácená hodnota begin přiřazena k objektu iterator, lze upravit prvky v objektu set.

Příklad

// 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 Vrátí iterátor, který řeší první prvek v oblasti.

const_iterator cbegin() const;

Návratová hodnota

const Obousměrný iterátor s přístupem, který odkazuje na první prvek rozsahu, nebo umístění těsně za koncem prázdné oblasti (pro prázdnou oblast, cbegin() == cend()).

Poznámky

Při návratové cbeginhodnotě nelze upravit prvky v oblasti.

Tuto členská funkce můžete použít místo begin() členské funkce, abyste zajistili, že návratová hodnota je const_iterator. Obvykle se používá ve spojení s klíčovým slovem odpočtu auto typu, jak je znázorněno v následujícím příkladu. V příkladu zvažte Container , že je upravitelný (non- const) kontejner jakéhokoli druhu, který podporuje begin() a cbegin().

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

// i2 is Container<T>::const_iterator

`cend`

const Vrátí iterátor, který řeší umístění za posledním prvkem v rozsahu.

const_iterator cend() const;

Návratová hodnota

const Obousměrný iterátor s přístupem, který odkazuje těsně za koncem rozsahu.

Poznámky

cend slouží k otestování, zda iterátor předal konec jeho rozsahu.

Tuto členská funkce můžete použít místo end() členské funkce, abyste zajistili, že návratová hodnota je const_iterator. Obvykle se používá ve spojení s klíčovým slovem odpočtu auto typu, jak je znázorněno v následujícím příkladu. V příkladu zvažte Container , že je upravitelný (non- const) kontejner jakéhokoli druhu, který podporuje end() a cend().

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

// i2 is Container<T>::const_iterator

Hodnota vrácená cend by neměla být dereferenced.

`clear`

Odstraní všechny prvky objektu set.

void clear();

Příklad

// 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, který poskytuje obousměrný iterátor, který může číst const prvek v sadě.

typedef implementation-defined const_iterator;

Poznámky

Typ const_iterator nelze použít k úpravě hodnoty elementu.

Příklad

Podívejte se na příklad begin , který používá const_iterator.

`const_pointer`

Typ, který poskytuje ukazatel na const prvek v sadě.

typedef typename allocator_type::const_pointer const_pointer;

Poznámky

Typ const_pointer nelze použít k úpravě hodnoty elementu.

Ve většině případů const_iterator by se měl použít pro přístup k prvkům v objektu const set.

`const_reference`

Typ, který poskytuje odkaz na const prvek uložený v sadě pro čtení a provádění const operací.

typedef typename allocator_type::const_reference const_reference;

Příklad

// 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, který poskytuje obousměrný iterátor, který může číst libovolný const prvek v sadě.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Poznámky

Typ const_reverse_iterator nemůže změnit hodnotu elementu a slouží k iteraci v sadě obráceně.

Příklad

Podívejte se na příklad rend , jak deklarovat a používat const_reverse_iterator.

`contains`

Zkontrolujte, jestli existuje prvek se zadaným klíčem v objektu set.

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

Parametry

K
Typ klíče.

key
Hodnota klíče prvku, kterou chcete vyhledat.

Návratová hodnota

true je-li prvek nalezen v objektu set; false jinak.

Poznámky

contains() je nový v jazyce C++20. Pokud ho chcete použít, zadejte možnost kompilátoru /std:c++20 nebo novější.

template<class K> bool contains(const K& key) const Pouze se účastní řešení přetížení, pokud key_compare je transparentní. Další informace najdete v heterogenním vyhledávání v asociativních kontejnerech .

Příklad

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

Vrátí počet prvků objektu set, jejichž klíč odpovídá klíči se zadaným parametrem.

size_type count(const Key& key) const;

Parametry

key
Klíč prvků, které se mají shodovat ze sady.

Návratová hodnota

1, pokud sada obsahuje prvek, jehož klíč řazení odpovídá klíči parametru. 0, pokud sada neobsahuje prvek s odpovídajícím klíčem.

Poznámky

Členová funkce vrátí počet prvků v následujícím rozsahu:

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

Příklad

Následující příklad ukazuje použití set::count členské funkce.

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

Vrátí konstantní iterátor adresující první prvek v obráceném objektu set.

const_reverse_iterator crbegin() const;

Návratová hodnota

Konstantní obousměrný iterátor adresovaný prvním prvkem v obrácené sadě nebo adresování toho, co bylo posledním prvkem v nereverzní sadě.

Poznámky

crbegin se používá s obrácenou sadou stejně, jako begin se používá se sadou.

S návratovou crbeginhodnotou objektu set nelze upravit.

Příklad

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

Vrátí konstantní iterátor adresující umístění následující po posledním prvku v obráceném objektu set.

const_reverse_iterator crend() const;

Návratová hodnota

Const reverse obousměrný iterátor, který řeší umístění úspěšné poslední prvek v obrácené sadě (umístění, které předchází prvnímu prvku v nereverzní sadě).

Poznámky

crend se používá s obrácenou sadou stejně, jako end se používá se sadou.

S návratovou crendhodnotou objektu set nelze upravit. Hodnota vrácená crend by neměla být dereferenced.

crend lze použít k otestování, zda reverzní iterátor dosáhl konce sady.

Příklad

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

Celočíselný typ se znaménkem, který slouží k vyjádření počtu prvků objektu set v rozsahu mezi prvky, na které odkazují iterátory.

typedef typename allocator_type::difference_type difference_type;

Poznámky

Jedná se difference_type o typ vrácený při odečtení nebo zvýšení prostřednictvím iterátorů kontejneru. Obvykle difference_type se používá k reprezentaci počtu prvků v rozsahu [ první, poslední) mezi iterátory first a last, zahrnuje prvek, na který first odkazuje, a rozsah prvků až do, ale nikoli včetně prvku, na který odkazuje last.

Ačkoli difference_type je k dispozici pro všechny iterátory, které splňují požadavky vstupního iterátoru, který zahrnuje třídu obousměrných iterátorů podporovaných reverzibilními kontejnery, jako je sada, odčítání mezi iterátory je podporováno pouze iterátory náhodného přístupu poskytované kontejnerem náhodného přístupu, jako je vektor.

Příklad

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

Vloží vytvořený prvek na místě (neprovádí se žádné operace kopírování ani přesunutí).

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

Parametry

args
Argumenty předané k vytvoření prvku, který má být vložen do sady, pokud již neobsahuje prvek, jehož hodnota je ekvivalentní seřazena.

Návratová hodnota

A pair jehož bool komponenta vrátí hodnotu true, pokud byla vložena, a false, pokud mapa již obsahoval prvek, jehož hodnota měla ekvivalentní hodnotu v pořadí. Součást iterátoru návratové dvojice hodnot vrátí adresu, kde byl vložen nový prvek (pokud je bool komponenta true) nebo kde prvek byl již umístěn (pokud je logická součást false).

Poznámky

Tato funkce zneplatní žádné iterátory ani odkazy.

Pokud při emplacementu dojde k výjimce, stav kontejneru se nezmění.

Příklad

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

Vloží prvek vytvořený na místě (neprovádí se žádné operace kopírování nebo přesunutí) s nápovědou k umístění.

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

Parametry

args
Argumenty předané k vytvoření prvku, který se má vložit do sady, pokud sada již tento prvek neobsahuje, nebo obecněji, pokud již neobsahuje prvek, jehož hodnota je ekvivalentní seřazena.

where
Místo zahájení vyhledání správného bodu vložení. (Pokud tento bod bezprostředně předchází where, může se místo logaritmického času objevit vložení v amortizovaném konstantním čase.)

Návratová hodnota

Iterátor na nově vložený prvek.

Pokud vložení selhalo, protože prvek již existuje, vrátí iterátor existujícímu prvku.

Poznámky

Tato funkce zneplatní žádné iterátory ani odkazy.

Pokud při emplacementu dojde k výjimce, stav kontejneru se nezmění.

Příklad

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

Testuje, zda je objekt set prázdný.

bool empty() const;

Návratová hodnota

true pokud je sada prázdná; false pokud je sada neprázdná.

Příklad

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

Vrátí iterátor za koncem.

const_iterator end() const;

iterator end();

Návratová hodnota

Poslední iterátor. Pokud je sada prázdná, pak set::end() == set::begin().

Poznámky

end slouží k otestování, jestli iterátor předal konec sady.

Hodnota vrácená end by neměla být dereferenced.

Příklad kódu najdete v tématu set::find.

`equal_range`

Vrátí dvojici iterátorů v uvedeném pořadí k prvnímu prvku v sadě s klíčem, který je větší nebo roven zadanému klíči, a k prvnímu prvku v sadě s klíčem, který je větší než klíč.

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

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

Parametry

key
Klíč argumentu, který se má porovnat s klíčem řazení prvku z prohledávané sady.

Návratová hodnota

Dvojice iterátorů, kde první je lower_bound klíč a druhý je upper_bound klíč.

Pokud chcete získat přístup k prvnímu iterátoru dvojice pr vrácené členovou funkcí, použijte pr. nejprve a chcete-li odvodit dolní mez iterátoru, použijte *( pr. první). Pokud chcete získat přístup k druhému iterátoru dvojice pr vrácené členovou funkcí, použijte pr. a chcete-li převést horní mez iterátoru, použijte *( pr. druhý).

Příklad

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

Odebere prvek nebo rozsah prvků v objektu set od zadané pozice nebo odebere prvky, které odpovídají zadanému klíči.

iterator erase(
    const_iterator Where);

iterator erase(
    const_iterator First,
    const_iterator Last);

size_type erase(
    const key_type& Key);

Parametry

Where
Pozice prvku, který má být odebrán.

First
Pozice prvního prvku, který má být odebrán.

Last
Pozice bezprostředně za posledním prvkem, který má být odebrán.

Key
Hodnota klíče prvků, které mají být odebrány.

Návratová hodnota

Pro první dvě členské funkce obousměrný iterátor, který označí první prvek zbývající za jakýmikoli odstraněnými prvky, nebo prvek, který je koncem objektu set, pokud žádný takový prvek neexistuje.

Třetí členská funkce vrátí počet prvků, které byly odebrány z objektu set.

Příklad

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

Vrátí iterátor, který odkazuje na umístění prvku v sadě, která má klíč ekvivalentní zadanému klíči.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parametry

key
Hodnota klíče, která se má shodovat s klíčem řazení prvku z prohledávané sady.

Návratová hodnota

Iterátor, který odkazuje na umístění prvku se zadaným klíčem, nebo umístění úspěšné poslední prvek v sadě (set::end()), pokud se pro klíč nenajde žádná shoda.

Poznámky

Členská funkce vrátí iterátor, který odkazuje na prvek v množině, jehož klíč je ekvivalentní klíči argumentu pod binárním predikátem, který indukuje řazení na základě menší než srovnávací relace.

Pokud je vrácená hodnota find přiřazena k objektu const_iteratorsady, nelze upravit. Pokud je vrácená hodnota find přiřazena k objektu iteratorset, lze upravit objekt set

Příklad

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

Vrátí kopii objektu alokátoru použitého k vytvoření sady.

allocator_type get_allocator() const;

Návratová hodnota

Alokátor používaný sadou ke správě paměti, což je parametr Allocatoršablony .

Další informace naleznete Allocatorv části Poznámky tématu předmětuset.

Poznámky

Alokátory pro třídu set určují, jak třída spravuje úložiště. Výchozí alokátory dodávané s třídami kontejneru standardní knihovny C++ jsou dostatečné pro většinu programovacích potřeb. Psaní a používání vlastní třídy alokátoru je pokročilé téma jazyka C++.

Příklad

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

Vloží prvek nebo rozsah prvků do objektu set.

// (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
Hodnota prvku, který má být vložen do sady, pokud již neobsahuje prvek, jehož hodnota je ekvivalentní seřazena.

Where
Místo zahájení vyhledání správného bodu vložení. (Pokud tento bod bezprostředně předchází Kde může místo logaritmického času dojít k vložení v amortizovaném konstantním čase.)

ValTy
Parametr šablony, který určuje typ argumentu, který sada může použít k vytvoření elementu value_type, a perfect-forwards Val jako argument.

First
Pozice prvního prvku, který chcete zkopírovat.

Last
Pozice bezprostředně za posledním prvkem, který chcete zkopírovat.

InputIterator
Argument funkce šablony, který splňuje požadavky vstupního iterátoru , který odkazuje na prvky typu, které lze použít k vytvoření value_type objektů.

IList
Ze initializer_list kterého chcete prvky zkopírovat.

Návratová hodnota

Členské funkce s jedním prvkem (1) a (2), vrátí pair hodnotu, jejíž bool komponenta je pravdivá, pokud byla vložena, a false, pokud sada již obsahovala prvek ekvivalentní hodnoty v pořadí. Komponenta iterátoru dvojice návratových hodnot odkazuje na nově vložený prvek, pokud bool je komponenta pravdivá, nebo na existující prvek, pokud je komponenta bool nepravda.

Členské funkce s jedním prvkem s nápovědou (3) a (4) vrátí iterátor, který odkazuje na pozici, kde byl nový prvek vložen do sady, nebo pokud prvek s ekvivalentním klíčem již existuje, existující prvek.

Poznámky

Touto funkcí nejsou zneplatněny žádné iterátory, ukazatele ani odkazy.

Během vkládání pouze jednoho prvku, pokud je vyvolán výjimka, stav kontejneru se nezmění. Pokud je při vkládání více prvků vyvolána výjimka, kontejner zůstane v neurčeném, ale platném stavu.

Pokud chcete získat přístup ke komponentě iterátoru pair pr vrácené členské funkce s jedním prvkem, použijte pr.first; pro dereference iterátoru ve vrácené dvojici použijte *pr.first, a to tím, že vám poskytne prvek. Pro přístup ke komponentě bool použijte pr.second. Příklad naleznete v ukázce kódu dále v tomto článku.

Kontejner value_type je typedef, který patří do kontejneru, a pro sadu set<V>::value_type je typ const V.

Členová funkce oblasti (5) vloží sekvenci hodnot prvků do sady, která odpovídá jednotlivým prvkům adresovaných iterátorem v oblasti [First, Last), a proto Last se nevloží. Členská funkce kontejneru end() se vztahuje k pozici hned za posledním prvkem v kontejneru, například příkaz s.insert(v.begin(), v.end()); se pokusí vložit všechny prvky v do s. Vkládají se pouze prvky, které v rozsahu obsahují jedinečné hodnoty. Duplicitní hodnoty jsou ignorovány. Chcete-li sledovat, které prvky jsou odmítnuty, použijte jednoprvkovou verzi funkce insert.

Členová funkce seznamu inicializátoru (6) používá initializer_list ke kopírování prvků do sady.

Vložení prvku vytvořeného na místě – to znamená, že se neprovádí žádné operace kopírování nebo přesunutí – viz set::emplace a set::emplace_hint.

Příklad

// 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, který poskytuje konstantní obousměrný iterátor , který může číst libovolný prvek v sadě.

typedef implementation-defined iterator;

Příklad

Podívejte se na příkladbegin, jak deklarovat a používat .iterator

`key_comp`

Načte kopii objektu porovnání, která je použita pro seřazení klíčů v objektu set.

key_compare key_comp() const;

Návratová hodnota

Vrátí objekt funkce, který sada používá k seřazení jeho prvků, což je parametr Traitsšablony .

Další informace naleznete Traitsv set tématu Třída .

Poznámky

Uložený objekt definuje členovu funkci:

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

vrátí true , pokud _xVal předchází a není rovno _yVal v pořadí řazení.

Oba key_compare a value_compare jsou synonymy pro parametr Traitsšablony . Oba typy jsou k dispozici pro třídy množiny a více sad, kde jsou identické, kvůli kompatibilitě s mapou a vícemapovými třídami, kde jsou odlišné.

Příklad

// 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, který poskytuje objekt funkce, který může porovnat dva klíče řazení pro určení relativního pořadí dvou prvků v objektu set.

typedef Traits key_compare;

Poznámky

key_compare je synonymem parametru Traitsšablony .

Další informace naleznete Traitsv set tématu Třída .

Příklad

Podívejte se na příklad key_comp , jak deklarovat a používat key_compare.

`key_type`

Typ, který popisuje objekt uložený jako prvek sady ve své kapacitě jako klíč řazení.

typedef Key key_type;

Poznámky

key_type je synonymem parametru Keyšablony .

Další informace naleznete Keyv části Poznámky tématu předmětuset.

Oba key_type a value_type jsou synonymy pro parametr Keyšablony . Oba typy jsou k dispozici pro třídy množiny a více sad, kde jsou identické, kvůli kompatibilitě s mapou a vícemapovými třídami, kde jsou odlišné.

Příklad

Podívejte se na příklad value_type , jak deklarovat a používat key_type.

`lower_bound`

Vrátí iterátor na první prvek objektu set s klíčem, který je roven nebo větší než zadaný klíč.

const_iterator lower_bound(const Key& key) const;

iterator lower_bound(const Key& key);

Parametry

key
Klíč argumentu, který se má porovnat s klíčem řazení prvku z prohledávané sady.

Návratová hodnota

Iterátor nebo const_iterator adresující umístění prvku v sadě, která má klíč, který je roven nebo větší než klíč argumentu nebo který řeší umístění úspěšné poslední prvek v sadě, pokud se pro klíč nenajde žádná shoda.

Příklad

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

Vrátí maximální délku objektu set.

size_type max_size() const;

Návratová hodnota

Maximální možná délka sady.

Příklad

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

Nahradí prvky tohoto set použití elementy z jiného set.

set& operator=(const set& right);

set& operator=(set&& right);

Parametry

right
Poskytování set nových prvků, které mají být přiřazeny k tomuto set.

Poznámky

První verze operator= používá lvalue odkaz pro right, kopírovat elementy z right tohoto set.

Druhá verze používá odkaz rvalue pro právo. Přesouvá prvky z right tohoto objektu set.

Všechny prvky v tomto set případě před spuštěním funkce operátoru budou zahozeny.

Příklad

// 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, který poskytuje ukazatel na prvek v objektu set.

typedef typename allocator_type::pointer pointer;

Poznámky

Typ pointer lze použít k úpravě hodnoty elementu.

Ve většině případů iterator by se měl použít pro přístup k prvkům v objektu set.

`rbegin`

Vrátí iterátor adresující první prvek v obráceném objektu set.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Návratová hodnota

Reverzní obousměrný iterátor adresovaný prvním prvkem v obrácené sadě nebo adresování toho, co bylo posledním prvkem v nereverzní sadě.

Poznámky

rbegin se používá s obrácenou sadou stejně, jako begin se používá se sadou.

Pokud je vrácená hodnota rbegin přiřazena k objektu const_reverse_iteratorsady, nelze upravit. Pokud je vrácená hodnota rbegin přiřazena k objektu reverse_iterator, lze upravit objekt set.

rbegin lze použít k iteraci v sadě zpět.

Příklad

// 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, který poskytuje odkaz na prvek uložený v objektu set.

typedef typename allocator_type::reference reference;

Příklad

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

Vrátí iterátor adresující umístění následující po posledním prvku v obráceném objektu set.

const_reverse_iterator rend() const;

reverse_iterator rend();

Návratová hodnota

Reverzní obousměrný iterátor, který řeší umístění úspěšné poslední prvek v obrácené sadě (umístění, které předchází prvnímu prvku v nereverzní sadě).

Poznámky

rend se používá s obrácenou sadou stejně, jako end se používá se sadou.

Pokud je vrácená hodnota rend přiřazena k objektu const_reverse_iteratorsady, nelze upravit. Pokud je vrácená hodnota rend přiřazena k objektu reverse_iterator, lze upravit objekt set. Hodnota vrácená rend by neměla být dereferenced.

rend lze použít k otestování, zda reverzní iterátor dosáhl konce sady.

Příklad

// 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, který poskytuje obousměrný iterátor, který může číst nebo upravovat prvek v obráceném objektu set.

typedef std::reverse_iterator<iterator> reverse_iterator;

Poznámky

Typ reverse_iterator se používá k iteraci sadou v obráceném směru.

Příklad

Podívejte se na příklad rbegin , jak deklarovat a používat reverse_iterator.

`set`

Zkonstruuje objekt set, který je prázdný nebo který je kopií celého nebo části některého jiného objektu set.

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
Třída alokátoru úložiště, která se má použít pro tento objekt set, který má výchozí hodnotu Allocator.

Comp
Funkce porovnání typu const Traits , která slouží k seřazení prvků v sadě, což je výchozí hodnota Compare.

Rght
Sada, ze které má být konstruovaná sada kopií.

First
Pozice prvního prvku v oblasti prvků, které se mají zkopírovat.

Last
Pozice prvního prvku nad rozsah prvků, které se mají zkopírovat.

IList
Seznam initializer_list, ze kterého chcete kopírovat prvky.

Poznámky

Všechny konstruktory ukládají typ objektu alokátoru, který spravuje úložiště paměti pro sadu a které lze později vrátit voláním get_allocator. Parametr allocator je často v deklaraci třídy vynechán a makra předběžného zpracování jsou použita k nahrazení alternativních alokátorů.

Všechny konstruktory inicializují své sady.

Všechny konstruktory ukládají objekt funkce typu Traits , který se používá k vytvoření pořadí mezi klíči sady a které lze později vrátit voláním key_comp.

První tři konstruktory určují prázdnou počáteční sadu, druhou určující typ porovnávací funkce (comp), která se má použít při stanovení pořadí prvků a třetí explicitně specifikující typ alokátoru (al), který se má použít. Klíčové slovo explicit potlačí určité druhy automatického převodu typů.

Čtvrtý konstruktor určuje kopii sady right.

Další tři konstruktory používají initializer_list k určení prvků.

Další tři konstruktory zkopírují rozsah [ first, last) množiny s rostoucí explicitností při určení typu porovnávací funkce třídy Traits a Allocator.

Osmý konstruktor určuje kopii sady přesunutím right.

Příklad

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

Vrátí počet prvků v objektu set.

size_type size() const;

Návratová hodnota

Aktuální délka sady.

Příklad

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

Celočíselný typ bez znaménka představující počet prvků v objektu set.

typedef typename allocator_type::size_type size_type;

Příklad

Příklad deklarování a použití najdete v příkladu size postupu deklarace a použití. size_type

`swap`

Vymění prvky dvou sad.

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

Parametry

right
Sada argumentů poskytující prvky, které se mají prohodit s cílovou sadou.

Poznámky

Členová funkce zneplatňuje žádné odkazy, ukazatele nebo iterátory, které označují prvky ve dvou sadách, jejichž prvky se vyměňují.

Příklad

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

Vrátí iterátor na první prvek v sadě, který s klíčem, který je větší než zadaný klíč.

const_iterator upper_bound(const Key& key) const;

iterator upper_bound(const Key& key);

Parametry

key
Klíč argumentu, který se má porovnat s klíčem řazení prvku z prohledávané sady.

Návratová hodnota

const_iterator Nebo iterator adresující umístění prvku v sadě, který má klíč větší než klíč argumentu, nebo který řeší umístění úspěšného posledního prvku v sadě, pokud se pro klíč nenajde žádná shoda.

Příklad

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

Získá kopii objektu porovnání použitého pro seřazení hodnot prvků objektu set.

value_compare value_comp() const;

Návratová hodnota

Vrátí objekt funkce, který sada používá k seřazení jeho prvků, což je parametr Traitsšablony .

Další informace naleznete Traitsv set tématu Třída .

Poznámky

Uložený objekt definuje členovu funkci:

bool – operátor(const Key&_xVal; const Key&_yVal;

vrátí true , pokud _xVal předchází a není rovno _yVal v pořadí řazení.

Oba value_compare a key_compare jsou synonymy pro parametr Traitsšablony . Oba typy jsou k dispozici pro třídy množiny a více sad, kde jsou identické, kvůli kompatibilitě s mapou a vícemapovými třídami, kde jsou odlišné.

Příklad

// 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, který poskytuje objekt funkce, který může porovnat dvě hodnoty prvků k určení jejich relativního pořadí v sadě.

typedef key_compare value_compare;

Poznámky

value_compare je synonymem parametru Traitsšablony .

Další informace naleznete Traitsv set tématu Třída .

Příklad

Podívejte se na příklad value_comp , jak deklarovat a používat value_compare.

`value_type`

Typ, který popisuje objekt uložený jako prvek sady ve své kapacitě jako hodnotu.

typedef Key value_type;

Poznámky

value_type je synonymem parametru Keyšablony .

Další informace naleznete Keyv části Poznámky tématu předmětuset.

Příklad

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

Sdílet prostřednictvím

set Třída

Syntaxe

Parametry

Poznámky

Konstruktory

Typedefs

Funkce

Operátory

allocator_type

Poznámky

Příklad

begin

Návratová hodnota

Poznámky

Příklad

cbegin

Návratová hodnota

Poznámky

cend

Návratová hodnota

Poznámky

clear

Příklad

const_iterator

Poznámky

Příklad

const_pointer

Poznámky

const_reference

Příklad

const_reverse_iterator

Poznámky

Příklad

contains

Parametry

Návratová hodnota

Poznámky

Příklad

count

Parametry

Návratová hodnota

Poznámky

Příklad

crbegin

Návratová hodnota

Poznámky

Příklad

crend

Návratová hodnota

Poznámky

Příklad

difference_type

Poznámky

Příklad

emplace

Parametry

Návratová hodnota

Poznámky

Příklad

emplace_hint

Parametry

Návratová hodnota

Poznámky

Příklad

empty

Návratová hodnota

Příklad

end

Návratová hodnota

Poznámky

equal_range

Parametry

Návratová hodnota

Příklad

erase

Parametry

Návratová hodnota

Příklad

find

`set` Třída

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