Classe unordered_multimap
Il modello di classe descrive un oggetto che controlla una sequenza di lunghezza variabile di elementi di tipo std::pair<const Key, Ty>. La sequenza viene ordinata in modo debole da una funzione hash, che esegue il partizionamento della sequenza in un set ordinato di sottosequenze denominate bucket. In ogni bucket una funzione di confronto determina se una coppia di elementi ha un ordinamento equivalente. In ogni elemento sono archiviati due oggetti, una chiave di ordinamento e un valore. La sequenza viene rappresentata in modo da consentire la ricerca, l'inserimento e la rimozione di un elemento arbitrario mediante una serie di operazioni che possono essere indipendenti dal numero di elementi della sequenza (tempo costante), almeno quando tutti i bucket sono più o meno lunghi uguali. Nella peggiore delle ipotesi, quando tutti gli elementi si trovano in un unico bucket, il numero di operazioni è proporzionale al numero di elementi della sequenza (tempo lineare). Inoltre, l'inserimento di un elemento non invalida gli iteratori e la rimozione di un elemento invalida solo gli iteratori che fanno riferimento all'elemento rimosso.
Sintassi
template <class Key,
class Ty,
class Hash = std::hash<Key>,
class Pred = std::equal_to<Key>,
class Alloc = std::allocator<Key>>
class unordered_multimap;
Parametri
Chiave
Tipo di chiave.
Ty
Tipo mappato.
Hash
Tipo di oggetto della funzione hash.
Pred
Tipo di oggetto della funzione di confronto di uguaglianza.
Alloc
Classe Allocator.
Membri
| Definizione del tipo | Descrizione |
|---|---|
| allocator_type | Tipo di un allocatore per gestire l'archiviazione. |
| const_iterator | Tipo di un iteratore costante per la sequenza controllata. |
| const_local_iterator | Tipo di un iteratore di bucket costante per la sequenza controllata. |
| const_pointer | Tipo di un puntatore costante a un elemento. |
| const_reference | Tipo di un riferimento costante a un elemento. |
| difference_type | Tipo di una distanza Signed tra due elementi. |
| Hasher | Tipo della funzione hash. |
| iterator | Tipo di un iteratore per la sequenza controllata. |
| key_equal | Tipo della funzione di confronto. |
| key_type | Tipo di una chiave di ordinamento. |
| local_iterator | Tipo di un iteratore di bucket per la sequenza controllata. |
| mapped_type | Tipo di un valore mappato associato a ogni chiave. |
| pointer | Tipo di un puntatore a un elemento. |
| reference | Tipo di un riferimento a un elemento. |
| size_type | Tipo di una distanza Unsigned tra due elementi. |
| value_type | Tipo di un elemento. |
| Funzione membro | Descrizione |
|---|---|
| begin | Indica l'inizio della sequenza controllata. |
| Secchio | Ottiene il numero di bucket relativo a un valore della chiave. |
| bucket_count | Ottiene il numero di bucket. |
| bucket_size | Ottiene le dimensioni di un bucket. |
| cbegin | Indica l'inizio della sequenza controllata. |
| cend | Designa la fine della sequenza controllata. |
| deselezionare | Rimuove tutti gli elementi. |
| contieneC++20 | Controlla se è presente un elemento con la chiave specificata in unordered_multimap. |
| count | Trova il numero di elementi corrispondenti a una chiave specificata. |
| emplace | Aggiunge un elemento costruito sul posto. |
| emplace_hint | Aggiunge un elemento costruito sul posto, con il suggerimento. |
| empty | Verifica se sono presenti o meno degli elementi. |
| end | Designa la fine della sequenza controllata. |
| equal_range | Trova un intervallo che corrisponde a una chiave specificata. |
| erase | Rimuove gli elementi in corrispondenza delle posizioni specificate. |
| find | Trova un elemento che corrisponde a una chiave specificata. |
| get_allocator | Ottiene l'oggetto allocatore archiviato. |
| hash_function | Ottiene l'oggetto della funzione hash archiviato. |
| insert | Aggiunge elementi. |
| key_eq | Ottiene l'oggetto archiviato della funzione di confronto. |
| load_factor | Conta il numero medio di elementi per bucket. |
| max_bucket_count | Ottiene il numero massimo di bucket. |
| max_load_factor | Ottiene o imposta il numero massimo di elementi per bucket. |
| max_size | Ottiene la dimensione massima della sequenza controllata. |
| Rimaneggiamento | Ricompila la tabella hash. |
| size | Conta il numero di elementi. |
| swap | Scambia il contenuto di due contenitori. |
| unordered_multimap | Costruisce un oggetto contenitore. |
| Operatore | Descrizione |
|---|---|
| unordered_multimap::operator= | Copia una tabella hash. |
Osservazioni:
L'oggetto ordina la sequenza da esso controllata chiamando due oggetti archiviati, un oggetto della funzione di confronto di tipo unordered_multimap::key_equal e un oggetto della funzione hash di tipo unordered_multimap::hasher. È possibile accedere al primo oggetto archiviato chiamando la funzione membro unordered_multimap::key_eq() ed è possibile accedere al secondo oggetto archiviato chiamando la funzione membro unordered_multimap::hash_function(). In particolare, per tutti i valori X e Y di tipo Key, la chiamata a key_eq()(X, Y) restituisce true solo se i valori dei due argomenti hanno un ordinamento equivalente; la chiamata a hash_function()(keyval) produce una distribuzione di valori di tipo size_t. A differenza del modello di classe unordered_map Class, un oggetto di tipo unordered_multimap non garantisce che key_eq()(X, Y) sia sempre false per due elementi della sequenza controllata. Le chiavi non devono essere necessariamente univoche.
L'oggetto consente inoltre di archiviare un fattore di carico massimo che specifica il numero medio massimo di elementi per bucket desiderato. Se l'inserimento di un elemento comporta il superamento del fattore di carico massimo da parte di unordered_multimap::load_factor(), il contenitore aumenta il numero dei bucket e ricompila la tabella hash in base alle necessità.
L'ordine effettivo degli elementi nella sequenza controllata dipende dalla funzione hash, dalla funzione di confronto, dall'ordine di inserimento, dal fattore di carico massimo e dal numero corrente di bucket. Non è in genere possibile prevedere l'ordine degli elementi nella sequenza selezionata. Si può tuttavia avere sempre la certezza dell'adiacenza dei subset di elementi con un ordinamento equivalente nella sequenza controllata.
L'oggetto alloca e libera la memoria per la sequenza da esso controllata tramite un oggetto allocatore archiviato di tipo unordered_multimap::allocator_type. Un oggetto allocatore di questo tipo deve avere la stessa interfaccia esterna di un oggetto di tipo allocator. Si noti che l'oggetto allocatore archiviato non viene copiato dopo l'assegnazione dell'oggetto contenitore.
Requisiti
Intestazione:<unordered_map>
Spazio dei nomi: std
unordered_multimap::allocator_type
Tipo di un allocatore per gestire l'archiviazione.
typedef Alloc allocator_type;
Osservazioni:
Il tipo è un sinonimo del parametro di modello Alloc.
Esempio
// std__unordered_map__unordered_multimap_allocator_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
typedef std::allocator<std::pair<const char, int> > Myalloc;
int main()
{
Mymap c1;
Mymap::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_multimap::begin
Designa l'inizio della sequenza controllata o di un bucket.
iterator begin();
const_iterator begin() const;
local_iterator begin(size_type nbucket);
const_local_iterator begin(size_type nbucket) const;
Parametri
nbucket
Numero di bucket.
Osservazioni:
Le prime due funzioni membro restituiscono un iteratore in avanti che punta al primo elemento della sequenza (o appena oltre la fine di una sequenza vuota). Le ultime due funzioni membro restituiscono un iteratore in avanti che punta al primo elemento del bucket nbucket (o appena oltre la fine di un bucket vuoto).
Esempio
// std__unordered_map__unordered_multimap_begin.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// inspect first two items " [c 3] [b 2]"
Mymap::iterator it2 = c1.begin();
std::cout << " [" << it2->first << ", " << it2->second << "]";
++it2;
std::cout << " [" << it2->first << ", " << it2->second << "]";
std::cout << std::endl;
// inspect bucket containing 'a'
Mymap::const_local_iterator lit = c1.begin(c1.bucket('a'));
std::cout << " [" << lit->first << ", " << lit->second << "]";
return (0);
}
[c, 3] [b, 2] [a, 1]
[c, 3] [b, 2]
[a, 1]
unordered_multimap::bucket
Ottiene il numero di bucket relativo a un valore della chiave.
size_type bucket(const Key& keyval) const;
Parametri
keyval
Valore della chiave da mappare.
Osservazioni:
La funzione membro restituisce il numero di bucket attualmente corrispondente al valore della chiave keyval.
Esempio
// std__unordered_map__unordered_multimap_bucket.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// display buckets for keys
Mymap::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, 3] [b, 2] [a, 1]
bucket('a') == 7
bucket_size(7) == 1
unordered_multimap::bucket_count
Ottiene il numero di bucket.
size_type bucket_count() const;
Osservazioni:
La funzione membro restituisce il numero corrente di bucket.
Esempio
// std__unordered_map__unordered_multimap_bucket_count.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
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, 3] [b, 2] [a, 1]
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_multimap::bucket_size
Ottiene le dimensioni di un bucket.
size_type bucket_size(size_type nbucket) const;
Parametri
nbucket
Numero di bucket.
Osservazioni:
Le funzioni membro restituiscono le dimensioni del numero di bucket nbucket.
Esempio
// std__unordered_map__unordered_multimap_bucket_size.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// display buckets for keys
Mymap::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, 3] [b, 2] [a, 1]
bucket('a') == 7
bucket_size(7) == 1
unordered_multimap::cbegin
Restituisce un iteratore const che punta al primo elemento dell'intervallo.
const_iterator cbegin() const;
Valore restituito
Iteratore di accesso in avanti const che punta al primo elemento dell'intervallo o alla posizione oltre la fine di un intervallo vuoto (per un intervallo vuoto, cbegin() == cend()).
Osservazioni:
Con il valore restituito di cbegin, gli elementi dell'intervallo non possono essere modificati.
È possibile usare questa funzione membro anziché la funzione membro begin() per garantire che il valore restituito sia const_iterator. In genere, viene usata insieme alla parola chiave di deduzione di tipo auto, come illustrato nell'esempio seguente. Nell'esempio, si consideri Container come un contenitore (non const) modificabile di qualsiasi tipo che supporta begin() e cbegin().
auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();
// i2 is Container<T>::const_iterator
unordered_multimap::cend
Restituisce un iteratore const che punta alla posizione oltre l'ultimo elemento di un intervallo.
const_iterator cend() const;
Valore restituito
Iteratore di accesso in avanti const che punta oltre la fine dell'intervallo.
Osservazioni:
cend viene utilizzato per verificare se un iteratore ha superato la fine del relativo intervallo.
È possibile usare questa funzione membro anziché la funzione membro end() per garantire che il valore restituito sia const_iterator. In genere, viene usata insieme alla parola chiave di deduzione di tipo auto, come illustrato nell'esempio seguente. Nell'esempio, si consideri Container come un contenitore (non const) modificabile di qualsiasi tipo che supporta end() e cend().
auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();
// i2 is Container<T>::const_iterator
Non è consigliabile dereferenziare il valore restituito da cend.
unordered_multimap::clear
Rimuove tutti gli elementi.
void clear();
Osservazioni:
La funzione membro chiama unordered_multimap::erase(unordered_multimap::begin(),unordered_multimap::end()).
Esempio
// std__unordered_map__unordered_multimap_clear.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
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(Mymap::value_type('d', 4));
c1.insert(Mymap::value_type('e', 5));
// display contents " [e 5] [d 4]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
std::cout << "size == " << c1.size() << std::endl;
std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
size == 0
empty() == true
[e, 5] [d, 4]
size == 2
empty() == false
unordered_multimap::const_iterator
Tipo di un iteratore costante per la sequenza controllata.
typedef T1 const_iterator;
Osservazioni:
Il tipo descrive un oggetto che può essere usato come iteratore costante in avanti per la sequenza controllata. Qui è descritto come sinonimo del tipo definito dall'implementazione T1.
Esempio
// std__unordered_map__unordered_multimap_const_iterator.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
unordered_multimap::const_local_iterator
Tipo di un iteratore di bucket costante per la sequenza controllata.
typedef T5 const_local_iterator;
Osservazioni:
Il tipo descrive un oggetto che può essere usato come iteratore in avanti costante per un bucket. Qui è descritto come sinonimo del tipo definito dall'implementazione T5.
Esempio
// std__unordered_map__unordered_multimap_const_local_iterator.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// inspect bucket containing 'a'
Mymap::const_local_iterator lit = c1.begin(c1.bucket('a'));
std::cout << " [" << lit->first << ", " << lit->second << "]";
return (0);
}
[c, 3] [b, 2] [a, 1]
[a, 1]
unordered_multimap::const_pointer
Tipo di un puntatore costante a un elemento.
typedef Alloc::const_pointer const_pointer;
Osservazioni:
Il tipo descrive un oggetto che può essere usato come puntatore costante a un elemento della sequenza controllata.
Esempio
// std__unordered_map__unordered_multimap_const_pointer.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::iterator it = c1.begin();
it != c1.end(); ++it)
{
Mymap::const_pointer p = &*it;
std::cout << " [" << p->first << ", " << p->second << "]";
}
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
unordered_multimap::const_reference
Tipo di un riferimento costante a un elemento.
typedef Alloc::const_reference const_reference;
Osservazioni:
Il tipo descrive un oggetto che può essere usato come riferimento costante a un elemento della sequenza controllata.
Esempio
// std__unordered_map__unordered_multimap_const_reference.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::iterator it = c1.begin();
it != c1.end(); ++it)
{
Mymap::const_reference ref = *it;
std::cout << " [" << ref.first << ", " << ref.second << "]";
}
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
unordered_multimap::contains
Controlla se è presente un elemento con la chiave specificata in unordered_multimap.
bool contains(const Key& key) const;
template<class K> bool contains(const K& key) const;
Parametri
K
Tipo di chiave.
key
Valore della chiave dell'elemento da cercare.
Valore restituito
true se l'elemento viene trovato nel contenitore; false Altrimenti.
Osservazioni:
contains() è una novità di C++20. Per usarlo, specificare l'opzione del compilatore /std:c++20 o versione successiva.
template<class K> bool contains(const K& key) const partecipa alla risoluzione dell'overload solo se key_compare è trasparente.
Esempio
// Requires /std:c++20 or /std:c++latest
#include <unordered_map>
#include <iostream>
int main()
{
std::unordered_multimap<int, bool> theUnorderedMultimap = {{0, false}, {1,true}};
std::cout << std::boolalpha; // so booleans show as 'true' or 'false'
std::cout << theUnorderedMultimap.contains(1) << '\n';
std::cout << theUnorderedMultimap.contains(2) << '\n';
return 0;
}
true
false
unordered_multimap::count
Trova il numero di elementi corrispondenti a una chiave specificata.
size_type count(const Key& keyval) const;
Parametri
keyval
Valore della chiave da cercare.
Osservazioni:
La funzione membro restituisce il numero di elementi nell'intervallo delimitato da unordered_multimap::equal_range(keyval).
Esempio
// std__unordered_map__unordered_multimap_count.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
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, 3] [b, 2] [a, 1]
count('A') == 0
count('b') == 1
count('C') == 0
unordered_multimap::difference_type
Tipo di una distanza Signed tra due elementi.
typedef T3 difference_type;
Osservazioni:
Il tipo di valore integer con segno descrive un oggetto che può rappresentare la differenza tra gli indirizzi di due elementi qualsiasi della sequenza controllata. Qui è descritto come sinonimo del tipo definito dall'implementazione T3.
Esempio
// std__unordered_map__unordered_multimap_difference_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// compute positive difference
Mymap::difference_type diff = 0;
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
++diff;
std::cout << "end()-begin() == " << diff << std::endl;
// compute negative difference
diff = 0;
for (Mymap::const_iterator it = c1.end();
it != c1.begin(); --it)
--diff;
std::cout << "begin()-end() == " << diff << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
end()-begin() == 3
begin()-end() == -3
unordered_multimap::emplace
Inserisce un elemento costruito in locale (senza che vengano eseguite operazioni di copia o di spostamento), con un suggerimento sulla posizione.
template <class... Args>
iterator emplace(Args&&... args);
Parametri
args
Argomenti inoltrati per costruire un elemento da inserire nell'oggetto unordered_multimap.
Valore restituito
Iteratore all'elemento appena inserito.
Osservazioni:
Questa funzione non invalida alcun riferimento a elementi del contenitore, ma potrebbe invalidare tutti gli iteratori per il contenitore.
L'oggetto value_type di un elemento è una coppia, pertanto il valore di un elemento sarà una coppia ordinata in cui il primo componente equivale al valore della chiave e il secondo componente equivale al valore dei dati dell'elemento.
Durante l'inserimento, se viene generata un'eccezione che non si trova nella funzione hash del contenitore, quest'ultimo non viene modificato. Se l'eccezione viene generata nella funzione hash, il risultato non sarà definito.
Per un esempio di codice, vedere multimap::emplace.
unordered_multimap::emplace_hint
Inserisce un elemento costruito in locale (senza che vengano eseguite operazioni di copia o di spostamento), con un suggerimento sulla posizione.
template <class... Args>
iterator emplace_hint(
const_iterator where,
Args&&... args);
Parametri
args
Argomenti inoltrati per costruire un elemento da inserire nell'oggetto unordered.
where
Suggerimento sulla posizione per avviare la ricerca del punto di inserimento corretto.
Valore restituito
Iteratore all'elemento appena inserito.
Osservazioni:
Questa funzione non invalida alcun riferimento a elementi del contenitore, ma potrebbe invalidare tutti gli iteratori per il contenitore.
Durante l'inserimento, se viene generata un'eccezione che non si trova nella funzione hash del contenitore, quest'ultimo non viene modificato. Se l'eccezione viene generata nella funzione hash, il risultato non sarà definito.
L'oggetto value_type di un elemento è una coppia, pertanto il valore di un elemento sarà una coppia ordinata in cui il primo componente equivale al valore della chiave e il secondo componente equivale al valore dei dati dell'elemento.
Per un esempio di codice, vedere map::emplace_hint.
unordered_multimap::empty
Verifica se sono presenti o meno degli elementi.
bool empty() const;
Osservazioni:
La funzione membro restituisce true per una sequenza controllata vuota.
Esempio
// std__unordered_map__unordered_multimap_empty.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
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(Mymap::value_type('d', 4));
c1.insert(Mymap::value_type('e', 5));
// display contents " [e 5] [d 4]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
std::cout << "size == " << c1.size() << std::endl;
std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
size == 0
empty() == true
[e, 5] [d, 4]
size == 2
empty() == false
unordered_multimap::end
Designa la fine della sequenza controllata.
iterator end();
const_iterator end() const;
local_iterator end(size_type nbucket);
const_local_iterator end(size_type nbucket) const;
Parametri
nbucket
Numero di bucket.
Osservazioni:
Le prime due funzioni membro restituiscono un iteratore in avanti che punta poco oltre la fine della sequenza. Le ultime due funzioni membro restituiscono un iteratore in avanti che punta appena oltre la fine del bucket nbucket.
Esempio
// std__unordered_map__unordered_multimap_end.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// inspect last two items " [a 1] [b 2]"
Mymap::iterator it2 = c1.end();
--it2;
std::cout << " [" << it2->first << ", " << it2->second << "]";
--it2;
std::cout << " [" << it2->first << ", " << it2->second << "]";
std::cout << std::endl;
// inspect bucket containing 'a'
Mymap::const_local_iterator lit = c1.end(c1.bucket('a'));
--lit;
std::cout << " [" << lit->first << ", " << lit->second << "]";
return (0);
}
[c, 3] [b, 2] [a, 1]
[a, 1] [b, 2]
[a, 1]
unordered_multimap::equal_range
Trova un intervallo che corrisponde a una chiave specificata.
std::pair<iterator, iterator>
equal_range(const Key& keyval);
std::pair<const_iterator, const_iterator>
equal_range(const Key& keyval) const;
Parametri
keyval
Valore della chiave da cercare.
Osservazioni:
La funzione membro restituisce una coppia di iteratori X in modo che [X.first, X.second) delimiti solo gli elementi della sequenza controllata con ordinamento equivalente con keyval. Se tali elementi non esistono, entrambi gli iteratori sono end().
Esempio
// std__unordered_map__unordered_multimap_equal_range.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// display results of failed search
std::pair<Mymap::iterator, Mymap::iterator> pair1 =
c1.equal_range('x');
std::cout << "equal_range('x'):";
for (; pair1.first != pair1.second; ++pair1.first)
std::cout << " [" << pair1.first->first
<< ", " << pair1.first->second << "]";
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->first
<< ", " << pair1.first->second << "]";
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
equal_range('x'):
equal_range('b'): [b, 2]
unordered_multimap::erase
Rimuove un elemento o un intervallo di elementi di un oggetto unordered_multimap dalle posizioni specificate oppure rimuove gli elementi che corrispondono a una chiave specificata.
iterator erase(
const_iterator Where);
iterator erase(
const_iterator First,
const_iterator Last);
size_type erase(
const key_type& Key);
Parametri
Where
Posizione dell'elemento che deve essere rimosso.
First
Posizione del primo elemento che deve essere rimosso.
Ultimo
Posizione immediatamente successiva all'ultimo elemento che deve essere rimosso.
Chiave
Valore della chiave dell'elemento che deve essere rimosso.
Valore restituito
Per le prime due funzioni membro, iteratore bidirezionale che definisce il primo elemento rimanente oltre gli eventuali elementi rimossi o elemento che rappresenta la fine dell'oggetto map se tali elementi non sono presenti.
Per la terza funzione membro, restituisce il numero di elementi rimossi dall'oggetto unordered_multimap.
Osservazioni:
Per un esempio di codice, vedere map::erase.
unordered_multimap::find
Trova un elemento che corrisponde a una chiave specificata.
const_iterator find(const Key& keyval) const;
Parametri
keyval
Valore della chiave da cercare.
Osservazioni:
La funzione membro restituisce unordered_multimap::equal_range(keyval).first.
Esempio
// std__unordered_map__unordered_multimap_find.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
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
Mymap::iterator it = c1.find('b');
std::cout << "find('b') == "
<< std::boolalpha << (it != c1.end())
<< ": [" << it->first << ", " << it->second << "]" << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
find('A') == false
find('b') == true: [b, 2]
unordered_multimap::get_allocator
Ottiene l'oggetto allocatore archiviato.
Alloc get_allocator() const;
Osservazioni:
La funzione membro restituisce l'oggetto allocatore archiviato.
Esempio
// std__unordered_map__unordered_multimap_get_allocator.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
typedef std::allocator<std::pair<const char, int> > Myalloc;
int main()
{
Mymap c1;
Mymap::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_multimap::hash_function
Ottiene l'oggetto della funzione hash archiviato.
Hash hash_function() const;
Osservazioni:
La funzione membro restituisce l'oggetto archiviato della funzione hash.
Esempio
// std__unordered_map__unordered_multimap_hash_function.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
Mymap::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_multimap::hasher
Tipo della funzione hash.
typedef Hash hasher;
Osservazioni:
Il tipo è un sinonimo del parametro di modello Hash.
Esempio
// std__unordered_map__unordered_multimap_hasher.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
Mymap::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_multimap::insert
Inserisce un elemento o un intervallo di elementi in un oggetto unordered_multimap.
// (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);
Parametri
Val
Valore di un elemento da inserire in unordered_multimap.
Where
Posizione in cui iniziare a cercare il punto di inserimento corretto.
ValTy
Parametro modello che specifica il tipo di argomento che il unordered_multimap può usare per costruire un elemento di value_type e forwards perfect-forwards Val come argomento.
First
Posizione del primo elemento da copiare.
Ultimo
Posizione immediatamente dopo l'ultimo elemento da copiare.
InputIterator
Argomento della funzione modello che soddisfa i requisiti di un iteratore di input che punta agli elementi di un tipo utilizzabili per costruire oggetti value_type.
IList
Oggetto initializer_list da cui copiare gli elementi.
Valore restituito
Le funzioni membro di inserimento a elemento singolo, (1) e (2), restituiscono un iteratore alla posizione in cui il nuovo elemento è stato inserito in unordered_multimap.
Le funzioni membro a elemento singolo con suggerimento, (3) e (4), restituiscono un iteratore che fa riferimento alla posizione in cui il nuovo elemento è stato inserito in unordered_multimap.
Osservazioni:
Questa funzione non invalida alcun puntatore o riferimento, ma potrebbe invalidare tutti gli iteratori per il contenitore.
Se viene generata un'eccezione durante l'inserimento di un solo elemento, ma l'eccezione non si manifesta nella funzione hash del contenitore, lo stato del contenitore non verrà modificato. Se l'eccezione viene generata nella funzione hash, il risultato non sarà definito. Se viene generata un'eccezione durante l'inserimento di più elementi, il contenitore viene lasciato in uno stato non specificato ma comunque valido.
L'oggetto value_type di un contenitore è un typedef appartenente al contenitore e, per map, map<K, V>::value_type è pair<const K, V>. Il valore di un elemento è una coppia ordinata in cui il primo componente equivale al valore della chiave e il secondo componente equivale al valore dati dell'elemento.
La funzione membro dell'intervallo (5) inserisce la sequenza di valori di elemento in un unordered_multimap che corrisponde a ogni elemento indirizzato da un iteratore nell'intervallo [First, Last). Pertanto, Last non viene inserito. La funzione membro di contenitore end() fa riferimento alla posizione immediatamente dopo l'ultimo elemento nel contenitore. L'istruzione m.insert(v.begin(), v.end());, ad esempio, cerca di inserire tutti gli elementi di v in m.
La funzione membro di elenco di inizializzatori (6) usa un oggetto initializer_list per copiare gli elementi nell'oggetto unordered_multimap.
Per l'inserimento di un elemento costruito sul posto, ovvero senza operazioni di copia o spostamento, vedere unordered_multimap::emplace e unordered_multimap::emplace_hint.
Per un esempio di codice, vedere multimap::insert.
unordered_multimap::iterator
Tipo di un iteratore per la sequenza controllata.
typedef T0 iterator;
Osservazioni:
Il tipo descrive un oggetto che può essere usato come iteratore in avanti per la sequenza controllata. Qui è descritto come sinonimo del tipo definito dall'implementazione T0.
Esempio
// std__unordered_map__unordered_multimap_iterator.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
unordered_multimap::key_eq
Ottiene l'oggetto archiviato della funzione di confronto.
Pred key_eq() const;
Osservazioni:
La funzione membro restituisce l'oggetto archiviato della funzione di confronto.
Esempio
// std__unordered_map__unordered_multimap_key_eq.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
Mymap::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_multimap::key_equal
Tipo della funzione di confronto.
typedef Pred key_equal;
Osservazioni:
Il tipo è un sinonimo del parametro di modello Pred.
Esempio
// std__unordered_map__unordered_multimap_key_equal.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
Mymap::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_multimap::key_type
Tipo di una chiave di ordinamento.
typedef Key key_type;
Osservazioni:
Il tipo è un sinonimo del parametro di modello Key.
Esempio
// std__unordered_map__unordered_multimap_key_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// add a value and reinspect
Mymap::key_type key = 'd';
Mymap::mapped_type mapped = 4;
Mymap::value_type val = Mymap::value_type(key, mapped);
c1.insert(val);
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
[d, 4] [c, 3] [b, 2] [a, 1]
unordered_multimap::load_factor
Conta il numero medio di elementi per bucket.
float load_factor() const;
Osservazioni:
La funzione membro restituisce (float)unordered_multimap::size() / (float)unordered_multimap::bucket_count(), il numero medio di elementi per bucket.
Esempio
// std__unordered_map__unordered_multimap_load_factor.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
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_multimap::local_iterator
Tipo di iteratore di bucket.
typedef T4 local_iterator;
Osservazioni:
Il tipo descrive un oggetto che può essere usato come iteratore in avanti per un bucket. Qui è descritto come sinonimo del tipo definito dall'implementazione T4.
Esempio
// std__unordered_map__unordered_multimap_local_iterator.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// inspect bucket containing 'a'
Mymap::local_iterator lit = c1.begin(c1.bucket('a'));
std::cout << " [" << lit->first << ", " << lit->second << "]";
return (0);
}
[c, 3] [b, 2] [a, 1]
[a, 1]
unordered_multimap::mapped_type
Tipo di un valore mappato associato a ogni chiave.
typedef Ty mapped_type;
Osservazioni:
Il tipo è un sinonimo del parametro di modello Ty.
Esempio
// std__unordered_map__unordered_multimap_mapped_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// add a value and reinspect
Mymap::key_type key = 'd';
Mymap::mapped_type mapped = 4;
Mymap::value_type val = Mymap::value_type(key, mapped);
c1.insert(val);
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
[d, 4] [c, 3] [b, 2] [a, 1]
unordered_multimap::max_bucket_count
Ottiene il numero massimo di bucket.
size_type max_bucket_count() const;
Osservazioni:
La funzione membro restituisce il numero massimo di bucket attualmente consentiti.
Esempio
// std__unordered_map__unordered_multimap_max_bucket_count.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
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, 3] [b, 2] [a, 1]
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_multimap::max_load_factor
Ottiene o imposta il numero massimo di elementi per bucket.
float max_load_factor() const;
void max_load_factor(float factor);
Parametri
Fattore
Nuovo fattore di carico massimo.
Osservazioni:
La prima funzione membro restituisce il fattore di carico massimo archiviato. La seconda funzione membro sostituisce il fattore di carico massimo archiviato con il fattore .
Esempio
// std__unordered_map__unordered_multimap_max_load_factor.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
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, 3] [b, 2] [a, 1]
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_multimap::max_size
Ottiene la dimensione massima della sequenza controllata.
size_type max_size() const;
Osservazioni:
La funzione membro restituisce la lunghezza della sequenza più lunga che l'oggetto può controllare.
Esempio
// std__unordered_map__unordered_multimap_max_size.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
std::cout << "max_size() == " << c1.max_size() << std::endl;
return (0);
}
max_size() == 536870911
unordered_multimap::operator=
Copia una tabella hash.
unordered_multimap& operator=(const unordered_multimap& right);
unordered_multimap& operator=(unordered_multimap&& right);
Parametri
right
Oggetto unordered_multimap copiato in unordered_multimap.
Osservazioni:
Dopo aver cancellato tutti gli elementi esistenti in un unordered_multimap, operator= copia o sposta il contenuto di destra nella unordered_multimap.
Esempio
// unordered_multimap_operator_as.cpp
// compile with: /EHsc
#include <unordered_multimap>
#include <iostream>
int main( )
{
using namespace std;
unordered_multimap<int, int> v1, v2, v3;
unordered_multimap<int, int>::iterator iter;
v1.insert(pair<int, int>(1, 10));
cout << "v1 = " ;
for (iter = v1.begin(); iter != v1.end(); iter++)
cout << iter->second << " ";
cout << endl;
v2 = v1;
cout << "v2 = ";
for (iter = v2.begin(); iter != v2.end(); iter++)
cout << iter->second << " ";
cout << endl;
// move v1 into v2
v2.clear();
v2 = move(v1);
cout << "v2 = ";
for (iter = v2.begin(); iter != v2.end(); iter++)
cout << iter->second << " ";
cout << endl;
}
unordered_multimap::pointer
Tipo di un puntatore a un elemento.
typedef Alloc::pointer pointer;
Osservazioni:
Il tipo descrive un oggetto che può essere usato come puntatore a un elemento della sequenza controllata.
Esempio
// std__unordered_map__unordered_multimap_pointer.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::iterator it = c1.begin();
it != c1.end(); ++it)
{
Mymap::pointer p = &*it;
std::cout << " [" << p->first << ", " << p->second << "]";
}
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
unordered_multimap::reference
Tipo di un riferimento a un elemento.
typedef Alloc::reference reference;
Osservazioni:
Il tipo descrive un oggetto che può essere usato come riferimento a un elemento della sequenza controllata.
Esempio
// std__unordered_map__unordered_multimap_reference.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::iterator it = c1.begin();
it != c1.end(); ++it)
{
Mymap::reference ref = *it;
std::cout << " [" << ref.first << ", " << ref.second << "]";
}
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
unordered_multimap::rehash
Ricompila la tabella hash.
void rehash(size_type nbuckets);
Parametri
nbuckets
Numero di bucket richiesto.
Osservazioni:
La funzione membro modifica il numero di bucket in modo che siano almeno nbucket e ricompila la tabella hash in base alle esigenze.
Esempio
// std__unordered_map__unordered_multimap_rehash.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
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, 3] [b, 2] [a, 1]
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_multimap::size
Conta il numero di elementi.
size_type size() const;
Osservazioni:
La funzione membro restituisce la lunghezza della sequenza controllata.
Esempio
// std__unordered_map__unordered_multimap_size.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
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(Mymap::value_type('d', 4));
c1.insert(Mymap::value_type('e', 5));
// display contents " [e 5] [d 4]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
std::cout << "size == " << c1.size() << std::endl;
std::cout << "empty() == " << std::boolalpha << c1.empty() << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
size == 0
empty() == true
[e, 5] [d, 4]
size == 2
empty() == false
unordered_multimap::size_type
Tipo di una distanza Unsigned tra due elementi.
typedef T2 size_type;
Osservazioni:
Il tipo Unsigned Integer descrive un oggetto che può rappresentare la lunghezza di una sequenza controllata. Qui è descritto come sinonimo del tipo definito dall'implementazione T2.
Esempio
// std__unordered_map__unordered_multimap_size_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
Mymap::size_type sz = c1.size();
std::cout << "size == " << sz << std::endl;
return (0);
}
size == 0
unordered_multimap::swap
Scambia il contenuto di due contenitori.
void swap(unordered_multimap& right);
Parametri
right
Contenitore con cui eseguire lo scambio.
Osservazioni:
La funzione membro scambia le sequenze controllate tra *this e destra. Se unordered_multimap::get_allocator() == right.get_allocator(), esegue l'operazione in un tempo costante, genera un'eccezione solo in seguito alla copia dell'oggetto traits archiviato di tipo Tr e non invalida alcun riferimento, puntatore o iteratore che definisce gli elementi nelle due sequenze controllate. In caso contrario, esegue un numero di assegnazioni di elementi e chiamate al costruttore proporzionale al numero di elementi nelle due sequenze controllate.
Esempio
// std__unordered_map__unordered_multimap_swap.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
Mymap c2;
c2.insert(Mymap::value_type('d', 4));
c2.insert(Mymap::value_type('e', 5));
c2.insert(Mymap::value_type('f', 6));
c1.swap(c2);
// display contents " [f 6] [e 5] [d 4]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
swap(c1, c2);
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
[f, 6] [e, 5] [d, 4]
[c, 3] [b, 2] [a, 1]
unordered_multimap::unordered_multimap
Costruisce un oggetto contenitore.
unordered_multimap(
const unordered_multimap& Right);
explicit unordered_multimap(
size_type Bucket_count = N0,
const Hash& Hash = Hash(),
const Comp& Comp = Pred(),
const Allocator& Al = Alloc());
unordered_multimap(
unordered_multimap&& Right);
unordered_multimap(
initializer_list<Type> IList);
unordered_multimap(
initializer_list<Type> IList,
size_type Bucket_count);
unordered_multimap(
initializer_list<Type> IList,
size_type Bucket_count,
const Hash& Hash);
unordered_multimap(
initializer_list<Type> IList,
size_type Bucket_count,
const Hash& Hash,
const Key& Key);
unordered_multimap(
initializer_list<Type> IList,
size_type Bucket_count,
const Hash& Hash,
const Key& Key,
const Allocator& Al);
template <class InputIterator>
unordered_multimap(
InputIterator first,
InputIterator last,
size_type Bucket_count = N0,
const Hash& Hash = Hash(),
const Comp& Comp = Pred(),
const Allocator& Al = Alloc());
Parametri
InputIterator
Tipo di iteratore.
Al
Oggetto allocatore da archiviare.
Comp
Oggetto della funzione di confronto da archiviare.
Hash
Oggetto della funzione hash da archiviare.
Bucket_count
Numero minimo di bucket.
Right
Contenitore da copiare.
IList
initializer_list da cui copiare gli elementi.
Osservazioni:
Il primo costruttore specifica una copia della sequenza controllata da Right. Il secondo costruttore specifica una sequenza controllata vuota. Il terzo costruttore specifica una copia della sequenza spostando a destra. Il quarto, il quinto, il sesto, il settimo e l'ottavo costruttore usano una initializer_list per i membri. Il nono costruttore inserisce la sequenza di valori degli elementi [First, Last).
Tutti i costruttori inizializzano inoltre diversi valori archiviati. Per il costruttore di copia, i valori vengono ottenuti da Right. Altrimenti:
Il numero minimo di bucket è l'argomento Bucket_count, se presente; in caso contrario, è un valore predefinito descritto qui come valore N0definito dall'implementazione .
L'oggetto funzione hash è l'argomento Hash, se presente; in caso contrario, è Hash().
L'oggetto funzione di confronto è l'argomento Comp, se presente; in caso contrario, è Pred().
L'oggetto allocatore è l'argomento Al, se presente; in caso contrario, è Alloc().
Esempio
// std__unordered_map__unordered_multimap_construct.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
using namespace std;
using Mymap = unordered_multimap<char, int> ;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (const auto& c : c1) {
cout << " [" << c.first << ", " << c.second << "]";
}
cout << endl;
Mymap c2(8,
hash<char>(),
equal_to<char>(),
allocator<pair<const char, int> >());
c2.insert(Mymap::value_type('d', 4));
c2.insert(Mymap::value_type('e', 5));
c2.insert(Mymap::value_type('f', 6));
// display contents " [f 6] [e 5] [d 4]"
for (const auto& c : c2) {
cout << " [" << c.first << ", " << c.second << "]";
}
cout << endl;
Mymap c3(c1.begin(),
c1.end(),
8,
hash<char>(),
equal_to<char>(),
allocator<pair<const char, int> >());
// display contents " [c 3] [b 2] [a 1]"
for (const auto& c : c3) {
cout << " [" << c.first << ", " << c.second << "]";
}
cout << endl;
Mymap c4(move(c3));
// display contents " [c 3] [b 2] [a 1]"
for (const auto& c : c4) {
cout << " [" << c.first << ", " << c.second << "]";
}
cout << endl;
// Construct with an initializer_list
unordered_multimap<int, char> c5({ { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } });
for (const auto& c : c5) {
cout << " [" << c.first << ", " << c.second << "]";
}
cout << endl;
// Initializer_list plus size
unordered_multimap<int, char> c6({ { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } }, 4);
for (const auto& c : c1) {
cout << " [" << c.first << ", " << c.second << "]";
}
cout << endl;
// Initializer_list plus size and hash
unordered_multimap<int, char, hash<char>> c7(
{ { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } },
4,
hash<char>()
);
for (const auto& c : c1) {
cout << " [" << c.first << ", " << c.second << "]";
}
cout << endl;
// Initializer_list plus size, hash, and key_equal
unordered_multimap<int, char, hash<char>, equal_to<char>> c8(
{ { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } },
4,
hash<char>(),
equal_to<char>()
);
for (const auto& c : c1) {
cout << " [" << c.first << ", " << c.second << "]";
}
cout << endl;
// Initializer_list plus size, hash, key_equal, and allocator
unordered_multimap<int, char, hash<char>, equal_to<char>> c9(
{ { 5, 'g' }, { 6, 'h' }, { 7, 'i' }, { 8, 'j' } },
4,
hash<char>(),
equal_to<char>(),
allocator<pair<const char, int> >()
);
for (const auto& c : c1) {
cout << " [" << c.first << ", " << c.second << "]";
}
cout << endl;
}
[a, 1] [b, 2] [c, 3] [d, 4] [e, 5] [f, 6] [a, 1] [b, 2] [c, 3] [a, 1] [b, 2] [c, 3] [5, g] [6, h] [7, i] [8, j] [a, 1] [b, 2] [c, 3] [a, 1] [b, 2] [c, 3] [a, 1] [b, 2] [c, 3] [a, 1] [b, 2] [c, 3] [c, 3] [b, 2] [a, 1]
[f, 6] [e, 5] [d, 4]
[c, 3] [b, 2] [a, 1]
[c, 3] [b, 2] [a, 1]
unordered_multimap::value_type
Tipo di un elemento.
typedef std::pair<const Key, Ty> value_type;
Osservazioni:
Il tipo descrive un elemento nella sequenza controllata.
Esempio
// std__unordered_map__unordered_multimap_value_type.cpp
// compile with: /EHsc
#include <unordered_map>
#include <iostream>
typedef std::unordered_multimap<char, int> Mymap;
int main()
{
Mymap c1;
c1.insert(Mymap::value_type('a', 1));
c1.insert(Mymap::value_type('b', 2));
c1.insert(Mymap::value_type('c', 3));
// display contents " [c 3] [b 2] [a 1]"
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
// add a value and reinspect
Mymap::key_type key = 'd';
Mymap::mapped_type mapped = 4;
Mymap::value_type val = Mymap::value_type(key, mapped);
c1.insert(val);
for (Mymap::const_iterator it = c1.begin();
it != c1.end(); ++it)
std::cout << " [" << it->first << ", " << it->second << "]";
std::cout << std::endl;
return (0);
}
[c, 3] [b, 2] [a, 1]
[d, 4] [c, 3] [b, 2] [a, 1]
Vedi anche
<unordered_map>
Contenitori
Thread Safety in the C++ Standard Library (Sicurezza dei thread nella libreria standard C++)
Informazioni di riferimento per la libreria standard C++
Commenti e suggerimenti
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedere https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per