`multiset` Třída

Článek
10/12/2023

Multisetová třída standardní knihovny C++ slouží k ukládání a načítání dat z kolekce, ve které nemusí být hodnoty prvků jedinečné a ve kterých slouží jako klíčové hodnoty, podle kterých jsou data automaticky seřazena. Hodnota klíče prvku v multiset prvku nemusí být změněna přímo. Místo toho musíte odstranit staré hodnoty a vložit prvky s novými hodnotami.

Syntaxe

template <class Key, class Compare =less <Key>, class Allocator =allocator <Key>>
class multiset

Parametry

Key
Datový typ prvku, který má být uložen v souboru multiset.

Compare
Typ, který poskytuje objekt funkce, který může porovnat dvě hodnoty prvků jako klíče řazení určit jejich relativní pořadí v multiset. 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, který představuje uložený objekt alokátoru, který zapouzdřuje podrobnosti o multisetpřidělení a uvolnění paměti. Výchozí hodnota je allocator<Key>.

Poznámky

Třída standardní knihovny multiset 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.
Oboustranný, protože poskytuje obousměrné iterátory 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.
Násobek v tom smyslu, že jeho prvky nemusí mít jedinečné klíče, takže jedna hodnota klíče může mít mnoho hodnot prvků přidružených k němu.
Jednoduchý asociativní kontejner, protože jeho hodnoty prvku jsou jeho hodnoty klíče.
Šablona třídy, protože funkce, které poskytuje, je obecná a tak 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.

Iterátor poskytovaný multiset třídou je obousměrný iterátor, ale členské funkce insert třídy a multiset 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.

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. Vložení prvků zneplatní žádné iterátory a odebrání prvků zneplatní pouze iterátory, které ukazovaly na odebrané prvky.

Tento multiset kontejner by měl být asociativním kontejnerem podle výběru, pokud aplikace splňuje podmínky asociující hodnoty s jejich klíči. Prvky můžou multiset být více a slouží jako vlastní klíče řazení, takže klíče nejsou jedinečné. Model pro tento typ struktury je uspořádaný seznam slov, v němž se slova mohou vyskytovat více než jednou. Pokud by nebylo povoleno více výskytů jednoho slova, byl by objekt set odpovídající strukturou kontejneru. Pokud byly k seznamu jedinečných klíčových slov připojeny jedinečné definice jako hodnoty, objekt map by byl vhodnou strukturou, který by měla tato data obsahovat. Pokud by definice nebyly jedinečné, pak multimap by byl kontejner podle výběru.

Pořadí multiset , které řídí voláním uloženého objektu funkce typu 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é pro stanovení tohoto pořadí: takže vzhledem ke všem dvěma prvkům může být 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 tranzitivní a pokud je ekvivalence tranzitivní, kde jsou dva objekty x a y definovány tak, aby byly 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é.

Konstruktory

Konstruktor	Popis
multiset	Vytvoří prázdnou `multiset` nebo která je kopií všech nebo částí zadaného `multiset`.

Typedefs

Název typu	Popis
`allocator_type`	Typedef pro `allocator` třídu objektu `multiset` .
`const_iterator`	Typedef pro obousměrný iterátor, který může číst `const` prvek v souboru `multiset`.
`const_pointer`	Definice typu ukazatele na `const` prvek v objektu `multiset`.
`const_reference`	Definice typu pro odkaz na `const` prvek uložený v objektu `multiset` pro čtení a provádění `const` operací.
`const_reverse_iterator`	Typedef pro obousměrný iterátor, který může číst libovolný `const` prvek v objektu `multiset`.
`difference_type`	Sign integer typedef for the number of element of a `multiset` in a range between elements pointed to by iterators.
`iterator`	Typedef pro obousměrný iterátor, který může číst nebo upravovat libovolný prvek v objektu `multiset`.
`key_compare`	Typedef pro objekt funkce, který může porovnat dva klíče k určení relativního pořadí dvou prvků v objektu `multiset`.
`key_type`	Typedef pro objekt funkce, který může porovnat dva klíče řazení k určení relativního pořadí dvou prvků v objektu `multiset`.
`pointer`	Definice typu ukazatele na prvek v objektu `multiset`.
`reference`	Typedef pro odkaz na prvek uložený v objektu `multiset`.
`reverse_iterator`	Typedef pro obousměrný iterátor, který může číst nebo upravovat prvek v obráceném směru `multiset`.
`size_type`	Typ celého čísla bez znaménka, který může představovat počet prvků v objektu `multiset`.
`value_compare`	Typedef pro objekt funkce, který může porovnat dva prvky jako klíče řazení určit jejich relativní pořadí v objektu `multiset`.
`value_type`	Typedef, který popisuje objekt uložený jako prvek jako `multiset` prvek ve své kapacitě jako hodnotu.

Členské funkce

