unordered_multiset-klass

Klassmallen beskriver ett objekt som styr en sekvens med varierande längd av element av typen const Key. Sekvensen är svagt ordnad av en hash-funktion, som partitionerar sekvensen i en ordnad uppsättning underfrågor som kallas bucketar. I varje bucket avgör en jämförelsefunktion om ett par element har motsvarande ordning. Varje element fungerar som både en sorteringsnyckel och ett värde. Sekvensen representeras på ett sätt som tillåter sökning, infogning och borttagning av ett godtyckligt element med ett antal åtgärder som kan vara oberoende av antalet element i sekvensen (konstant tid), åtminstone när alla bucketar är ungefär lika långa. I värsta fall, när alla element finns i en bucket, är antalet åtgärder proportionella mot antalet element i sekvensen (linjär tid). Dessutom ogiltigförklarar infogning av ett element inga iteratorer, och om du tar bort ett element ogiltigförklaras endast de iteratorer som pekar på det borttagna elementet.

Syntax

template <class Key,
    class Hash = std::hash<Key>,
    class Pred = std::equal_to<Key>,
    class Alloc = std::allocator<Key>>
class unordered_multiset;

Parameterar

Nyckel
Nyckeltypen.

Hasch
Objekttypen hash-funktion.

Pred
Objekttypen för likhetsjämförelsefunktionen.

Alloc
Allokeringsklassen.

Medlemmar

Anmärkningar

Objektet beställer sekvensen som det styr genom att anropa två lagrade objekt, ett jämförelsefunktionsobjekt av typen unordered_multiset::key_equal och ett hash-funktionsobjekt av typen unordered_multiset::hasher. Du kommer åt det första lagrade objektet genom att anropa medlemsfunktionen unordered_multiset::key_eq() och du kommer åt det andra lagrade objektet genom att anropa medlemsfunktionen unordered_multiset::hash_function(). Specifikt för alla värden X och Y av typen Keyreturnerar anropet key_eq()(X, Y) endast sant om de två argumentvärdena har motsvarande ordning. anropet hash_function()(keyval) ger en fördelning av värden av typen size_t. Till skillnad från klassmallen unordered_setsäkerställer inte ett objekt av typen unordered_multiset att det key_eq()(X, Y) alltid är falskt för två element i den kontrollerade sekvensen. (Nycklar behöver inte vara unika.)

Objektet lagrar också en maximal belastningsfaktor, som anger det maximala önskade genomsnittliga antalet element per bucket. Om infogning av ett element orsakar unordered_multiset::load_factor() överskrider den maximala belastningsfaktorn ökar containern antalet bucketar och återskapar hash-tabellen efter behov.

Den faktiska ordningen på element i den kontrollerade sekvensen beror på hash-funktionen, jämförelsefunktionen, insättningsordningen, den maximala belastningsfaktorn och det aktuella antalet bucketar. Du kan inte i allmänhet förutsäga ordningen på element i den kontrollerade sekvensen. Du kan dock alltid vara säker på att alla delmängder av element som har motsvarande ordning ligger intill varandra i den kontrollerade sekvensen.

Objektet allokerar och frigör lagring för den sekvens som det styr genom ett lagrat allokeringsobjekt av typen unordered_multiset::allocator_type. Ett sådant allokeringsobjekt måste ha samma externa gränssnitt som ett objekt av typen allocator. Observera att det lagrade allokeringsobjektet inte kopieras när containerobjektet tilldelas.

Kravspecifikation

Rubrik:<unordered_set>

namnområde: std

unordered_multiset::allocator_type

Typ av allokerare för hantering av lagring.

typedef Alloc allocator_type;

Anmärkningar

Typen är en synonym för mallparametern Alloc.

Exempel

// std__unordered_set__unordered_multiset_allocator_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
typedef std::allocator<std::pair<const char, int> > Myalloc;
int main()
{
    Myset c1;

    Myset::allocator_type al = c1.get_allocator();
    std::cout << "al == std::allocator() is "
        << std::boolalpha << (al == Myalloc()) << std::endl;

    return (0);
}

al == std::allocator() is true

unordered_multiset::begin

Anger början av den kontrollerade sekvensen eller en bucket.

iterator begin();

const_iterator begin() const;

local_iterator begin(size_type nbucket);

const_local_iterator begin(size_type nbucket) const;

Parameterar

nbucket
Bucketnumret.

Anmärkningar

De två första medlemsfunktionerna returnerar en framåtriktad iterator som pekar på det första elementet i sekvensen (eller strax utanför slutet av en tom sekvens). De två sista medlemsfunktionerna returnerar en vidarebefordrande iterator som pekar på det första elementet i bucket nbucket (eller precis utanför slutet av en tom bucket).

