unordered_multimap (Clase)
La plantilla de clase describe un objeto que controla una secuencia de longitud variable de elementos de tipo std::pair<const Key, Ty>. La secuencia está ordenada débilmente por una función hash, que divide la secuencia en un conjunto ordenado subsecuencias denominadas depósitos. Dentro de cada depósito una función de comparación determina si algún par de elementos tiene una ordenación equivalente. Cada elemento almacena dos objetos, una clave de ordenación y un valor. La secuencia se representan de tal forma que permite la búsqueda, inserción y eliminación de un elemento arbitrario con una serie de operaciones que pueden ser independientes del número de elementos de la secuencia (tiempo constante), al menos cuando todos los depósitos tienen una longitud aproximadamente igual. En el peor de los casos, cuando todos los elementos están en un depósito, el número de operaciones es proporcional al número de elementos de la secuencia (tiempo lineal). Además, la inserción de un elemento no invalida ningún iterador y al quitar un elemento solo se invalidan los iteradores que apuntan al elemento quitado.
Sintaxis
template <class Key,
class Ty,
class Hash = std::hash<Key>,
class Pred = std::equal_to<Key>,
class Alloc = std::allocator<Key>>
class unordered_multimap;
Parámetros
Clave
El tipo de clave.
Ty
El tipo asignado.
Hash
El tipo de objeto de la función hash.
Pred
El tipo de objeto de función de comparación de igualdad.
Alloc
Clase de asignador.
Miembros
| Definición de tipo | Descripción |
|---|---|
| allocator_type | El tipo de un asignador para administrar el almacenamiento. |
| const_iterator | El tipo de un iterador constante para la secuencia controlada. |
| const_local_iterator | El tipo de un iterador de depósito constante para la secuencia controlada. |
| const_pointer | El tipo de un puntero constante a un elemento. |
| const_reference | El tipo de una referencia constante a un elemento. |
| difference_type | El tipo de una distancia con signo entre dos elementos. |
| _Hasher | El tipo de la función hash. |
| iterator | El tipo de un iterador para la secuencia controlada. |
| key_equal | El tipo de la función de comparación. |
| key_type | El tipo de una clave de ordenación. |
| local_iterator | El tipo de un iterador de depósito para la secuencia controlada. |
| mapped_type | El tipo de un valor asignado asociado a cada clave. |
| pointer | El tipo de un puntero a un elemento. |
| referencia | El tipo de una referencia a un elemento. |
| size_type | El tipo de una distancia sin signo entre dos elementos. |
| value_type | El tipo de un elemento. |
| Función miembro | Descripción |
|---|---|
| begin | Designa el principio de la secuencia controlada. |
| bucket | Obtiene el número de depósito para un valor de clave. |
| bucket_count | Obtiene el número de depósitos. |
| bucket_size | Obtiene el tamaño de un depósito. |
| cbegin | Designa el principio de la secuencia controlada. |
| cend | Designa el final de la secuencia controlada. |
| eliminar | Quita todos los elementos. |
| contieneC++20 | Comprueba si hay un elemento con la clave especificada en unordered_multimap. |
| count | Busca el número de elementos que coinciden con una clave especificada. |
| emplace | Agrega un elemento construido en contexto. |
| emplace_hint | Agrega un elemento construido en contexto, con sugerencia. |
| empty | Comprueba si no hay ningún elemento presente. |
| end | Designa el final de la secuencia controlada. |
| equal_range | Busca el intervalo que coincide con una clave especificada. |
| erase | Quita los elementos de las posiciones especificadas. |
| find | Busca un elemento que coincide con una clave especificada. |
| get_allocator | Obtiene el objeto de asignador almacenado. |
| hash_function | Obtiene el objeto de función hash almacenado. |
| insert | Agrega elementos. |
| key_eq | Obtiene el objeto de función de comparación almacenado. |
| load_factor | Cuenta los elementos promedio por depósito. |
| max_bucket_count | Obtiene el número máximo de depósitos. |
| max_load_factor | Obtiene o establece los elementos máximos por depósito. |
| max_size | Obtiene el tamaño máximo de la secuencia controlada. |
| rehash | Recompila la tabla hash. |
| size | Cuenta el número de elementos. |
| swap | Intercambia el contenido de dos contenedores. |
| unordered_multimap | Construye un objeto contenedor. |
| Operator | Descripción |
|---|---|
| unordered_multimap::operator= | Copia una tabla hash. |
Comentarios
El objeto ordena la secuencia que controla llamando a dos objetos almacenados, un objeto de función de comparación de tipo unordered_multimap::key_equal y un objeto de función hash de tipo unordered_multimap::hasher. Se tiene acceso al primer objeto almacenado llamando a la función miembro unordered_multimap::key_eq() y se tiene acceso al segundo objeto almacenado llamando a la función miembro unordered_multimap::hash_function(). Concretamente, para todos los valores X e Y de tipo Key, la llamada a key_eq()(X, Y) solo devuelve true si los dos valores de argumento tienen una ordenación equivalente; la llamada a hash_function()(keyval) produce una distribución de valores de tipo size_t. A diferencia de la plantilla de clase unordered_map, un objeto de tipo unordered_multimap no garantiza que key_eq()(X, Y) es siempre false para dos elementos cualesquiera de la secuencia controlada. (No es necesario que las claves sean únicas).
El objeto también almacena un factor de carga máxima, que especifica el número promedio deseado máximo de elementos por depósito. Si la inserción de un elemento hace que unordered_multimap::load_factor() supere el factor de carga máxima, el contenedor aumenta el número de depósitos y recompila la tabla hash según sea necesario.
El orden real de los elementos de la secuencia controlada depende de la función hash, la función de comparación, el orden de inserción, el factor de carga máxima y el número actual de depósitos. En general no se puede predecir el orden de los elementos de la secuencia controlada. Sin embargo, siempre se puede asegurar que cualquier subconjunto de elementos que tengan una ordenación equivalente son adyacentes en la secuencia controlada.
El objeto asigna y libera almacenamiento para la secuencia que controla a través de un objeto asignador almacenado de tipo unordered_multimap::allocator_type. Ese objeto de asignador debe tener la misma interfaz externa que un objeto de tipo allocator. Tenga en cuenta que el objeto de asignador almacenado no se copia cuando se asigna el objeto contenedor.
Requisitos
Encabezado:<unordered_map>
Espacio de nombres: std
unordered_multimap::allocator_type
El tipo de un asignador para administrar el almacenamiento.
typedef Alloc allocator_type;
Comentarios
El tipo es un sinónimo del parámetro de plantilla Alloc.
Ejemplo
// 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 el principio de la secuencia controlada o un depósito.
iterator begin();
const_iterator begin() const;
local_iterator begin(size_type nbucket);
const_local_iterator begin(size_type nbucket) const;
Parámetros
nbucket
Número de depósito.
Comentarios
Las dos primeras funciones miembro devuelven un iterador hacia delante que apunta al primer elemento de la secuencia (o más allá del final de una secuencia vacía). Las dos últimas funciones miembro devuelven un iterador hacia delante que apunta al primer elemento del depósito nbucket (o más allá del final de un depósito vacío).
Ejemplo
// 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
Obtiene el número de depósito para un valor de clave.
size_type bucket(const Key& keyval) const;
Parámetros
keyval
Valor de clave que se va a asignar.
Comentarios
La función miembro devuelve el número de depósito que corresponde actualmente al valor de clave keyval.
Ejemplo
// 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
Obtiene el número de depósitos.
size_type bucket_count() const;
Comentarios
La función miembro devuelve el número actual de depósitos.
Ejemplo
// 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
Obtiene el tamaño de un depósito.
size_type bucket_size(size_type nbucket) const;
Parámetros
nbucket
Número de depósito.
Comentarios
Las funciones miembro devuelven el tamaño del número del cubo nbucket.
Ejemplo
// 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
Devuelve un iterador const que direcciona el primer elemento del intervalo.
const_iterator cbegin() const;
Valor devuelto
Iterador const de acceso hacia delante que apunta al primer elemento del intervalo o la ubicación situada más allá del final de un intervalo vacío (para un intervalo vacío, cbegin() == cend()).
Comentarios
Con el valor devuelto de cbegin, los elementos del intervalo no se pueden modificar.
Se puede usar esta función miembro en lugar de la función miembro begin() para garantizar que el valor devuelto es const_iterator. Normalmente, se usa junto con la palabra clave de deducción de tipos auto, como se muestra en el ejemplo siguiente. En el ejemplo se considera que Container es un contenedor modificable (distinto de const) de cualquier naturaleza que admite begin() y cbegin().
auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();
// i2 is Container<T>::const_iterator
unordered_multimap::cend
Devuelve un iterador const que direcciona la ubicación situada más allá del último elemento de un intervalo.
const_iterator cend() const;
Valor devuelto
Iterador const de acceso hacia delante que apunta justo después del final del intervalo.
Comentarios
cend se usa para probar si un iterador ha sobrepasado el final de su intervalo.
Se puede usar esta función miembro en lugar de la función miembro end() para garantizar que el valor devuelto es const_iterator. Normalmente, se usa junto con la palabra clave de deducción de tipos auto, como se muestra en el ejemplo siguiente. En el ejemplo se considera que Container es un contenedor modificable (distinto de const) de cualquier naturaleza que admite end() y cend().
auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();
// i2 is Container<T>::const_iterator
El valor devuelto por cend no se debe desreferenciar.
unordered_multimap::clear
Quita todos los elementos.
void clear();
Comentarios
La función miembro llama a unordered_multimap::erase( unordered_multimap::begin(), unordered_multimap::end.())
Ejemplo
// 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
El tipo de un iterador constante para la secuencia controlada.
typedef T1 const_iterator;
Comentarios
El tipo describe un objeto que puede actuar como un iterador de avance constante de la secuencia controlada. Aquí se describe como sinónimo del tipo definido por implementación T1.
Ejemplo
// 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
El tipo de un iterador de depósito constante para la secuencia controlada.
typedef T5 const_local_iterator;
Comentarios
El tipo describe un objeto que puede actuar como iterador constante hacia delante para un depósito. Aquí se describe como sinónimo del tipo definido por implementación T5.
Ejemplo
// 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
El tipo de un puntero constante a un elemento.
typedef Alloc::const_pointer const_pointer;
Comentarios
El tipo describe un objeto que puede actuar como puntero constante a un elemento de la secuencia controlada.
Ejemplo
// 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
El tipo de una referencia constante a un elemento.
typedef Alloc::const_reference const_reference;
Comentarios
El tipo describe un objeto que puede actuar como referencia constante a un elemento de la secuencia controlada.
Ejemplo
// 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
Comprueba si hay un elemento con la clave especificada en unordered_multimap.
bool contains(const Key& key) const;
template<class K> bool contains(const K& key) const;
Parámetros
K
Tipo de la clave.
key
Valor de clave del elemento que se va a buscar.
Valor devuelto
true si el elemento se encuentra en el contenedor; en caso contrario, false.
Comentarios
contains() es nuevo en C++20. Para usarlo, especifique /std:c++20 o una opción de compilador posterior.
template<class K> bool contains(const K& key) const solo participa en la resolución de la sobrecarga si key_compare es transparente.
Ejemplo
// 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
Busca el número de elementos que coinciden con una clave especificada.
size_type count(const Key& keyval) const;
Parámetros
keyval
Valor de clave que se va a buscar.
Comentarios
La función miembro devuelve el número de elementos incluidos en el rango delimitado por unordered_multimap::equal_range(keyval).
Ejemplo
// 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
El tipo de una distancia con signo entre dos elementos.
typedef T3 difference_type;
Comentarios
El tipo de entero con signo describe un objeto que puede representar la diferencia entre las direcciones de dos elementos cualesquiera de la secuencia controlada. Aquí se describe como sinónimo del tipo definido por implementación T3.
Ejemplo
// 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
Inserta un elemento construido en contexto (no se realiza ninguna operación de copia o de movimiento), con una sugerencia de colocación.
template <class... Args>
iterator emplace(Args&&... args);
Parámetros
args
Argumentos reenviados para construir un elemento que se va a insertar en unordered_multimap.
Valor devuelto
Iterador al elemento recién insertado.
Comentarios
Esta función no invalida ninguna referencia a elementos contenedores, pero puede invalidar todos los iteradores al contenedor.
El value_type de un elemento es un par, de modo que el valor de un elemento será un par ordenado en el que el primer componente es igual que el valor de clave y el segundo componente es igual que el valor de datos del elemento.
Durante la inserción, si se produce una excepción pero no ocurre en la función hash del contenedor, el contenedor no se modifica. Si la excepción se produce en la función hash, el resultado es indefinido.
Para obtener un ejemplo de código, vea multimap::emplace.
unordered_multimap::emplace_hint
Inserta un elemento construido en contexto (no se realiza ninguna operación de copia o de movimiento), con una sugerencia de colocación.
template <class... Args>
iterator emplace_hint(
const_iterator where,
Args&&... args);
Parámetros
args
Argumentos reenviados para construir un elemento que se va a insertar sin ordenar.
where
Sugerencia con respecto al lugar donde se va a empezar a buscar el punto correcto de inserción.
Valor devuelto
Iterador al elemento recién insertado.
Comentarios
Esta función no invalida ninguna referencia a elementos contenedores, pero puede invalidar todos los iteradores al contenedor.
Durante la inserción, si se produce una excepción pero no ocurre en la función hash del contenedor, el contenedor no se modifica. Si la excepción se produce en la función hash, el resultado es indefinido.
El value_type de un elemento es un par, de modo que el valor de un elemento será un par ordenado en el que el primer componente es igual que el valor de clave y el segundo componente es igual que el valor de datos del elemento.
Para obtener un ejemplo de código, vea map::emplace_hint.
unordered_multimap::empty
Comprueba si no hay ningún elemento presente.
bool empty() const;
Comentarios
La función miembro devuelve true para una secuencia controlada vacía.
Ejemplo
// 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 el final de la secuencia controlada.
iterator end();
const_iterator end() const;
local_iterator end(size_type nbucket);
const_local_iterator end(size_type nbucket) const;
Parámetros
nbucket
Número de depósito.
Comentarios
Las dos primeras funciones miembro devuelven un iterador hacia delante que apunta inmediatamente después del final de la secuencia. Las dos últimas funciones miembro devuelven un iterador hacia delante que apunta inmediatamente después del final del cubo nbucket.
Ejemplo
// 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
Busca el intervalo que coincide con una clave especificada.
std::pair<iterator, iterator>
equal_range(const Key& keyval);
std::pair<const_iterator, const_iterator>
equal_range(const Key& keyval) const;
Parámetros
keyval
Valor de clave que se va a buscar.
Comentarios
La función miembro devuelve un par de iteradores X tales que [X.first, X.second) delimita únicamente los elementos de la secuencia controlada que tienen una ordenación equivalente con keyval. Si no hay elementos de este tipo, los dos iteradores son end().
Ejemplo
// 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
Quita un elemento o un intervalo de elementos de un unordered_multimap de las posiciones especificadas o quita los elementos que coinciden con una clave especificada.
iterator erase(
const_iterator Where);
iterator erase(
const_iterator First,
const_iterator Last);
size_type erase(
const key_type& Key);
Parámetros
Where
Posición del elemento que se va a quitar.
First
Posición del primer elemento que se va a quitar.
Último
Posición situada más allá del último elemento que se va a quitar.
Clave
Valor de clave de los elementos que se van a quitar.
Valor devuelto
Para las dos primeras funciones miembro, iterador bidireccional que designa el primer elemento que permanece más allá de los elementos quitados, o un elemento que es el final de la asignación si no existe ese elemento.
Para la tercera función miembro, devuelve el número de elementos que se han quitado de unordered_multimap.
Comentarios
Para obtener un ejemplo de código, vea map::erase.
unordered_multimap::find
Busca un elemento que coincide con una clave especificada.
const_iterator find(const Key& keyval) const;
Parámetros
keyval
Valor de clave que se va a buscar.
Comentarios
La función miembro devuelve unordered_multimap::equal_range(keyval).first.
Ejemplo
// 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
Obtiene el objeto de asignador almacenado.
Alloc get_allocator() const;
Comentarios
La función miembro devuelve el objeto de asignador almacenado.
Ejemplo
// 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
Obtiene el objeto de función hash almacenado.
Hash hash_function() const;
Comentarios
La función miembro devuelve el objeto de función hash almacenado.
Ejemplo
// 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
El tipo de la función hash.
typedef Hash hasher;
Comentarios
El tipo es un sinónimo del parámetro de plantilla Hash.
Ejemplo
// 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
Inserta un elemento o un intervalo de elementos en un 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);
Parámetros
Val
Valor de un elemento que se va a insertar en el unordered_multimap.
Where
Lugar donde se va a iniciar la búsqueda del punto de inserción correcto.
ValTy
Parámetro de plantilla que especifica el tipo de argumento que unordered_multimap puede usar para construir un elemento de value_type y realiza un reenvío directo de Val como argumento.
First
Posición del primer elemento que se va a copiar.
Último
Posición situada más allá del último elemento que se va a copiar.
InputIterator
Argumento de la función de plantilla que cumple los requisitos de un iterador de entrada que apunta a elementos de un tipo que se puede usar para crear objetos value_type.
IList
El elemento initializer_list del que se van a copiar los elementos.
Valor devuelto
Las funciones miembro de inserción de un solo elemento, (1) y (2), devuelven un iterador a la posición donde se insertó el nuevo elemento en el unordered_multimap.
Las funciones miembro de inserción de un solo elemento con sugerencia, (3) y (4), devuelven un iterador que apunta a la posición donde se insertó el nuevo elemento en el unordered_multimap.
Comentarios
Esta función no invalida ningún puntero ni ninguna referencia, pero puede invalidar todos los iteradores al contenedor.
Durante la inserción de un solo elemento, si se produce una excepción pero no se realiza en la función hash del contenedor, no se modifica el estado del contenedor. Si la excepción se produce en la función hash, el resultado es indefinido. Durante la inserción de varios elementos, si se produce una excepción, el contenedor se deja en un estado sin especificar pero válido.
El objeto value_type de un contenedor es una definición de tipo que pertenece al contenedor y, para map, map<K, V>::value_type es pair<const K, V>. El valor de un elemento es un par ordenado en el que el primer componente es igual al valor de clave y el segundo componente es igual al valor de datos del elemento.
La función miembro de intervalo (5) inserta la secuencia de valores de elemento en un unordered_multimap que corresponde a cada elemento direccionado por un iterador en el intervalo [First, Last); por tanto, Last no se inserta. La función miembro de contenedor end() hace referencia a la posición situada justo después del último elemento del contenedor; por ejemplo, la instrucción m.insert(v.begin(), v.end()); inserta todos los elementos de v en m.
La función miembro de lista de inicializadores (6) usa una initializer_list para copiar los elementos al unordered_multimap.
Para la inserción de un elemento construido en contexto (es decir, no se realiza ninguna operación de copia o movimiento), vea unordered_multimap::emplace y unordered_multimap::emplace_hint.
Para obtener un ejemplo de código, vea multimap::insert.
unordered_multimap::iterator
El tipo de un iterador para la secuencia controlada.
typedef T0 iterator;
Comentarios
El tipo describe un objeto que puede actuar como un iterador de avance de la secuencia controlada. Aquí se describe como sinónimo del tipo definido por implementación T0.
Ejemplo
// 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
Obtiene el objeto de función de comparación almacenado.
Pred key_eq() const;
Comentarios
La función miembro devuelve el objeto de función de comparación almacenado.
Ejemplo
// 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
El tipo de la función de comparación.
typedef Pred key_equal;
Comentarios
El tipo es un sinónimo del parámetro de plantilla Pred.
Ejemplo
// 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
El tipo de una clave de ordenación.
typedef Key key_type;
Comentarios
El tipo es un sinónimo del parámetro de plantilla Key.
Ejemplo
// 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
Cuenta los elementos promedio por depósito.
float load_factor() const;
Comentarios
La función miembro devuelve (float)unordered_multimap::size() / (float)unordered_multimap::bucket_count(), el promedio de elementos por depósito.
Ejemplo
// 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 de un iterador de depósito.
typedef T4 local_iterator;
Comentarios
El tipo describe un objeto que puede actuar como iterador hacia delante para un depósito. Aquí se describe como sinónimo del tipo definido por implementación T4.
Ejemplo
// 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
El tipo de un valor asignado asociado a cada clave.
typedef Ty mapped_type;
Comentarios
El tipo es un sinónimo del parámetro de plantilla Ty.
Ejemplo
// 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
Obtiene el número máximo de depósitos.
size_type max_bucket_count() const;
Comentarios
La función miembro devuelve el número máximo de depósitos que se admiten actualmente.
Ejemplo
// 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
Obtiene o establece los elementos máximos por depósito.
float max_load_factor() const;
void max_load_factor(float factor);
Parámetros
factor
El nuevo factor de carga máxima.
Comentarios
La primera función miembro devuelve el factor de carga máxima almacenado. La segunda función miembro reemplaza el factor de carga máxima almacenado con factor.
Ejemplo
// 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
Obtiene el tamaño máximo de la secuencia controlada.
size_type max_size() const;
Comentarios
La función miembro devuelve la longitud de la secuencia más larga que puede controlar el objeto.
Ejemplo
// 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 tabla hash.
unordered_multimap& operator=(const unordered_multimap& right);
unordered_multimap& operator=(unordered_multimap&& right);
Parámetros
right
La clase unordered_multimap que se copia en unordered_multimap.
Comentarios
Después de borrar todos los elementos existentes en un unordered_multimap, operator= copia o mueve el contenido de right a unordered_multimap.
Ejemplo
// 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
El tipo de un puntero a un elemento.
typedef Alloc::pointer pointer;
Comentarios
El tipo describe un objeto que puede actuar como puntero a un elemento de la secuencia controlada.
Ejemplo
// 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
El tipo de una referencia a un elemento.
typedef Alloc::reference reference;
Comentarios
El tipo describe un objeto que puede actuar como referencia a un elemento de la secuencia controlada.
Ejemplo
// 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
Recompila la tabla hash.
void rehash(size_type nbuckets);
Parámetros
nbuckets
Número solicitado de depósitos.
Comentarios
La función miembro modifica el número de depósitos para que sea al menos nbuckets y vuelve a generar la tabla hash según sea necesario.
Ejemplo
// 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
Cuenta el número de elementos.
size_type size() const;
Comentarios
La función miembro devuelve la longitud de la secuencia controlada.
Ejemplo
// 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
El tipo de una distancia sin signo entre dos elementos.
typedef T2 size_type;
Comentarios
El tipo de entero sin signo describe un objeto que puede representar la longitud de cualquier secuencia controlada. Aquí se describe como sinónimo del tipo definido por implementación T2.
Ejemplo
// 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
Intercambia el contenido de dos contenedores.
void swap(unordered_multimap& right);
Parámetros
right
El contenedor con el que se intercambia.
Comentarios
La función miembro intercambia las secuencias controladas entre *this y right. Si unordered_multimap::get_allocator() == right.get_allocator(), lo hace en tiempo constante, inicia una excepción solo como resultado de copiar el objeto de rasgos almacenado de tipo Tr y no invalida referencias, punteros o iteradores que designan elementos en las dos secuencias controladas. De lo contrario, realiza varias asignaciones de elementos y llamadas de constructor proporcionales al número de elementos de ambas secuencias controladas.
Ejemplo
// 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
Construye un objeto contenedor.
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());
Parámetros
InputIterator
Tipo de iterador.
Al
Objeto de asignador que se va a almacenar.
Comp
Objeto de función de comparación que se va a almacenar.
Hash
Objeto de función hash que se va a almacenar.
Bucket_count
Número mínimo de depósitos.
Right
Contenedor que se va a copiar.
IList
initializer_list de la que se van a copiar los elementos.
Comentarios
El primer constructor especifica una copia de la secuencia controlada por Right. El segundo constructor especifica una secuencia controlada vacía. El tercer constructor especifica una copia de la secuencia moviendo Right. Los constructores cuarto, quinto, sexto, séptimo y octavo utilizan una initializer_list para los miembros. El noveno constructor inserta la secuencia de valores de elemento [First, Last).
Todos los constructores también inicializan varios valores almacenados. Para el constructor de copias, los valores se obtienen de Right. De lo contrario:
El número mínimo de depósitos es el argumento Bucket_count, si está presente; de lo contrario, es un valor predeterminado descrito aquí como el valor N0 definido por la implementación.
El objeto de función hash es el argumento Hash, si está presente; de lo contrario, es Hash().
El objeto de función de comparación es el argumento Comp, si está presente; de lo contrario, es Pred().
El objeto de asignador es el argumento Al, si está presente; de lo contrario, es Alloc().
Ejemplo
// 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
El tipo de un elemento.
typedef std::pair<const Key, Ty> value_type;
Comentarios
El tipo describe un elemento de la secuencia controlada.
Ejemplo
// 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]
Vea también
<unordered_map>
Contenedores
Seguridad para subprocesos en la biblioteca estándar de C++
Referencia de biblioteca estándar de C++
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente las Cuestiones de GitHub como mecanismo de retroalimentación para el contenido y lo sustituiremos por un nuevo sistema de retroalimentación. Para más información, consulta: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de