Členová funkce	Popis
`begin`	Vrátí iterátor, který odkazuje na první prvek v objektu `multiset`.
`cbegin`	Vrátí iterátor const, který řeší první prvek v objektu `multiset`.
`cend`	Vrátí iterátor const, který řeší umístění úspěšné poslední prvek v objektu `multiset`.
`clear`	Vymaže všechny prvky .`multiset`
`contains`^C++20	Zkontrolujte, jestli existuje prvek se zadaným klíčem v objektu `multiset`.
`count`	Vrátí počet prvků v `multiset` klíči, který odpovídá klíči zadanému jako parametr.
`crbegin`	Vrátí konstantní iterátor adresovaný prvním prvkem v obráceném směru `multiset`.
`crend`	Vrátí const iterátor, který řeší umístění úspěšné poslední prvek v obráceném `multiset`stavu .
`emplace`	Vloží prvek vytvořený na místě do objektu `multiset`.
`emplace_hint`	Vloží prvek vytvořený na místě do objektu `multiset`, s tipem umístění.
`empty`	Testuje, jestli `multiset` je prázdný.
`end`	Vrátí iterátor, který odkazuje na umístění za posledním prvkem v objektu `multiset`.
`equal_range`	Vrátí pár iterátorů. První iterátor ve dvojici odkazuje na první prvek v `multiset` klíči, který je větší než zadaný klíč. Druhý iterátor ve dvojici odkazuje na první prvek v `multiset` klíči, který se rovná nebo je větší než klíč.
`erase`	Odebere prvek nebo rozsah prvků v `multiset` zadané pozici nebo odebere prvky, které odpovídají zadanému klíči.
`find`	Vrátí iterátor, který odkazuje na první umístění prvku v `multiset` objektu, který má klíč roven zadanému klíči.
`get_allocator`	Vrátí kopii objektu `allocator` , který se používá k sestavení `multiset`.
`insert`	Vloží prvek nebo oblast prvků do objektu `multiset`.
`key_comp`	Poskytuje objekt funkce, který může porovnat dva klíče řazení k určení relativního pořadí dvou prvků v objektu `multiset`.
`lower_bound`	Vrátí iterátor na první prvek v klíči `multiset` , který je roven nebo větší než zadaný klíč.
`max_size`	Vrátí maximální délku `multiset`.
`rbegin`	Vrátí iterátor, který odkazuje na první prvek v obráceném směru `multiset`.
`rend`	Vrátí iterátor, který odkazuje na umístění úspěšné poslední prvek v obráceném `multiset`stavu .
`size`	Vrátí počet prvků v argumentu `multiset`.
`swap`	Vymění prvky dvou `multiset`s.
`upper_bound`	Vrátí iterátor na první prvek v klíči `multiset` , který je větší než zadaný klíč.
`value_comp`	Načte kopii objektu porovnání, který slouží k seřazení hodnot prvků v objektu `multiset`.

Operátory

Operátor	Popis
`operator=`	Nahradí prvky jiného `multiset` souboru kopií jiného `multiset`.

Požadavky

Záhlaví:<set>

Obor názvů:std

`multiset::allocator_type`

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

typedef Allocator allocator_type;

Poznámky

allocator_type je synonymem parametru Allocatoršablony .

Další informace najdete Allocatorv části Poznámky tématu třídy s více sadami.

Příklad

get_allocator Příklad použitíallocator_type

`multiset::begin`

Vrátí iterátor adresování prvního prvku v objektu multiset.

const_iterator begin() const;

iterator begin();

Vrácená hodnota

Obousměrný iterátor adresující první prvek v multiset umístění, které je úspěšné, je prázdný multiset.

Příklad

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

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int>::iterator ms1_Iter;
   multiset <int>::const_iterator ms1_cIter;

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

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

   ms1_Iter = ms1.begin( );
   ms1.erase( ms1_Iter );

   // The following 2 lines would err as the iterator is const
   // ms1_cIter = ms1.begin( );
   // ms1.erase( ms1_cIter );

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

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

`multiset::cbegin`

const Vrátí iterátor, který řeší první prvek v oblasti.

const_iterator cbegin() const;

Vrácená 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 automatického odpočtu 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

`multiset::cend`

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

const_iterator cend() const;

Vrácená 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 automatického odpočtu 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.

`multiset::clear`

Vymaže všechny prvky .multiset

void clear();

Příklad

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