Exempel

// std__unordered_set__unordered_multiset_begin.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect first two items "[c] [b]"
    Myset::iterator it2 = c1.begin();
    std::cout << "[" << *it2 << "] ";
    ++it2;
    std::cout << "[" << *it2 << "] ";
    std::cout << std::endl;

    // inspect bucket containing 'a'
    Myset::const_local_iterator lit = c1.begin(c1.bucket('a'));
    std::cout << "[" << *lit << "] ";

    return (0);
}

[c] [b] [a]
[c] [b]
[a]

unordered_multiset::bucket

Hämtar bucketnumret för ett nyckelvärde.

size_type bucket(const Key& keyval) const;

Parameterar

keyval
Nyckelvärdet som ska mappas.

Anmärkningar

Medlemsfunktionen returnerar det bucketnummer som för närvarande motsvarar nyckelvärdet keyval.

Exempel

// std__unordered_set__unordered_multiset_bucket.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // display buckets for keys
    Myset::size_type bs = c1.bucket('a');
    std::cout << "bucket('a') == " << bs << std::endl;
    std::cout << "bucket_size(" << bs << ") == " << c1.bucket_size(bs)
        << std::endl;

    return (0);
}

[c] [b] [a]
bucket('a') == 7
bucket_size(7) == 1

unordered_multiset::bucket_count

Hämtar antalet bucketar.

size_type bucket_count() const;

Anmärkningar

Medlemsfunktionen returnerar det aktuella antalet bucketar.

Exempel

// std__unordered_set__unordered_multiset_bucket_count.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;

    return (0);
}

[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4

bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1

bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1

unordered_multiset::bucket_size

Hämtar storleken på en bucket

size_type bucket_size(size_type nbucket) const;

Parameterar

nbucket
Bucketnumret.

Anmärkningar

Medlemsfunktionerna returnerar storleken på bucketnummer nbucket.

Exempel

// std__unordered_set__unordered_multiset_bucket_size.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // display buckets for keys
    Myset::size_type bs = c1.bucket('a');
    std::cout << "bucket('a') == " << bs << std::endl;
    std::cout << "bucket_size(" << bs << ") == " << c1.bucket_size(bs)
        << std::endl;

    return (0);
}

[c] [b] [a]
bucket('a') == 7
bucket_size(7) == 1

unordered_multiset::cbegin

Returnerar en const iterator som adresserar det första elementet i intervallet.

const_iterator cbegin() const;

Returvärde

En const iterator för vidarebefordran som pekar på det första elementet i intervallet, eller platsen precis utanför slutet av ett tomt intervall (för ett tomt intervall cbegin() == cend()).

Anmärkningar

Med returvärdet för cbeginkan elementen i intervallet inte ändras.

Du kan använda den här medlemsfunktionen i stället för funktionen begin() medlem för att garantera att returvärdet är const_iterator. Vanligtvis används det tillsammans med nyckelordet autotypsavdrag , som du ser i följande exempel. I exemplet bör du överväga att Container vara en ändringsbar (icke-const) container av något slag som stöder begin() och cbegin().

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

auto i2 = Container.cbegin();
// i2 is Container<T>::const_iterator

unordered_multiset::cend

Returnerar en const iterator som adresserar platsen precis utanför det sista elementet i ett intervall.

const_iterator cend() const;

Returvärde

En const iterator för vidarebefordran som pekar precis utanför intervallets slut.

Anmärkningar

cend används för att testa om en iterator har passerat slutet av sitt intervall.

Du kan använda den här medlemsfunktionen i stället för funktionen end() medlem för att garantera att returvärdet är const_iterator. Vanligtvis används det tillsammans med nyckelordet autotypsavdrag , som du ser i följande exempel. I exemplet bör du överväga att Container vara en ändringsbar (icke-const) container av något slag som stöder end() och cend().

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

auto i2 = Container.cend();
// i2 is Container<T>::const_iterator

Värdet som returneras av cend bör inte derefereras.

unordered_multiset::clear

Tar bort alla element.

void clear();

Anmärkningar

Medlemsfunktionen anropar unordered_multiset::erase(unordered_multiset::begin(),unordered_multiset::end()).

Exempel

// std__unordered_set__unordered_multiset_clear.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a] "
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // clear the container and reinspect
    c1.clear();
    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
    std::cout << std::endl;

    c1.insert('d');
    c1.insert('e');

    // display contents "[e] [d] "
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;

    return (0);
}

[c] [b] [a]
size == 0
empty() == true

[e] [d]
size == 2
empty() == false

unordered_multiset::const_iterator

Typen av en konstant iterator för den kontrollerade sekvensen.

typedef T1 const_iterator;

Anmärkningar

Typen beskriver ett objekt som kan fungera som en konstant vidarebefordran iterator för den kontrollerade sekvensen. Det beskrivs här som en synonym för den implementeringsdefinierade typen T1.

Exempel

// std__unordered_set__unordered_multiset_const_iterator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]

unordered_multiset::const_local_iterator

Typen av en konstant bucket-iterator för den kontrollerade sekvensen.

typedef T5 const_local_iterator;

Anmärkningar

Typen beskriver ett objekt som kan fungera som en konstant vidarebefordran iterator för en bucket. Det beskrivs här som en synonym för den implementeringsdefinierade typen T5.

Exempel

// std__unordered_set__unordered_multiset_const_local_iterator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect bucket containing 'a'
    Myset::const_local_iterator lit = c1.begin(c1.bucket('a'));
    std::cout << "[" << *lit << "] ";

    return (0);
}

[c] [b] [a]
[a]

unordered_multiset::const_pointer

Typen av en konstant pekare till ett element.

typedef Alloc::const_pointer const_pointer;

Anmärkningar

Typen beskriver ett objekt som kan fungera som en konstant pekare till ett element i den kontrollerade sekvensen.

Exempel

// std__unordered_set__unordered_multiset_const_pointer.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::iterator it = c1.begin();
        it != c1.end(); ++it)
        {
        Myset::const_pointer p = &*it;
        std::cout << "[" << *p << "] ";
        }
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]

unordered_multiset::const_reference

Typen av en konstant referens till ett element.

typedef Alloc::const_reference const_reference;

Anmärkningar

Typen beskriver ett objekt som kan fungera som en konstant referens till ett element i den kontrollerade sekvensen.

Exempel

// std__unordered_set__unordered_multiset_const_reference.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::iterator it = c1.begin();
        it != c1.end(); ++it)
        {
        Myset::const_reference ref = *it;
        std::cout << "[" << ref << "] ";
        }
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]

unordered_multiset::contains

Kontrollerar om det finns ett element med den angivna nyckeln i unordered_multiset.

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

Parameterar

K
Typ av nyckel.

nyckel
Elementets nyckelvärde att söka efter.

Returvärde

true om elementet finns i containern. false annars.

Anmärkningar

contains() är nytt i C++20. Om du vill använda den anger du kompileringsalternativet /std:c++20 eller senare.

template<class K> bool contains(const K& key) const deltar endast i överbelastningsmatchning om key_compare är transparent.

Exempel

// Requires /std:c++20 or later
#include <unordered_set>
#include <iostream>

int main()
{
    std::unordered_multiset<int> theUnorderedMultiset = { 1, 2, 3 };

    std::cout << std::boolalpha; // so booleans show as 'true' or 'false'
    std::cout << theUnorderedMultiset.contains(1) << '\n';
    std::cout << theUnorderedMultiset.contains(4) << '\n';

    return 0;
}

true
false

unordered_multiset::count

Hittar antalet element som matchar en angiven nyckel.

size_type count(const Key& keyval) const;

Parameterar

keyval
Nyckelvärde att söka efter.

Anmärkningar

Medlemsfunktionen returnerar antalet element i intervallet som avgränsas av unordered_multiset::equal_range(keyval).

Exempel

// std__unordered_set__unordered_multiset_count.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    std::cout << "count('A') == " << c1.count('A') << std::endl;
    std::cout << "count('b') == " << c1.count('b') << std::endl;
    std::cout << "count('C') == " << c1.count('C') << std::endl;

    return (0);
}

[c] [b] [a]
count('A') == 0
count('b') == 1
count('C') == 0

unordered_multiset::d ifference_type

Typen av ett signerat avstånd mellan två element.

typedef T3 difference_type;

Anmärkningar

Den signerade heltalstypen beskriver ett objekt som kan representera skillnaden mellan adresserna för två element i den kontrollerade sekvensen. Det beskrivs här som en synonym för den implementeringsdefinierade typen T3.

Exempel

// std__unordered_set__unordered_multiset_difference_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // compute positive difference
    Myset::difference_type diff = 0;
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        ++diff;
    std::cout << "end()-begin() == " << diff << std::endl;

    // compute negative difference
    diff = 0;
    for (Myset::const_iterator it = c1.end();
        it != c1.begin(); --it)
        --diff;
    std::cout << "begin()-end() == " << diff << std::endl;

    return (0);
}