int main( )
{
   using namespace std;
   multiset <int> ms1;

   ms1.insert( 1 );
   ms1.insert( 2 );

   cout << "The size of the multiset is initially "
        << ms1.size( ) << "." << endl;

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

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

`multiset::const_iterator`

Typ, který poskytuje obousměrný iterátor, který může číst const prvek v objektu multiset.

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 použití .const_iterator

`multiset::const_pointer`

Typ, který poskytuje ukazatel na const prvek v objektu multiset.

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ů by měl být iterátor použit pro přístup k prvkům v objektu multiset .

`multiset::const_reference`

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

typedef typename allocator_type::const_reference const_reference;

Příklad

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

int main( )
{
   using namespace std;
   multiset <int> ms1;

   ms1.insert( 10 );
   ms1.insert( 20 );

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

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

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

The first element in the multiset is 10.

`multiset::const_reverse_iterator`

Typ, který poskytuje obousměrný iterátor, který může číst libovolný const prvek v objektu multiset.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Poznámky

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

Příklad

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

`multiset::contains`

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

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.

Vrácená hodnota

true je-li prvek nalezen v kontejneru; 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::multiset<int> theMultiSet = {1, 2};

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

    return 0;
}

true
false

`multiset::count`

Vrátí počet prvků v multiset klíči, jehož klíč odpovídá klíči zadanému parametrem.

size_type count(const Key& key) const;

Parametry

key
Klíč prvků, které mají být spárovány z objektu multiset.

Vrácená hodnota

Počet prvků v klíči multiset řazení odpovídá klíči parametru.

Poznámky

Členová funkce vrátí počet prvků x v oblasti.

[ lower_bound(key), upper_bound(key)

Příklad

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

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

int main()
{
    using namespace std;
    multiset<int> ms1;
    multiset<int>::size_type i;

    ms1.insert(1);
    ms1.insert(1);
    ms1.insert(2);

    // Elements don't need to be unique in multiset,
    // so duplicates are allowed and counted.
    i = ms1.count(1);
    cout << "The number of elements in ms1 with a sort key of 1 is: "
         << i << "." << endl;

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

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

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

`multiset::crbegin`

Vrátí konstantní iterátor adresovaný prvním prvkem v obrácené multisetě.

const_reverse_iterator crbegin() const;

Vrácená hodnota

Const reverse obousměrný iterátor adresuje první prvek v obrácené vícemnožině nebo adresování toho, co bylo posledním prvkem v nereverzní multiset.

Poznámky

crbegin se používá s obrácenou vícemnožinou stejně jako začátek se používá s multiset.

S návratovou crbeginmultiset hodnotou objektu nelze změnit.

crbegin lze použít k iteraci zpět multiset .

Příklad

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

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int>::const_reverse_iterator ms1_crIter;

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

   ms1_crIter = ms1.crbegin( );
   cout << "The first element in the reversed multiset is "
        << *ms1_crIter << "." << endl;
}

The first element in the reversed multiset is 30.

`multiset::crend`

Vrátí const iterátor, který řeší umístění úspěšné poslední prvek v obrácené multiset.

const_reverse_iterator crend() const;

Vrácená hodnota

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

Poznámky

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

S návratovou crendmultiset hodnotou objektu nelze změnit.

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

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

Příklad

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

int main() {
   using namespace std;
   multiset <int> ms1;
   multiset <int>::const_reverse_iterator ms1_crIter;

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

   ms1_crIter = ms1.crend( ) ;
   ms1_crIter--;
   cout << "The last element in the reversed multiset is "
        << *ms1_crIter << "." << endl;
}

`multiset::difference_type`

Typ celého čísla se znaménkem, který lze použít k reprezentaci počtu prvků multiset 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 [ first, last) mezi iterátory first a last, zahrnuje prvek, na který first odkazuje, a rozsah prvků až do, ale nikoli včetně, prvek, na který lastodkazuje .

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, které poskytuje kontejner náhodný přístup jako vektor.

Příklad

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

int main( )
{
   using namespace std;

   multiset <int> ms1;
   multiset <int>::iterator ms1_Iter, ms1_bIter, ms1_eIter;

   ms1.insert( 20 );
   ms1.insert( 10 );
   ms1.insert( 20 );

   ms1_bIter = ms1.begin( );
   ms1_eIter = ms1.end( );

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

   df_typ5 = count( ms1_bIter, ms1_eIter, 5 );
   df_typ10 = count( ms1_bIter, ms1_eIter, 10 );
   df_typ20 = count( ms1_bIter, ms1_eIter, 20 );

   // The keys, and hence the elements, of a multiset aren't unique
   cout << "The number '5' occurs " << df_typ5
        << " times in multiset ms1.\n";
   cout << "The number '10' occurs " << df_typ10
        << " times in multiset ms1.\n";
   cout << "The number '20' occurs " << df_typ20
        << " times in multiset ms1.\n";

   // Count the number of elements in a multiset
   multiset <int>::difference_type  df_count = 0;
   ms1_Iter = ms1.begin( );
   while ( ms1_Iter != ms1_eIter)
   {
      df_count++;
      ms1_Iter++;
   }

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

The number '5' occurs 0 times in multiset ms1.
The number '10' occurs 1 times in multiset ms1.
The number '20' occurs 2 times in multiset ms1.
The number of elements in the multiset ms1 is: 3.

`multiset::emplace`

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(Args&&... args);

Parametry

args
Argumenty přeposlané k vytvoření prvku, který má být vložen do multiset.

Vrácená hodnota

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

Poznámky

Tato funkce zneplatní žádné odkazy na prvky kontejneru, ale může zneplatnit všechny iterátory kontejneru.

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

Příklad

// multiset_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()
{
    multiset<string> s1;

    s1.emplace("Anna");
    s1.emplace("Bob");
    s1.emplace("Carmine");

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

    s1.emplace("Bob");

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

`multiset::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řeposlané k vytvoření prvku, který má být vložen do multiset.

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

Vrácená hodnota

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

Poznámky

Tato funkce zneplatní žádné odkazy na prvky kontejneru, ale může zneplatnit všechny iterátory kontejneru.

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

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

`multiset::empty`

Testuje, jestli multiset je prázdný.

bool empty() const;

Vrácená hodnota

truemultiset pokud je prázdný; false pokud multiset je neprázdný.

Příklad

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

int main()
{
   using namespace std;
   multiset <int> ms1, ms2;
   ms1.insert ( 1 );

   if ( ms1.empty( ) )
      cout << "The multiset ms1 is empty." << endl;
   else
      cout << "The multiset ms1 is not empty." << endl;

   if ( ms2.empty( ) )
      cout << "The multiset ms2 is empty." << endl;
   else
      cout << "The multiset ms2 is not empty." << endl;
}

The multiset ms1 is not empty.
The multiset ms2 is empty.

`multiset::end`

Vrátí iterátor za koncem.

const_iterator end() const;

iterator end();

Vrácená hodnota

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

Poznámky

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

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

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

`multiset::equal_range`

Vrátí dvojici iterátorů v uvedeném pořadí k prvnímu prvku v multiset klíči, který je větší než zadaný klíč, a k prvnímu prvku v multiset klíči, který je roven nebo 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ého multiset prvku.

Vrácená hodnota

Pár iterátorů tak, aby 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. firsta chcete-li odvodit dolní mez iterátoru, použijte *( pr. . first Pokud chcete získat přístup k druhému iterátoru dvojice pr vrácené členovou funkcí, použijte pr. seconda chcete-li převést horní mez iterátoru, použijte *( pr. . second

Příklad

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

int main( )
{
   using namespace std;
   typedef multiset<int, less<int> > IntSet;
   IntSet ms1;
   multiset <int> :: const_iterator ms1_RcIter;

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

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

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

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

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

   p2 = ms1.equal_range( 40 );

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

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

`multiset::erase`

Odebere prvek nebo rozsah prvků v multiset zadané pozici 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.

Vrácená hodnota

Pro první dvě členské funkce obousměrný iterátor, který určuje první prvek, který zůstává nad rámec všech prvků odebraných, nebo prvek, který je koncem multiset tohoto prvku, pokud takový prvek neexistuje.

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

Poznámky

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

`multiset::find`

Vrátí iterátor, který odkazuje na umístění prvku v objektu multiset , 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ého multiset prvku.

Vrácená hodnota

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

Poznámky

Členská funkce vrátí iterátor, který odkazuje na prvek v multiset jehož klíči je ekvivalentní argumentu key 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_iterator, multiset nelze objekt změnit. Pokud je vrácená hodnota find přiřazena k objektu iterator, multiset lze objekt upravit.

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()
{
    multiset<int> s1({ 40, 45 });
    cout << "The starting multiset 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 multiset s1 is: " << endl;
    print_collection(s1);
    cout << endl;
    findit(s1, 45);
    findit(s1, 6);
}

`multiset::get_allocator`

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

allocator_type get_allocator() const;

Vrácená hodnota

Alokátor používaný multiset.

Poznámky

Alokátory pro multiset třídu 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

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

int main( )
{
   using namespace std;
   multiset <int>::allocator_type ms1_Alloc;
   multiset <int>::allocator_type ms2_Alloc;
   multiset <double>::allocator_type ms3_Alloc;
   multiset <int>::allocator_type ms4_Alloc;

   // The following lines declare objects
   // that use the default allocator.
   multiset <int> ms1;
   multiset <int, allocator<int> > ms2;
   multiset <double, allocator<double> > ms3;

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

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

   // The following lines create a multiset ms4
   // with the allocator of multiset ms1
   ms1_Alloc = ms1.get_allocator( );
   multiset <int> ms4( less<int>( ), ms1_Alloc );
   ms4_Alloc = ms4.get_allocator( );

   // Two allocators are interchangeable if
   // storage allocated from each can be
   // deallocated with the other
   if( ms1_Alloc == ms4_Alloc )
   {
      cout << "Allocators are interchangeable."
           << endl;
   }
   else
   {
      cout << "Allocators are not interchangeable."
           << endl;
   }
}

`multiset::insert`

Vloží prvek nebo oblast prvků do objektu multiset.

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

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

ValTy
Parametr šablony, který určuje typ argumentu multiset , který lze 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.

1
Argument funkce šablony, který splňuje požadavky input_iterator_tag , které odkazuje na prvky typu, které lze použít k vytvoření 1 objektů.

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

Vrácená hodnota

Členské funkce s jedním prvkem vložení (1) a (2) vrátí iterátor do pozice, kde byl nový prvek vložen do multiset.

Členské funkce s jedním prvkem, (3) a (4), vrátí iterátor, který odkazuje na pozici, kde byl nový prvek vložen do multiset.

Poznámky

Touto funkcí nejsou neplatné žádné ukazatele ani odkazy, ale může zneplatnit všechny iterátory kontejneru.

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.

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

Členová funkce oblasti (5) vloží sekvenci hodnot prvků do multiset prvku, který odpovídá každému prvku adresovanému iterátorem v oblasti [First, Last); proto Last se nevloží. Členské funkce end() kontejneru odkazuje na pozici těsně za posledním prvkem v kontejneru – například příkaz s.insert(v.begin(), v.end()); vloží všechny prvky v do s.

Funkce člena seznamu inicializátoru (6) používá initializer_list ke kopírování prvků do multiset.

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

Příklad

// multiset_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
    multiset<int> s1;
    // call insert(const value_type&) version
    s1.insert({ 1, 10 });
    // call insert(ValTy&&) version
    s1.insert(20);

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

    // intentionally attempt a duplicate, single element
    s1.insert(1);
    cout << "The modified multiset values of s1 are:" << endl;
    print(s1);
    cout << endl;

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

    // The templatized version inserting a jumbled range
    multiset<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 multiset values of s2 are:" << endl;
    print(s2);
    cout << endl;

    // The templatized versions move-constructing elements
    multiset<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;

    multiset<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;
}

`multiset::iterator`

Typ, který poskytuje konstantní obousměrný iterátor , který může číst libovolný prvek v objektu multiset.

typedef implementation-defined iterator;

Příklad

Podívejte se na příklad začátku příkladu, jak deklarovat a používat .iterator

`multiset::key_comp`

Načte kopii objektu porovnání použitého k řazení klíčů v objektu multiset.

key_compare key_comp() const;

Vrácená hodnota

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

Další informace najdete Comparev části Poznámky tématu třídy s více sadami.

Poznámky

Uložený objekt definuje členovu funkci:

bool – operátor( const Key&x; const Key&y);

vrátí hodnotu true, pokud x přísně předchází y v pořadí řazení.

Oba key_compare a value_compare jsou synonymy pro parametr Comparešablony . Oba typy jsou k dispozici pro sadu tříd a více sad, kde jsou identické, kvůli kompatibilitě s mapou tříd a multimapou, kde jsou odlišné.

Příklad

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

int main( )
{
   using namespace std;

   multiset <int, less<int> > ms1;
   multiset <int, less<int> >::key_compare kc1 = ms1.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 ms1."
           << endl;
   }

   multiset <int, greater<int> > ms2;
   multiset <int, greater<int> >::key_compare kc2 = ms2.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 ms2."
           << endl;
   }
   else
   {
      cout << "kc2( 2,3 ) returns value of false, "
           << "where kc2 is the function object of ms2."
           << 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 ms2.

`multiset::key_compare`

Typ, který poskytuje objekt funkce, který může porovnat dva klíče řazení k určení relativního pořadí dvou prvků v objektu multiset.

typedef Compare key_compare;

Poznámky

key_compare je synonymem parametru Comparešablony .

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

Příklad

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

`multiset::key_type`

Typ, který poskytuje objekt funkce, který může porovnat klíče řazení k určení relativního pořadí dvou prvků v objektu multiset.

typedef Key key_type;

Poznámky

key_type je synonymem parametru Keyšablony .

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

Příklad

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

`multiset::lower_bound`

Vrátí iterátor na první prvek v klíči multiset , 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ého multiset prvku.

Vrácená hodnota

const_iterator Nebo iterator adresuje umístění prvku v multiset prvku s klíčem, který je roven nebo větší než klíč argumentu, nebo který řeší umístění úspěšné poslední prvek v multiset případě, že se pro klíč nenajde žádná shoda.

Příklad

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

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int> :: const_iterator ms1_AcIter, ms1_RcIter;

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

   ms1_RcIter = ms1.lower_bound( 20 );
   cout << "The element of multiset ms1 with a key of 20 is: "
        << *ms1_RcIter << "." << endl;

   ms1_RcIter = ms1.lower_bound( 40 );

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

   // The element at a specific location in the multiset can be
   // found using a dereferenced iterator addressing the location
   ms1_AcIter = ms1.end( );
   ms1_AcIter--;
   ms1_RcIter = ms1.lower_bound( *ms1_AcIter );
   cout << "The element of ms1 with a key matching "
        << "that of the last element is: "
        << *ms1_RcIter << "." << endl;
}

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

`multiset::max_size`

Vrátí maximální délku multiset.

size_type max_size() const;

Vrácená hodnota

Maximální možnou délku multiset.

Příklad

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

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int>::size_type i;

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

`multiset::multiset`

multiset Vytvoří, která je prázdná nebo která je kopií všech nebo částí jiného multiset.

multiset();

explicit multiset (
    const Compare& Comp);

multiset (
    const Compare& Comp,
    const Allocator& Al);

multiset(
    const multiset& Right);

multiset(
    multiset&& Right);

multiset(
    initializer_list<Type> IList);

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

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

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

template <class InputIterator>
multiset (
    InputIterator First,
    InputIterator Last,
    const Compare& Comp);

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

Parametry

Al
Třída alokátoru úložiště, která se má použít pro tento objekt s více sadami Allocator, což je výchozí hodnota .

Comp
Porovnávací funkce typu const Compare , která se používá k seřazení prvků v multisetsouboru , který je výchozí Compare.

Right
z multiset nichž má být kopírovaná vícesadka.

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
Ze initializer_list kterého chcete prvky zkopírovat.

Poznámky

Všechny konstruktory ukládají typ objektu alokátoru, který spravuje úložiště paměti pro objekt multiset 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í jejich multiset.

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

První tři konstruktory určují prázdnou počáteční multisetu, druhou určující typ porovnávací funkce (Comp) k určení 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 multisetRight.

Pátý konstruktor určuje kopii přesunutím multisetRight.

6., 7. a 8. konstruktory určují initializer_list, ze kterého se mají prvky kopírovat.

Další tři konstruktory zkopírují rozsah [First, Last)multiset s rostoucí explicitností při zadávání typu porovnávací funkce a alokátoru.

Příklad

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

int main()
{
    using namespace std;
    //multiset <int>::iterator ms1_Iter, ms2_Iter, ms3_Iter;
    multiset <int>::iterator ms4_Iter, ms5_Iter, ms6_Iter, ms7_Iter;

    // Create an empty multiset ms0 of key type integer
    multiset <int> ms0;

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

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

    // Create a multiset ms3 with the
    // allocator of multiset ms1
    multiset <int>::allocator_type ms1_Alloc;
    ms1_Alloc = ms1.get_allocator();
    multiset <int> ms3(less<int>(), ms1_Alloc);
    ms3.insert(30);

    // Create a copy, multiset ms4, of multiset ms1
    multiset <int> ms4(ms1);

    // Create a multiset ms5 by copying the range ms1[ first,  last)
    multiset <int>::const_iterator ms1_bcIter, ms1_ecIter;
    ms1_bcIter = ms1.begin();
    ms1_ecIter = ms1.begin();
    ms1_ecIter++;
    ms1_ecIter++;
    multiset <int> ms5(ms1_bcIter, ms1_ecIter);

    // Create a multiset ms6 by copying the range ms4[ first,  last)
    // and with the allocator of multiset ms2
    multiset <int>::allocator_type ms2_Alloc;
    ms2_Alloc = ms2.get_allocator();
    multiset <int> ms6(ms4.begin(), ++ms4.begin(), less<int>(), ms2_Alloc);

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

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

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

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

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

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

    // Create a multiset by moving ms5
    multiset<int> ms7(move(ms5));
    cout << "ms7 =";
    for (auto i : ms7)
        cout << " " << i;
    cout << endl;

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

`multiset::operator=`

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

multiset& operator=(const multiset& right);

multiset& operator=(multiset&& right);

Parametry

Right
Prvky multiset , ze kterých jsou zkopírovány nebo přesunuty.

Poznámky

operator= zkopíruje nebo přesune prvky do Right tohoto multisetv závislosti na použitém typu odkazu (lvalue nebo rvalue). Prvky, které jsou v tomto multiset textu před operator= provedením, budou zahozeny.

Příklad

// multiset_operator_as.cpp
// compile with: /EHsc
#include <multiset>
#include <iostream>

int main( )
   {
   using namespace std;
   multiset<int> v1, v2, v3;
   multiset<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;
   }

`multiset::pointer`

Typ, který poskytuje ukazatel na prvek v objektu multiset.

typedef typename allocator_type::pointer pointer;

Poznámky

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

Ve většině případů by měl být iterátor použit pro přístup k prvkům v objektu multiset .

`multiset::rbegin`

Vrátí iterátor adresovaný první prvek v obrácené vícemnožině.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Vrácená hodnota

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

Poznámky

rbegin se používá s obráceným kódem multiset stejně jako rbegin se používá s multiset.

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

rbegin lze použít k iteraci zpět multiset .

Příklad

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

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int>::iterator ms1_Iter;
   multiset <int>::reverse_iterator ms1_rIter;

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

   ms1_rIter = ms1.rbegin( );
   cout << "The first element in the reversed multiset is "
        << *ms1_rIter << "." << endl;

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

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

   // a multiset element can be erased by dereferencing to its key
   ms1_rIter = ms1.rbegin( );
   ms1.erase ( *ms1_rIter );

   ms1_rIter = ms1.rbegin( );
   cout << "After the erasure, the first element "
        << "in the reversed multiset is "<< *ms1_rIter << "."
        << endl;
}

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

`multiset::reference`

Typ, který poskytuje odkaz na prvek uložený v objektu multiset.

typedef typename allocator_type::reference reference;

Příklad

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

int main( )
{
   using namespace std;
   multiset <int> ms1;

   ms1.insert( 10 );
   ms1.insert( 20 );

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

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

The first element in the multiset is 10.

`multiset::rend`

Vrátí iterátor, který řeší umístění úspěšné poslední prvek v obráceném stavu multiset.

const_reverse_iterator rend() const;

reverse_iterator rend();

Vrácená hodnota

Reverzní obousměrný iterátor, který adresuje umístění úspěšné poslední prvek v obráceném multiset směru (umístění, které předchází prvnímu prvku v nereverze multiset).

Poznámky

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

Pokud je vrácená hodnota rend přiřazena k objektu const_reverse_iterator, multiset nelze objekt upravit. Pokud je vrácená hodnota rend přiřazena k objektu reverse_iterator, multiset lze objekt upravit.

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

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

Příklad

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

int main() {
   using namespace std;
   multiset <int> ms1;
   multiset <int>::iterator ms1_Iter;
   multiset <int>::reverse_iterator ms1_rIter;
   multiset <int>::const_reverse_iterator ms1_crIter;

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

   ms1_rIter = ms1.rend( ) ;
   ms1_rIter--;
   cout << "The last element in the reversed multiset is "
        << *ms1_rIter << "." << endl;

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

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

   ms1_rIter = ms1.rend( );
   ms1_rIter--;
   ms1.erase ( *ms1_rIter );

   ms1_rIter = ms1.rend( );
   --ms1_rIter;
   cout << "After the erasure, the last element in the "
        << "reversed multiset is " << *ms1_rIter << "." << endl;
}

`multiset::reverse_iterator`

Typ, který poskytuje obousměrný iterátor, který může číst nebo upravovat prvek v obrácené multiset.

typedef std::reverse_iterator<iterator> reverse_iterator;

Poznámky

Typ reverse_iterator se používá k iteraci obráceně multiset .

Příklad

rbegin Příklad, jak deklarovat a používat reverse_iterator.

`multiset::size`

Vrátí počet prvků v sadě multiset.

size_type size() const;

Vrácená hodnota

Aktuální délka multiset.

Příklad

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

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int> :: size_type i;

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

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

The multiset length is 1.
The multiset length is now 2.

`multiset::size_type`

Typ celého čísla bez znaménka, který může představovat počet prvků v objektu multiset.

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

`multiset::swap`

Vymění prvky dvou sad.

void swap(
    multiset<Key, Compare, Allocator>& right);

Parametry

Right
Argument multiset poskytující prvky, které mají být prohozeny s cílovou vícemnožinou.

Poznámky

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

Příklad

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

int main( )
{
   using namespace std;
   multiset <int> ms1, ms2, ms3;
   multiset <int>::iterator ms1_Iter;

   ms1.insert( 10 );
   ms1.insert( 20 );
   ms1.insert( 30 );
   ms2.insert( 100 );
   ms2.insert( 200 );
   ms3.insert( 300 );

   cout << "The original multiset ms1 is:";
   for ( ms1_Iter = ms1.begin( ); ms1_Iter != ms1.end( ); ms1_Iter++ )
      cout << " " << *ms1_Iter;
   cout << "." << endl;

   // This is the member function version of swap
   ms1.swap( ms2 );

   cout << "After swapping with ms2, list ms1 is:";
   for ( ms1_Iter = ms1.begin( ); ms1_Iter != ms1.end( ); ms1_Iter++ )
      cout << " " << *ms1_Iter;
   cout << "." << endl;

   // This is the specialized template version of swap
   swap( ms1, ms3 );

   cout << "After swapping with ms3, list ms1 is:";
   for ( ms1_Iter = ms1.begin( ); ms1_Iter != ms1.end( ); ms1_Iter++ )
      cout << " " << *ms1_Iter;
   cout   << "." << endl;
}

The original multiset ms1 is: 10 20 30.
After swapping with ms2, list ms1 is: 100 200.
After swapping with ms3, list ms1 is: 300.

`multiset::upper_bound`

Vrátí iterátor na první prvek v klíči multiset , 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ého multiset prvku.

Vrácená hodnota

Iterátor nebo const_iterator adresující umístění prvku v multiset klíči, který je větší než klíč argumentu, nebo který řeší umístění úspěšného posledního multiset prvku v případě, že se pro klíč nenajde žádná shoda.

Příklad

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

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int> :: const_iterator ms1_AcIter, ms1_RcIter;

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

   ms1_RcIter = ms1.upper_bound( 20 );
   cout << "The first element of multiset ms1 with a key greater "
           << "than 20 is: " << *ms1_RcIter << "." << endl;

   ms1_RcIter = ms1.upper_bound( 30 );

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

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

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

`multiset::value_comp`

Načte kopii objektu porovnání použitého k seřazení hodnot prvků v objektu multiset.

value_compare value_comp() const;

Vrácená hodnota

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

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

Poznámky

Uložený objekt definuje členovu funkci:

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

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

Oba key_compare a value_compare jsou synonymy pro parametr Comparešablony . Oba typy jsou k dispozici pro sadu tříd a multiset, kde jsou identické, kvůli kompatibilitě s mapou tříd a multimap, kde jsou odlišné.

Příklad

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

int main( )
{
   using namespace std;

   multiset <int, less<int> > ms1;
   multiset <int, less<int> >::value_compare vc1 = ms1.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 ms1."
           << endl;
   }
   else
   {
      cout << "vc1( 2,3 ) returns value of false, "
           << "where vc1 is the function object of ms1."
           << endl;
   }

   set <int, greater<int> > ms2;
   set<int, greater<int> >::value_compare vc2 = ms2.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 ms2."
           << endl;
   }
   else
   {
      cout << "vc2( 2,3 ) returns value of false, "
           << "where vc2 is the function object of ms2."
           << endl;
   }
}

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

`multiset::value_compare`

Typ, který poskytuje objekt funkce, který může porovnat dva klíče řazení k určení jejich relativního pořadí v objektu multiset.

typedef key_compare value_compare;

Poznámky

value_compare je synonymem parametru Comparešablony .

Další informace najdete Comparev části Poznámky tématu třídy s více sadami.

Příklad

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

`multiset::value_type`

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

typedef Key value_type;

Poznámky

value_type je synonymem parametru Keyšablony .

Oba key_type a value_type jsou synonymy pro parametr Keyšablony . Oba typy jsou k dispozici pro sadu tříd a více sad, kde jsou identické, kvůli kompatibilitě s mapou tříd a multimapou, kde jsou odlišné.

Další informace naleznete Keyv části Poznámky tématu.

Příklad

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

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int>::iterator ms1_Iter;

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

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

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

   // a multiset accepts key_types or value_types as elements
   cout << "The multiset has elements:";
   for ( ms1_Iter = ms1.begin( ) ; ms1_Iter != ms1.end( ); ms1_Iter++ )
      cout << " " << *ms1_Iter;
   cout << "." << endl;
}

The multiset has elements: 10 20.

Viz také

Kontejnery
Bezpečný přístup z více vláken ve standardní knihovně C++
Standardní knihovna C++ – referenční dokumentace

multiset Třída

Syntaxe

Parametry

Poznámky

Konstruktory

Typedefs

Členské funkce

Operátory

Požadavky

multiset::allocator_type

Poznámky

Příklad

multiset::begin

Vrácená hodnota

Příklad

multiset::cbegin

Vrácená hodnota

Poznámky

multiset::cend

Vrácená hodnota

Poznámky

multiset::clear

Příklad

multiset::const_iterator

Poznámky

Příklad

multiset::const_pointer

Poznámky

multiset::const_reference

Příklad

multiset::const_reverse_iterator

Poznámky

Příklad

multiset::contains

Parametry

Vrácená hodnota

Poznámky

Příklad

multiset::count

Parametry

Vrácená hodnota

Poznámky

Příklad

multiset::crbegin

Vrácená hodnota

Poznámky

Příklad

multiset::crend

Vrácená hodnota

Poznámky

Příklad

multiset::difference_type

Poznámky

Příklad

multiset::emplace

Parametry

Vrácená hodnota

Poznámky

Příklad

multiset::emplace_hint

Parametry

Vrácená hodnota

Poznámky

multiset::empty

Vrácená hodnota

Příklad

multiset::end

Vrácená hodnota

Poznámky

multiset::equal_range

Parametry

Vrácená hodnota

Příklad

multiset::erase

Parametry

Vrácená hodnota

Poznámky

multiset::find

Parametry

Vrácená hodnota

`multiset` Třída

`multiset::allocator_type`

`multiset::begin`

`multiset::cbegin`

`multiset::cend`

`multiset::clear`

`multiset::const_iterator`

`multiset::const_pointer`

`multiset::const_reference`

`multiset::const_reverse_iterator`

`multiset::contains`

`multiset::count`

`multiset::crbegin`

`multiset::crend`

`multiset::difference_type`

`multiset::emplace`

`multiset::emplace_hint`

`multiset::empty`

`multiset::end`

`multiset::equal_range`

`multiset::erase`

`multiset::find`

`multiset::get_allocator`

`multiset::insert`

`multiset::iterator`

`multiset::key_comp`

`multiset::key_compare`

`multiset::key_type`

`multiset::lower_bound`

`multiset::max_size`

`multiset::multiset`

`multiset::operator=`

`multiset::pointer`

`multiset::rbegin`

`multiset::reference`

`multiset::rend`

`multiset::reverse_iterator`

`multiset::size`

`multiset::size_type`

`multiset::swap`

`multiset::upper_bound`

`multiset::value_comp`