[c] [b] [a]
end()-begin() == 3
begin()-end() == -3

unordered_multiset::emplace

Infogar ett element som skapats på plats (inga kopierings- eller flyttåtgärder utförs).

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

Parameterar

args
Argumenten som vidarebefordras för att konstruera ett element som ska infogas i unordered_multiset.

Returvärde

En iterator till det nyligen infogade elementet.

Anmärkningar

Inga referenser till containerelement har ogiltigförklarats av den här funktionen, men alla iteratorer kan ogiltigförklaras i containern.

Om ett undantag utlöses under infogningen men inte inträffar i containerns hash-funktion ändras inte containern. Om undantaget genereras i hash-funktionen är resultatet odefinierat.

Ett kodexempel finns i multiset::emplace.

unordered_multiset::emplace_hint

Infogar ett element som är konstruerat på plats (inga kopierings- eller flyttåtgärder utförs) med ett placeringstips.

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

Parameterar

args
Argumenten som vidarebefordras för att konstruera ett element som ska infogas i unordered_multiset.

var
Ett tips om platsen där du kan börja söka efter rätt insättningspunkt.

Returvärde

En iterator till det nyligen infogade elementet.

Anmärkningar

Inga referenser till containerelement har ogiltigförklarats av den här funktionen, men alla iteratorer kan ogiltigförklaras i containern.

Om ett undantag utlöses under infogningen men inte inträffar i containerns hash-funktion ändras inte containern. Om undantaget genereras i hash-funktionen är resultatet odefinierat.

Ett kodexempel finns i set::emplace_hint.

unordered_multiset::empty

Testar om det inte finns några element.

bool empty() const;

Anmärkningar

Medlemsfunktionen returnerar true för en tom kontrollerad sekvens.

Exempel

// std__unordered_set__unordered_multiset_empty.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // clear the container and reinspect
    c1.clear();
    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
    std::cout << std::endl;

    c1.insert('d');
    c1.insert('e');

    // display contents "[e] [d]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;

    return (0);
}

[c] [b] [a]
size == 0
empty() == true

[e] [d]
size == 2
empty() == false

unordered_multiset::end

Anger slutet på den kontrollerade sekvensen.

iterator end();
const_iterator end() const;
local_iterator end(size_type nbucket);
const_local_iterator end(size_type nbucket) const;

Parameterar

nbucket
Bucketnumret.

Anmärkningar

De två första medlemsfunktionerna returnerar en vidarebefordran iterator som pekar precis utanför slutet av sekvensen. De två sista medlemsfunktionerna returnerar en vidarebefordran iterator som pekar precis utanför slutet av bucket nbucket.

Exempel

// std__unordered_set__unordered_multiset_end.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect last two items "[a] [b]"
    Myset::iterator it2 = c1.end();
    --it2;
    std::cout << "[" << *it2 << "] ";
    --it2;
    std::cout << "[" << *it2 << "] ";
    std::cout << std::endl;

    // inspect bucket containing 'a'
    Myset::const_local_iterator lit = c1.end(c1.bucket('a'));
    --lit;
    std::cout << "[" << *lit << "] ";

    return (0);
}

[c] [b] [a]
[a] [b]
[a]

unordered_multiset::equal_range

Söker efter intervall som matchar en angiven nyckel.

std::pair<iterator, iterator>
    equal_range(const Key& keyval);

std::pair<const_iterator, const_iterator>
    equal_range(const Key& keyval) const;

Parameterar

keyval
Nyckelvärde att söka efter.

Anmärkningar

Medlemsfunktionen returnerar ett par iteratorer X som [X.first, X.second) avgränsar bara de element i den kontrollerade sekvensen som har motsvarande ordning med nyckelval. Om det inte finns några sådana element är båda iteratorerna end().

Exempel

// std__unordered_set__unordered_multiset_equal_range.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // display results of failed search
    std::pair<Myset::iterator, Myset::iterator> pair1 =
        c1.equal_range('x');
    std::cout << "equal_range('x'):";
    for (; pair1.first != pair1.second; ++pair1.first)
        std::cout << "[" << *pair1.first << "] ";
    std::cout << std::endl;

    // display results of successful search
    pair1 = c1.equal_range('b');
    std::cout << "equal_range('b'):";
    for (; pair1.first != pair1.second; ++pair1.first)
        std::cout << "[" << *pair1.first << "] ";
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
equal_range('x'):
equal_range('b'): [b]

unordered_multiset::erase

Tar bort ett element eller ett område med element i en unordered_multiset från angivna positioner eller tar bort element som matchar en angiven nyckel.

iterator erase(
    const_iterator Where);

iterator erase(
    const_iterator First,
    const_iterator Last);

size_type erase(
    const key_type& Key);

Parameterar

Var
Positionen för elementet som ska tas bort.

Första
Positionen för det första elementet som ska tas bort.

senaste
Placera precis utanför det sista elementet som ska tas bort.

Nyckel
Nyckelvärdet för de element som ska tas bort.

Returvärde

För de två första medlemsfunktionerna är en dubbelriktad iterator som anger det första elementet som återstår utöver alla element som tas bort, eller ett element som är slutet på unordered_multiset om det inte finns något sådant element.

För den tredje medlemsfunktionen returnerar antalet element som har tagits bort från unordered_multiset.

Anmärkningar

Ett kodexempel finns i set::erase.

unordered_multiset::find

Hittar ett element som matchar en angiven nyckel.

const_iterator find(const Key& keyval) const;

Parameterar

keyval
Nyckelvärde att söka efter.

Anmärkningar

Medlemsfunktionen returnerar unordered_multiset::equal_range(keyval).first.

Exempel

// std__unordered_set__unordered_multiset_find.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // try to find and fail
    std::cout << "find('A') == "
        << std::boolalpha << (c1.find('A') != c1.end()) << std::endl;

    // try to find and succeed
    Myset::iterator it = c1.find('b');
    std::cout << "find('b') == "
        << std::boolalpha << (it != c1.end())
        << ": [" << *it << "] " << std::endl;

    return (0);
}

[c] [b] [a]
find('A') == false
find('b') == true: [b]

unordered_multiset::get_allocator

Hämtar det lagrade allokeringsobjektet.

Alloc get_allocator() const;

Anmärkningar

Medlemsfunktionen returnerar det lagrade allokeringsobjektet.

Exempel

// std__unordered_set__unordered_multiset_get_allocator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
typedef std::allocator<std::pair<const char, int> > Myalloc;
int main()
{
    Myset c1;

    Myset::allocator_type al = c1.get_allocator();
    std::cout << "al == std::allocator() is "
        << std::boolalpha << (al == Myalloc()) << std::endl;

    return (0);
}

al == std::allocator() is true

unordered_multiset::hash_function

Hämtar det lagrade hash-funktionsobjektet.

Hash hash_function() const;

Anmärkningar

Medlemsfunktionen returnerar det lagrade hash-funktionsobjektet.

Exempel

// std__unordered_set__unordered_multiset_hash_function.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    Myset::hasher hfn = c1.hash_function();
    std::cout << "hfn('a') == " << hfn('a') << std::endl;
    std::cout << "hfn('b') == " << hfn('b') << std::endl;

    return (0);
}

hfn('a') == 1630279
hfn('b') == 1647086

unordered_multiset::hasher

Typen av hash-funktion.

typedef Hash hasher;

Anmärkningar

Typen är en synonym för mallparametern Hash.

Exempel

// std__unordered_set__unordered_multiset_hasher.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    Myset::hasher hfn = c1.hash_function();
    std::cout << "hfn('a') == " << hfn('a') << std::endl;
    std::cout << "hfn('b') == " << hfn('b') << std::endl;

    return (0);
}

hfn('a') == 1630279
hfn('b') == 1647086

unordered_multiset::insert

Infogar ett element eller ett område med element i en unordered_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);

Parameterar

Val
Värdet för ett element som ska infogas i unordered_multiset.

Var
Platsen där du vill börja söka efter rätt insättningspunkt.

ValTy
Mallparameter som anger den argumenttyp som unordered_multiset kan använda för att konstruera ett element av value_type och perfekt vidarebefordrar Val som ett argument.

Första
Positionen för det första element som ska kopieras.

senaste
Positionen precis utanför det sista element som ska kopieras.

InputIterator
Mallfunktionsargument som uppfyller kraven för en indata-iterator som pekar på element av en typ som kan användas för att konstruera value_type objekt.

IList
Den initializer_list som elementen ska kopieras från.

Returvärde

Medlemsfunktionerna single-element-insert, (1) och (2), returnerar en iterator till den position där det nya elementet infogades i unordered_multiset.

Medlemsfunktionerna single-element-with-hint, (3) och (4), returnerar en iterator som pekar på positionen där det nya elementet infogades i unordered_multiset.

Anmärkningar

Inga pekare eller referenser har ogiltigförklarats av den här funktionen, men alla iteratorer kan ogiltigförklaras i containern.

Om ett undantag utlöses men inte inträffar i containerns hash-funktion ändras inte containerns tillstånd under infogningen av bara ett element. Om undantaget genereras i hash-funktionen är resultatet odefinierat. Om ett undantag utlöses under införandet av flera element lämnas containern i ett ospecificerat men giltigt tillstånd.

Value_type för en container är en typedef som tillhör containern och som för angivet unordered_multiset<V>::value_type är typ const V.

Funktionen range member (5) infogar sekvensen med elementvärden i en unordered_multiset som motsvarar varje element som adresseras av en iterator i intervallet [First, Last). Därför infogas inte Last . Funktionen end() containermedlem refererar till positionen strax efter det sista elementet i containern, till exempel infogar instruktionen m.insert(v.begin(), v.end()); alla element v i i m.

Medlemsfunktionen i initieringslistan (6) använder en initializer_list för att kopiera element till unordered_multiset.

För infogning av ett element som har konstruerats på plats, dvs. inga kopierings- eller flyttåtgärder utförs, se unordered_multiset::emplace och unordered_multiset::emplace_hint.

Ett kodexempel finns i multiset::insert.

unordered_multiset::iterator

En typ som ger en konstant vidarebefordran iterator som kan läsa element i en unordered_multiset.

typedef implementation-defined iterator;

Exempel

I exemplet för start finns ett exempel på hur du deklarerar och använder en iterator.

unordered_multiset::key_eq

Hämtar det lagrade jämförelsefunktionsobjektet.

Pred key_eq() const;

Anmärkningar

Medlemsfunktionen returnerar det lagrade jämförelsefunktionsobjektet.

Exempel

// std__unordered_set__unordered_multiset_key_eq.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    Myset::key_equal cmpfn = c1.key_eq();
    std::cout << "cmpfn('a', 'a') == "
        << std::boolalpha << cmpfn('a', 'a') << std::endl;
    std::cout << "cmpfn('a', 'b') == "
        << std::boolalpha << cmpfn('a', 'b') << std::endl;

    return (0);
}

cmpfn('a', 'a') == true
cmpfn('a', 'b') == false

unordered_multiset::key_equal

Typen av jämförelsefunktion.

typedef Pred key_equal;

Anmärkningar

Typen är en synonym för mallparametern Pred.

Exempel

// std__unordered_set__unordered_multiset_key_equal.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    Myset::key_equal cmpfn = c1.key_eq();
    std::cout << "cmpfn('a', 'a') == "
        << std::boolalpha << cmpfn('a', 'a') << std::endl;
    std::cout << "cmpfn('a', 'b') == "
        << std::boolalpha << cmpfn('a', 'b') << std::endl;

    return (0);
}

cmpfn('a', 'a') == true
cmpfn('a', 'b') == false

unordered_multiset::key_type

Typ av beställningsnyckel.

typedef Key key_type;

Anmärkningar

Typen är en synonym för mallparametern Key.

Exempel

// std__unordered_set__unordered_multiset_key_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // add a value and reinspect
    Myset::key_type key = 'd';
    Myset::value_type val = key;
    c1.insert(val);

    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
[d] [c] [b] [a]

unordered_multiset::load_factor

Räknar de genomsnittliga elementen per bucket.

float load_factor() const;

Anmärkningar

Medlemsfunktionen returnerar (float)unordered_multiset::size() / (float)unordered_multiset::bucket_count(), det genomsnittliga antalet element per bucket.

Exempel

// std__unordered_set__unordered_multiset_load_factor.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    return (0);
}

unordered_multiset::local_iterator

Typen av bucket iterator.

typedef T4 local_iterator;

Anmärkningar

Typen beskriver ett objekt som kan fungera som en vidarebefordrande iterator för en bucket. Det beskrivs här som en synonym för den implementeringsdefinierade typen T4.

Exempel

// std__unordered_set__unordered_multiset_local_iterator.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect bucket containing 'a'
    Myset::local_iterator lit = c1.begin(c1.bucket('a'));
    std::cout << "[" << *lit << "] ";

    return (0);
}

[c] [b] [a]
[a]

unordered_multiset::max_bucket_count

Hämtar det maximala antalet bucketar.

size_type max_bucket_count() const;

Anmärkningar

Medlemsfunktionen returnerar det maximala antalet bucketar som för närvarande tillåts.

Exempel

// std__unordered_set__unordered_multiset_max_bucket_count.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4

bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1

bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1

unordered_multiset::max_load_factor

Hämtar eller anger maximalt antal element per bucket.

float max_load_factor() const;

void max_load_factor(float factor);

Parameterar

faktor
Den nya maxbelastningsfaktorn.

Anmärkningar

Den första medlemsfunktionen returnerar den lagrade maxbelastningsfaktorn. Den andra medlemsfunktionen ersätter den lagrade maxbelastningsfaktorn med faktor.

Exempel

// std__unordered_set__unordered_multiset_max_load_factor.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_bucket_count() == "
        << c1.max_bucket_count() << std::endl;
    std::cout << "max_load_factor() == "
        << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4

bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 0.1

bucket_count() == 128
load_factor() == 0.0234375
max_bucket_count() == 128
max_load_factor() == 0.1

unordered_multiset::max_size

Hämtar maximal storlek för den kontrollerade sekvensen.

size_type max_size() const;

Anmärkningar

Medlemsfunktionen returnerar längden på den längsta sekvens som objektet kan styra.

Exempel

// std__unordered_set__unordered_multiset_max_size.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    std::cout << "max_size() == " << c1.max_size() << std::endl;

    return (0);
}

max_size() == 4294967295

unordered_multiset::operator=

Kopierar en hash-tabell.

unordered_multiset& operator=(const unordered_multiset& right);

unordered_multiset& operator=(unordered_multiset&& right);

Parameterar

rätt
Den unordered_multiset kopieras till unordered_multiset.

Anmärkningar

När du har raderat befintliga element i en unordered_multisetkopieras operator= eller flyttas innehållet i höger till unordered_multiset.

Exempel

// unordered_multiset_operator_as.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

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

unordered_multiset::p ointer

Typ av pekare till ett element.

typedef Alloc::pointer pointer;

Anmärkningar

Typen beskriver ett objekt som kan fungera som en pekare till ett element i den kontrollerade sekvensen.

Exempel

// std__unordered_set__unordered_multiset_pointer.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::iterator it = c1.begin();
        it != c1.end(); ++it)
        {
        Myset::key_type key = *it;
        Myset::pointer p = &key;
        std::cout << "[" << *p << "] ";
        }
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]

unordered_multiset::reference

Typen av referens till ett element.

typedef Alloc::reference reference;

Anmärkningar

Typen beskriver ett objekt som kan fungera som en referens till ett element i den kontrollerade sekvensen.

Exempel

// std__unordered_set__unordered_multiset_reference.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::iterator it = c1.begin();
        it != c1.end(); ++it)
        {
        Myset::key_type key = *it;
        Myset::reference ref = key;
        std::cout << "[" << ref << "] ";
        }
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]

unordered_multiset::rehash

Återskapar hash-tabellen.

void rehash(size_type nbuckets);

Parameterar

nbuckets
Det begärda antalet bucketar.

Anmärkningar

Medlemsfunktionen ändrar antalet bucketar som ska vara minst nbuckets och återskapar hash-tabellen efter behov.

Exempel

// std__unordered_set__unordered_multiset_rehash.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // inspect current parameters
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // change max_load_factor and redisplay
    c1.max_load_factor(0.10f);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;
    std::cout << std::endl;

    // rehash and redisplay
    c1.rehash(100);
    std::cout << "bucket_count() == " << c1.bucket_count() << std::endl;
    std::cout << "load_factor() == " << c1.load_factor() << std::endl;
    std::cout << "max_load_factor() == " << c1.max_load_factor() << std::endl;

    return (0);
}

[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_load_factor() == 4

bucket_count() == 8
load_factor() == 0.375
max_load_factor() == 0.1

bucket_count() == 128
load_factor() == 0.0234375
max_load_factor() == 0.1

unordered_multiset::size

Räknar antalet element.

size_type size() const;

Anmärkningar

Medlemsfunktionen returnerar längden på den kontrollerade sekvensen.

Exempel

// std__unordered_set__unordered_multiset_size.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // clear the container and reinspect
    c1.clear();
    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
    std::cout << std::endl;

    c1.insert('d');
    c1.insert('e');

    // display contents "[e] [d]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    std::cout << "size == " << c1.size() << std::endl;
    std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;

    return (0);
}

[c] [b] [a]
size == 0
empty() == true

[e] [d]
size == 2
empty() == false

unordered_multiset::size_type

Typen av ett osignerat avstånd mellan två element.

typedef T2 size_type;

Anmärkningar

Den osignerade heltalstypen beskriver ett objekt som kan representera längden på valfri kontrollerad sekvens. Det beskrivs här som en synonym för den implementeringsdefinierade typen T2.

Exempel

// std__unordered_set__unordered_multiset_size_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;
    Myset::size_type sz = c1.size();

    std::cout << "size == " << sz << std::endl;

    return (0);
}

size == 0

unordered_multiset::swap

Växlar innehållet i två containrar.

void swap(unordered_multiset& right);

Parameterar

rätt
Containern som ska växlas med.

Anmärkningar

Medlemsfunktionen växlar de kontrollerade sekvenserna mellan *this och höger. Om unordered_multiset::get_allocator() == right.get_allocator(), gör det det i konstant tid, genererar det endast ett undantag som ett resultat av att det lagrade egenskapsobjektet av typen Trkopieras, och det ogiltigförklarar inga referenser, pekare eller iteratorer som anger element i de två kontrollerade sekvenserna. Annars utför den ett antal elementtilldelningar och konstruktoranrop som är proportionella mot antalet element i de två kontrollerade sekvenserna.

Exempel

// std__unordered_set__unordered_multiset_swap.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    Myset c2;

    c2.insert('d');
    c2.insert('e');
    c2.insert('f');

    c1.swap(c2);

    // display contents "[f] [e] [d]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    swap(c1, c2);

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
[f] [e] [d]
[c] [b] [a]

unordered_multiset::unordered_multiset

Skapar ett containerobjekt.

unordered_multiset(
    const unordered_multiset& Right);

explicit unordered_multiset(
    size_type Bucket_count = N0,
    const Hash& Hash = Hash(),
    const Comp& Comp = Comp(),
    const Allocator& Al = Alloc());

unordered_multiset(
    unordered_multiset&& Right);

unordered_set(
    initializer_list<Type> IList);

unordered_set(
    initializer_list<Typ> IList,
    size_type Bucket_count);

unordered_set(
    initializer_list<Type> IList,
    size_type Bucket_count,
    const Hash& Hash);

unordered_set(
    initializer_list<Type> IList,
    size_type Bucket_count,
    const Hash& Hash,
    const Key& Key);

unordered_set(
    initializer_list<Type> IList,
    size_type Bucket_count,
    const Hash& Hash,
    const Key& Key,
    const Allocator& Al);

template <class InputIterator>
unordered_multiset(
    InputIterator First,
    InputIterator Last,
    size_type Bucket_count = N0,
    const Hash& Hash = Hash(),
    const Comp& Comp = Comp(),
    const Allocator& Al = Alloc());

Parameterar

InputIterator
Iteratortypen.

Al
Allokeringsobjektet som ska lagras.

Komp
Jämförelsefunktionsobjektet som ska lagras.

Hasch
Det hash-funktionsobjekt som ska lagras.

Bucket_count
Det minsta antalet bucketar.

höger
Containern som ska kopieras.

IList
Den initializer_list som ska kopieras från.

Anmärkningar

Den första konstruktorn anger en kopia av sekvensen som styrs av Höger. Den andra konstruktorn anger en tom kontrollerad sekvens. Den tredje konstruktorn infogar sekvensen med elementvärden [First, Last). Den fjärde konstruktorn anger en kopia av sekvensen genom att flytta Höger.

Alla konstruktorer initierar också flera lagrade värden. För kopieringskonstruktorn hämtas värdena från Höger. Annars:

Det minsta antalet bucketar är argumentet Bucket_count, om det finns; annars är det ett standardvärde som beskrivs här som det implementeringsdefinierade värdet N0.

Hash-funktionsobjektet är argumentet Hash, om det finns; annars är Hash()det .

Jämförelsefunktionsobjektet är argumentet Comp, om det finns; annars är Comp()det .

Allokeringsobjektet är argumentet Al, om det finns; annars är Alloc()det .

unordered_multiset::value_type

Typ av element.

typedef Key value_type;

Anmärkningar

Typen beskriver ett element i den kontrollerade sekvensen.

Exempel

// std__unordered_set__unordered_multiset_value_type.cpp
// compile with: /EHsc
#include <unordered_set>
#include <iostream>

typedef std::unordered_multiset<char> Myset;
int main()
{
    Myset c1;

    c1.insert('a');
    c1.insert('b');
    c1.insert('c');

    // display contents "[c] [b] [a]"
    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    // add a value and reinspect
    Myset::key_type key = 'd';
    Myset::value_type val = key;
    c1.insert(val);

    for (Myset::const_iterator it = c1.begin();
        it != c1.end(); ++it)
        std::cout << "[" << *it << "] ";
    std::cout << std::endl;

    return (0);
}

[c] [b] [a]
[d] [c] [b] [a]

Se även

<unordered_set>
Behållare
Trådsäkerhet i C++ Standard Library
Standardbiblioteksreferens för C++