`hash_multimap` (STL/CLR)

Artículo
10/12/2023

La clase de plantilla describe un objeto que controla una secuencia de longitud variable de elementos que tienen acceso bidireccional. Puede usar el contenedor hash_multimap para administrar una secuencia de elementos como una tabla hash, cada entrada de tabla que almacena una lista vinculada bidireccional de nodos y cada nodo almacena un elemento. Un elemento consta de una clave, para ordenar la secuencia, y un valor asignado, que va a lo largo del recorrido.

En la descripción siguiente, GValue es igual que:

Microsoft::VisualC::StlClr::GenericPair<GKey, GMapped>

donde:

GKey es igual que Key a menos que este último sea un tipo ref, en cuyo caso es Key^

GMapped es igual que Mapped a menos que este último sea un tipo ref, en cuyo caso es Mapped^

Sintaxis

template<typename Key,
    typename Mapped>
    ref class hash_multimap
        :   public
        System::ICloneable,
        System::Collections::IEnumerable,
        System::Collections::ICollection,
        System::Collections::Generic::IEnumerable<GValue>,
        System::Collections::Generic::ICollection<GValue>,
        System::Collections::Generic::IList<GValue>,
        Microsoft::VisualC::StlClr::IHash<Gkey, GValue>
    { ..... };

Parámetros

Key
Tipo del componente clave de un elemento de la secuencia controlada.

Mapped
Tipo del otro componente de un elemento de la secuencia controlada.

Requisitos

Encabezado:<cliext/hash_map>

Espacio de nombres: cliext

Declaraciones

Definición de tipo	Descripción
`hash_multimap::const_iterator`	El tipo de un iterador constante para la secuencia controlada.
`hash_multimap::const_reference`	El tipo de una referencia constante a un elemento.
`hash_multimap::const_reverse_iterator`	El tipo de un iterador invertido constante para la secuencia controlada.
`hash_multimap::difference_type`	Tipo de una distancia (posiblemente con signo) entre dos elementos.
`hash_multimap::generic_container`	Tipo de la interfaz genérica para el contenedor.
`hash_multimap::generic_iterator`	Tipo de iterador de la interfaz genérica del contenedor.
`hash_multimap::generic_reverse_iterator`	Tipo de iterador inverso para la interfaz genérica del contenedor.
`hash_multimap::generic_value`	Tipo de elemento para la interfaz genérica del contenedor.
`hash_multimap::hasher`	Delegado de hash de una clave.
`hash_multimap::iterator`	El tipo de un iterador para la secuencia controlada.
`hash_multimap::key_compare`	Delegado de ordenación para dos claves.
`hash_multimap::key_type`	El tipo de una clave de ordenación.
`hash_multimap::mapped_type`	El tipo de un valor asignado asociado a cada clave.
`hash_multimap::reference`	El tipo de una referencia a un elemento.
`hash_multimap::reverse_iterator`	El tipo de un iterador invertido para la secuencia controlada.
`hash_multimap::size_type`	Tipo de una distancia (no negativa) entre dos elementos.
`hash_multimap::value_compare`	Delegado de ordenación de dos valores de elementos.
`hash_multimap::value_type`	El tipo de un elemento.

Función de miembro	Descripción
`hash_multimap::begin`	Designa el principio de la secuencia controlada.
`hash_multimap::bucket_count`	Cuenta el número de cubos.
`hash_multimap::clear`	Quita todos los elementos.
`hash_multimap::count`	Cuenta los elementos que coinciden con una clave especificada.
`hash_multimap::empty`	Comprueba si no hay ningún elemento presente.
`hash_multimap::end`	Designa el final de la secuencia controlada.
`hash_multimap::equal_range`	Busca el intervalo que coincide con una clave especificada.
`hash_multimap::erase`	Quita los elementos de las posiciones especificadas.
`hash_multimap::find`	Busca un elemento que coincide con una clave especificada.
`hash_multimap::hash_delegate`	Copia el delegado de hash para una clave.
`hash_multimap::hash_multimap`	Construye un objeto contenedor.
`hash_multimap::insert`	Agrega elementos.
`hash_multimap::key_comp`	Copia el delegado de ordenación de dos claves.
`hash_multimap::load_factor`	Cuenta los elementos promedio por depósito.
`hash_multimap::lower_bound`	Busca el principio del intervalo que coincide con una clave especificada.
`hash_multimap::make_value`	Construye un objeto de valor.
`hash_multimap::max_load_factor`	Obtiene o establece los elementos máximos por depósito.
`hash_multimap::rbegin`	Designa el principio de la secuencia controlada inversa.
`hash_multimap::rehash`	Recompila la tabla hash.
`hash_multimap::rend`	Designa el final de la secuencia controlada inversa.
`hash_multimap::size`	Cuenta el número de elementos.
`hash_multimap::swap`	Intercambia el contenido de dos contenedores.
`hash_multimap::to_array`	Copia la secuencia controlada en una nueva matriz.
`hash_multimap::upper_bound`	Busca el final del intervalo que coincide con una clave especificada.
`hash_multimap::value_comp`	Copia el delegado de ordenación de dos valores de elementos.

Operator	Descripción
`hash_multimap::operator=`	Reemplaza la secuencia controlada.

Interfaces

Interfaz	Descripción
ICloneable	Duplica un objeto.
IEnumerable	Moverse en secuencia por los elementos.
ICollection	Mantener un grupo de elementos.
IEnumerable<T>	Moverse en secuencia por los elementos con tipo.
ICollection<T>	Mantiene un grupo de elementos con tipo.
`IHash<Key, Value>`	Mantener el contenedor genérico.

Comentarios

El objeto asigna y libera almacenamiento para la secuencia que controla como nodos individuales de una lista vinculada bidireccional. Para acelerar el acceso, el objeto también mantiene una matriz de punteros de longitud variable en la lista (la tabla hash) y administra de manera eficaz toda la lista como una secuencia de sublistas o cubos. Inserta elementos en un cubo que mantiene ordenado al modificar los vínculos entre nodos sin copiar nunca el contenido de un nodo a otro. Esto significa que puede insertar y quitar elementos libremente sin alterar los elementos restantes.

El objeto ordena cada cubo que controla llamando a un objeto delegado almacenado de tipo hash_set::key_compare. Puede especificar el objeto delegado almacenado al construir el elemento hash_set; si no especifica ningún objeto delegado, el valor predeterminado es la comparación operator<=(key_type, key_type).

Para acceder al objeto delegado almacenado, llame a la función hash_set::key_compmiembro . Este objeto delegado debe definir una ordenación equivalente entre las claves de tipo hash_set::key_type. Esto significa que, para dos claves X y Y:

key_comp()(X, Y) devuelve el mismo resultado booleano en cada llamada.

Si key_comp()(X, Y) && key_comp()(Y, X) es true, X e Y tienen una ordenación equivalente.

Cualquier regla de ordenación que se comporte como operator<=(key_type, key_type)o operator>=(key_type, key_type) operator==(key_type, key_type) define el orden equivalente.

El contenedor solo garantiza que los elementos cuyas claves tengan una ordenación equivalente (y qué hash con el mismo valor entero) estén adyacentes dentro de un cubo. A diferencia de la clase hash_map de plantilla (STL/CLR), un objeto de clase hash_multimap de plantilla no requiere que las claves de todos los elementos sean únicas. (Dos o más claves pueden tener una ordenación equivalente).

El objeto determina qué cubo debe contener una clave de ordenación determinada llamando a un objeto delegado almacenado de tipo hash_set::hasher. Para obtener acceso a este objeto almacenado, llame a la función hash_set::hash_delegate miembro para obtener un valor entero que dependa del valor de clave. Puede especificar el objeto delegado almacenado al construir el elemento hash_set; si no especifica ningún objeto delegado, el valor predeterminado es la función System::Object::hash_value(key_type). Esto significa que, para cualquiera de la claves X e Y:

hash_delegate()(X) devuelve el mismo resultado entero en cada llamada.

Si X e Y tienen una ordenación equivalente, hash_delegate()(X) debe devolver el mismo resultado entero que hash_delegate()(Y).

Cada elemento contiene una clave independiente y un valor asignado. La secuencia se representa de forma que permita la búsqueda, inserción y eliminación de un elemento arbitrario en tiempo constante. Es decir, el número de operaciones es independiente del número de elementos de la secuencia, al menos en el mejor de los casos. 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.

Sin embargo, si los valores hash no se distribuyen uniformemente, una tabla hash puede degenerarse. En el extremo (para una función hash que siempre devuelve el mismo valor), la búsqueda, la inserción y la eliminación son proporcionales al número de elementos de la secuencia (tiempo lineal). El contenedor intenta elegir una función hash razonable, el tamaño medio del cubo y el tamaño de la tabla hash (número total de cubos), pero puede invalidar cualquiera o todas estas opciones. Vea, por ejemplo, las funciones hash_set::max_load_factor y hash_set::rehash.

Un hash_multimap admite iteradores bidireccionales, lo que significa que puede realizar pasos a elementos adyacentes dado un iterador que designa un elemento en la secuencia controlada. Un nodo principal especial corresponde al iterador devuelto por end(). Puede reducir este iterador para llegar al último elemento de la secuencia controlada, si está presente. Puede incrementar un hash_multimap iterador para llegar al nodo principal y, a continuación, comparará igual a end(). Pero no se puede desreferenciar el iterador devuelto por end().

No se puede hacer referencia a un hash_multimap elemento directamente dado su posición numérica. Esto requiere un iterador de acceso aleatorio.

Un hash_multimap iterador almacena un identificador en su nodo asociado hash_multimap , que a su vez almacena un identificador en su contenedor asociado. Solo puede usar iteradores con sus objetos de contenedor asociados. Un hash_multimap iterador sigue siendo válido siempre que su nodo asociado esté asociado hash_multimap a algún hash_multimap. Además, un iterador válido es dereferencable. Puede usarlo para acceder o modificar el valor del elemento que designa, siempre y cuando no sea igual a end().

Borrar o quitar un elemento llama al destructor para su valor almacenado. Al destruir el contenedor, se borran todos los elementos. Por lo tanto, un contenedor cuyo tipo de elemento es una clase de referencia garantiza que ningún elemento sobrevive al contenedor. Sin embargo, un contenedor de identificadores no destruye sus elementos.

Miembros

hash_multimap::begin

Designa el principio de la secuencia controlada.

Sintaxis

iterator begin();

Comentarios

La función miembro devuelve un iterador bidireccional que designa al primer elemento de la secuencia controlada o apunta inmediatamente después del final de una secuencia vacía. Se usa para obtener un iterador que designe el current principio de la secuencia controlada, pero su estado puede cambiar si cambia la longitud de la secuencia controlada.

Ejemplo

// cliext_hash_multimap_begin.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect first two items
    Myhash_multimap::iterator it = c1.begin();
    System::Console::WriteLine("*begin() = [{0} {1}]",
        it->first, it->second);
    ++it;
    System::Console::WriteLine("*++begin() = [{0} {1}]",
        it->first, it->second);
    return (0);
    }

[a 1] [b 2] [c 3]
*begin() = [a 1]
*++begin() = [b 2]

hash_multimap::bucket_count

Cuenta el número de cubos.

Sintaxis

int bucket_count();

Comentarios

La función miembro devuelve el número actual de depósitos. Se usa para determinar el tamaño de la tabla hash.

Ejemplo

// cliext_hash_multimap_bucket_count.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1 = gcnew Myhash_multimap;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }

[a 1] [b 2] [c 3]
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

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

hash_multimap::clear

Quita todos los elementos.

Sintaxis

void clear();

Comentarios

La función miembro llama eficazmente a erase(begin(), end()). Se usa para garantizar que la secuencia controlada está vacía.

Ejemplo

// cliext_hash_multimap_clear.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());

    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));

    // display contents " [a 1] [b 2]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

[a 1] [b 2] [c 3]
size() = 0
[a 1] [b 2]
size() = 0

hash_multimap::const_iterator

El tipo de un iterador constante para la secuencia controlada.

Sintaxis

typedef T2 const_iterator;

Comentarios

El tipo describe un objeto de tipo sin especificar T2 que puede actuar como un iterador bidireccional constante de la secuencia controlada.

Ejemplo

// cliext_hash_multimap_const_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Myhash_multimap::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        System::Console::Write("[{0} {1}] ", cit->first, cit->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]

hash_multimap::const_reference

El tipo de una referencia constante a un elemento.

Sintaxis

typedef value_type% const_reference;

Comentarios

El tipo describe una referencia constante a un elemento.

Ejemplo

// cliext_hash_multimap_const_reference.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Myhash_multimap::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        {   // get a const reference to an element
        Myhash_multimap::const_reference cref = *cit;
        System::Console::Write("[{0} {1}] ", cref->first, cref->second);
        }
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]

hash_multimap::const_reverse_iterator

El tipo de un iterador invertido constante para la secuencia controlada.

Sintaxis

typedef T4 const_reverse_iterator;

Comentarios

El tipo describe un objeto de tipo sin especificar T4 que puede actuar como un iterador inverso constante de la secuencia controlada.

Ejemplo

// cliext_hash_multimap_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" reversed
    Myhash_multimap::const_reverse_iterator crit = c1.rbegin();
    for (; crit != c1.rend(); ++crit)
        System::Console::Write("[{0} {1}] ", crit->first, crit->second);
    System::Console::WriteLine();
    return (0);
    }

[c 3] [b 2] [a 1]

hash_multimap::count

Busca el número de elementos que coinciden con una clave especificada.

Sintaxis

size_type count(key_type key);

Parámetros

key
Valor de clave que se va a buscar.

Comentarios

La función miembro devuelve el número de elementos de la secuencia controlada que tienen un orden equivalente con key. Se usa para determinar el número de elementos que se encuentran actualmente en la secuencia controlada que coinciden con una clave especificada.

Ejemplo

// cliext_hash_multimap_count.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("count(L'A') = {0}", c1.count(L'A'));
    System::Console::WriteLine("count(L'b') = {0}", c1.count(L'b'));
    System::Console::WriteLine("count(L'C') = {0}", c1.count(L'C'));
    return (0);
    }

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

hash_multimap::d ifference_type

Tipos de una distancia con signo entre dos elementos.

Sintaxis

typedef int difference_type;

Comentarios

El tipo describe un recuento de elementos posiblemente negativo.

Ejemplo

// cliext_hash_multimap_difference_type.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // compute positive difference
    Myhash_multimap::difference_type diff = 0;
    for (Myhash_multimap::iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);

    // compute negative difference
    diff = 0;
    for (Myhash_multimap::iterator it = c1.end(); it != c1.begin(); --it)
        --diff;
    System::Console::WriteLine("begin()-end() = {0}", diff);
    return (0);
    }

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

hash_multimap::empty

Comprueba si no hay ningún elemento presente.

Sintaxis

bool empty();

Comentarios

La función miembro devuelve true para una secuencia controlada vacía. Equivale a size() == 0. Se usa para comprobar si está hash_multimap vacío.

Ejemplo

// cliext_hash_multimap_empty.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());
    return (0);
    }

[a 1] [b 2] [c 3]
size() = 3
empty() = False
size() = 0
empty() = True

hash_multimap::end

Designa el final de la secuencia controlada.

Sintaxis

iterator end();

Comentarios

La función miembro devuelve un iterador bidireccional que apunta inmediatamente después del final de la secuencia controlada. Se usa para obtener un iterador que designe el final de la secuencia controlada; su estado no cambia si cambia la longitud de la secuencia controlada.

Ejemplo

// cliext_hash_multimap_end.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect last two items
    Myhash_multimap::iterator it = c1.end();
    --it;
    --it;
    System::Console::WriteLine("*-- --end() = [{0} {1}]",
        it->first, it->second);
    ++it;
    System::Console::WriteLine("*--end() = [{0} {1}]",
        it->first, it->second);
    return (0);
    }

[a 1] [b 2] [c 3]
*-- --end() = [b 2]
*--end() = [c 3]

hash_multimap::equal_range

Busca el intervalo que coincide con una clave especificada.

Sintaxis

cliext::pair<iterator, iterator> equal_range(key_type key);

Parámetros

key
Valor de clave que se va a buscar.

Comentarios

La función miembro devuelve un par de iteradores cliext::pair<iterator, iterator>(lower_bound(key), upper_bound(key)). Se usa para determinar el intervalo de elementos que están actualmente en la secuencia controlada que coinciden con una clave especificada.

Ejemplo

// cliext_hash_multimap_equal_range.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
typedef Myhash_multimap::pair_iter_iter Pairii;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // display results of failed search
    Pairii pair1 = c1.equal_range(L'x');
    System::Console::WriteLine("equal_range(L'x') empty = {0}",
        pair1.first == pair1.second);

    // display results of successful search
    pair1 = c1.equal_range(L'b');
    for (; pair1.first != pair1.second; ++pair1.first)
        System::Console::Write("[{0} {1}] ",
            pair1.first->first, pair1.first->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
equal_range(L'x') empty = True
[b 2]

hash_multimap::erase

Quita los elementos de las posiciones especificadas.

Sintaxis

iterator erase(iterator where);
iterator erase(iterator first, iterator last);
bool erase(key_type key)

Parámetros

first
Principio del intervalo que se va a borrar.

key
Valor de clave que se va a borrar.

last
Fin del intervalo que se va a borrar.

where
Elemento que se va a borrar.

Comentarios

La primera función miembro quita el elemento de la secuencia controlada a wherela que apunta , y devuelve un iterador que designa el primer elemento que queda más allá del elemento quitado, o end() si no existe dicho elemento. Se usa para quitar un único elemento.

La segunda función miembro quita los elementos de la secuencia controlada en el intervalo [first, last)medio abierto y devuelve un iterador que designa el primer elemento que queda más allá de los elementos quitados, o end() si no existe dicho elemento. Se usa para quitar cero o más elementos contiguos.

La tercera función miembro quita cualquier elemento de la secuencia controlada cuya clave tenga una ordenación equivalente a keyy devuelve un recuento del número de elementos quitados. Se usa para quitar y contar todos los elementos que coinciden con una clave especificada.

Cada eliminación de elementos tarda un tiempo proporcional al logaritmo del número de elementos de la secuencia controlada.

Ejemplo

// cliext_hash_multimap_erase.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    cliext::hash_multimap<wchar_t, int> c1;
    c1.insert(cliext::hash_multimap<wchar_t, int>::make_value(L'a', 1));
    c1.insert(cliext::hash_multimap<wchar_t, int>::make_value(L'b', 2));
    c1.insert(cliext::hash_multimap<wchar_t, int>::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (cliext::hash_multimap<wchar_t, int>::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // erase an element and reinspect
    cliext::hash_multimap<wchar_t, int>::iterator it =
        c1.erase(c1.begin());
    System::Console::WriteLine("erase(begin()) = [{0} {1}]",
        it->first, it->second);

    // add elements and display " b c d e"
    c1.insert(cliext::hash_multimap<wchar_t, int>::make_value(L'd', 4));
    c1.insert(cliext::hash_multimap<wchar_t, int>::make_value(L'e', 5));
    for each (cliext::hash_multimap<wchar_t, int>::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // erase all but end
    it = c1.end();
    it = c1.erase(c1.begin(), --it);
    System::Console::WriteLine("erase(begin(), end()-1) = [{0} {1}]",
        it->first, it->second);
    System::Console::WriteLine("size() = {0}", c1.size());

    // erase end
    System::Console::WriteLine("erase(L'x') = {0}", c1.erase(L'x'));
    System::Console::WriteLine("erase(L'e') = {0}", c1.erase(L'e'));
    return (0);
    }

[a 1] [b 2] [c 3]
erase(begin()) = [b 2]
[b 2] [c 3] [d 4] [e 5]
erase(begin(), end()-1) = [e 5]
size() = 1
erase(L'x') = 0
erase(L'e') = 1

`hash_multimap::find`

Busca un elemento que coincide con una clave especificada.

Sintaxis

iterator find(key_type key);

Parámetros

key
Valor de clave que se va a buscar.

Comentarios

Si al menos un elemento de la secuencia controlada tiene un orden equivalente con key, la función miembro devuelve un iterador que designa uno de esos elementos; de lo contrario, devuelve hash_multimap::end(). Se usa para localizar un elemento que está actualmente en la secuencia controlada que coincide con una clave especificada.

Ejemplo

// cliext_hash_multimap_find.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("find {0} = {1}",
        L'A', c1.find(L'A') != c1.end());

    Myhash_multimap::iterator it = c1.find(L'b');
    System::Console::WriteLine("find {0} = [{1} {2}]",
        L'b', it->first, it->second);

    System::Console::WriteLine("find {0} = {1}",
        L'C', c1.find(L'C') != c1.end());
    return (0);
    }

[a 1] [b 2] [c 3]
find A = False
find b = [b 2]
find C = False

`hash_multimap::generic_container`

Tipo de la interfaz genérica para el contenedor.

Sintaxis

typedef Microsoft::VisualC::StlClr::
    IHash<GKey, GValue>
    generic_container;

Comentarios

El tipo describe la interfaz genérica de esta clase contenedora de plantilla.

Ejemplo

// cliext_hash_multimap_generic_container.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_multimap::generic_container^ gc1 = %c1;
    for each (Myhash_multimap::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // modify generic and display original
    gc1->insert(Myhash_multimap::make_value(L'd', 4));
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // modify original and display generic
    c1.insert(Myhash_multimap::make_value(L'e', 5));
    for each (Myhash_multimap::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3] [d 4]
[a 1] [b 2] [c 3] [d 4] [e 5]

`hash_multimap::generic_iterator`

Tipo de iterador para usarlo con la interfaz genérica del contenedor.

Sintaxis

typedef Microsoft::VisualC::StlClr::Generic::
    ContainerBidirectionalIterator<generic_value>
    generic_iterator;

Comentarios

El tipo describe un iterador genérico que se puede usar con la interfaz genérica de esta clase de contenedor de plantilla.

Ejemplo

// cliext_hash_multimap_generic_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_multimap::generic_container^ gc1 = %c1;
    for each (Myhash_multimap::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // get an element and display it
    Myhash_multimap::generic_iterator gcit = gc1->begin();
    Myhash_multimap::generic_value gcval = *gcit;
    System::Console::Write("[{0} {1}] ", gcval->first, gcval->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[a 1]

`hash_multimap::generic_reverse_iterator`

Tipo de iterador inverso que se usa con la interfaz genérica del contenedor.

Sintaxis

typedef Microsoft::VisualC::StlClr::Generic::
    ReverseRandomAccessIterator<generic_value>
    generic_reverse_iterator;

Comentarios

El tipo describe un iterador inverso genérico que se puede usar con la interfaz genérica de esta clase de contenedor de plantilla.

Ejemplo

// cliext_hash_multimap_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_multimap::generic_container^ gc1 = %c1;
    for each (Myhash_multimap::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // get an element and display it
    Myhash_multimap::generic_reverse_iterator gcit = gc1->rbegin();
    Myhash_multimap::generic_value gcval = *gcit;
    System::Console::WriteLine("[{0} {1}] ", gcval->first, gcval->second);
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[c 3]

`hash_multimap::generic_value`

Tipo de elemento para usarlo con la interfaz genérica del contenedor.

Sintaxis

typedef GValue generic_value;

Comentarios

El tipo describe un objeto de tipo GValue que describe el valor del elemento almacenado que se debe usar con la interfaz genérica de esta clase contenedora de plantilla.

Ejemplo

// cliext_hash_multimap_generic_value.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct a generic container
    Myhash_multimap::generic_container^ gc1 = %c1;
    for each (Myhash_multimap::value_type elem in gc1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // get an element and display it
    Myhash_multimap::generic_iterator gcit = gc1->begin();
    Myhash_multimap::generic_value gcval = *gcit;
    System::Console::WriteLine("[{0} {1}] ", gcval->first, gcval->second);
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[a 1]

`hash_multimap::hash_delegate`

Busca un elemento que coincide con una clave especificada.

Sintaxis

hasher^ hash_delegate();

Comentarios

La función miembro devuelve el delegado que se usó para convertir un valor de clave en un entero. Se usa para aplicar un algoritmo hash a una clave.

Ejemplo

// cliext_hash_multimap_hash_delegate.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    Myhash_multimap::hasher^ myhash = c1.hash_delegate();

    System::Console::WriteLine("hash(L'a') = {0}", myhash(L'a'));
    System::Console::WriteLine("hash(L'b') = {0}", myhash(L'b'));
    return (0);
    }

hash(L'a') = 1616896120
hash(L'b') = 570892832

`hash_multimap::hash_multimap`

Construye un objeto contenedor.

Sintaxis

hash_multimap();
explicit hash_multimap(key_compare^ pred);
hash_multimap(key_compare^ pred, hasher^ hashfn);
hash_multimap(hash_multimap<Key, Mapped>% right);
hash_multimap(hash_multimap<Key, Mapped>^ right);
template<typename InIter>
    hash_multimaphash_multimap(InIter first, InIter last);
template<typename InIter>
    hash_multimap(InIter first, InIter last,
        key_compare^ pred);
template<typename InIter>
    hash_multimap(InIter first, InIter last,
        key_compare^ pred, hasher^ hashfn);
hash_multimap(System::Collections::Generic::IEnumerable<GValue>^ right);
hash_multimap(System::Collections::Generic::IEnumerable<GValue>^ right,
    key_compare^ pred);
hash_multimap(System::Collections::Generic::IEnumerable<GValue>^ right,
    key_compare^ pred, hasher^ hashfn);

Parámetros

first
Principio del intervalo que se va a insertar.

hashfn
Función hash para asignar claves a cubos.

last
Fin del intervalo que se va a insertar.

pred
Predicado de ordenación de la secuencia controlada.

right
Objeto o intervalo que se va a insertar.

Comentarios

El constructor:

hash_multimap();

inicializa la secuencia controlada sin elementos, con el predicado de ordenación predeterminado key_compare() y con la función hash predeterminada. Se usa para especificar una secuencia controlada inicial vacía, con el predicado de ordenación predeterminado y la función hash.

El constructor:

explicit hash_multimap(key_compare^ pred);

inicializa la secuencia controlada sin elementos, con el predicado predde ordenación y con la función hash predeterminada. Se usa para especificar una secuencia controlada inicial vacía, con el predicado de ordenación especificado y la función hash predeterminada.

El constructor:

hash_multimap(key_compare^ pred, hasher^ hashfn);

inicializa la secuencia controlada sin elementos, con el predicado predde ordenación y con la función hashfnhash . Se usa para especificar una secuencia controlada inicial vacía, con el predicado de ordenación especificado y la función hash.

El constructor:

hash_multimap(hash_multimap<Key, Mapped>% right);

inicializa la secuencia controlada con la secuencia [right.begin(), right.end()), con el predicado de ordenación predeterminado y con la función hash predeterminada. Se usa para especificar una secuencia controlada inicial que es una copia de la secuencia controlada por el hash_multimap objeto right, con el predicado de ordenación predeterminado y la función hash.

El constructor:

hash_multimap(hash_multimap<Key, Mapped>^ right);

inicializa la secuencia controlada con la secuencia [right->begin(), right->end()), con el predicado de ordenación predeterminado y con la función hash predeterminada. Se usa para especificar una secuencia controlada inicial que es una copia de la secuencia controlada por el hash_multimap objeto right, con el predicado de ordenación predeterminado y la función hash.

El constructor:

template<typename InIter> hash_multimap(InIter first, InIter last);

inicializa la secuencia controlada con la secuencia [first, last), con el predicado de ordenación predeterminado y con la función hash predeterminada. Se usa para convertir la secuencia controlada en una copia de otra secuencia, con el predicado de ordenación predeterminado y la función hash.

El constructor:

template<typename InIter> hash_multimap(InIter first, InIter last, key_compare^ pred);

inicializa la secuencia controlada con la secuencia [first, last), con el predicado predde ordenación y con la función hash predeterminada. Se usa para convertir la secuencia controlada en una copia de otra secuencia, con el predicado de ordenación especificado y la función hash predeterminada.

El constructor:

template<typename InIter> hash_multimap(InIter first, InIter last, key_compare^ pred, hasher^ hashfn);

inicializa la secuencia controlada con la secuencia [first, last), con el predicado predde ordenación y con la función hashfnhash . Se usa para convertir la secuencia controlada en una copia de otra secuencia, con el predicado de ordenación especificado y la función hash.

El constructor:

hash_multimap(System::Collections::Generic::IEnumerable<Key>^ right);

inicializa la secuencia controlada con la secuencia designada por el enumerador right, con el predicado de ordenación predeterminado y con la función hash predeterminada. Se usa para convertir la secuencia controlada en una copia de otra secuencia descrita por un enumerador, con el predicado de ordenación predeterminado y la función hash.

El constructor:

hash_multimap(System::Collections::Generic::IEnumerable<Key>^ right, key_compare^ pred);

inicializa la secuencia controlada con la secuencia designada por el enumerador right, con el predicado predde ordenación y con la función hash predeterminada. Se usa para convertir la secuencia controlada en una copia de otra secuencia descrita por un enumerador, con el predicado de ordenación especificado y la función hash predeterminada.

El constructor:

hash_multimap(System::Collections::Generic::IEnumerable<Key>^ right, key_compare^ pred, hasher^ hashfn);

inicializa la secuencia controlada con la secuencia designada por el enumerador right, con el predicado predde ordenación y con la función hashfnhash . Se usa para convertir la secuencia controlada en una copia de otra secuencia descrita por un enumerador, con el predicado de ordenación especificado y la función hash.

Ejemplo

// cliext_hash_multimap_construct.cpp
// compile with: /clr
#include <cliext/hash_map>

int myfun(wchar_t key)
    { // hash a key
    return (key ^ 0xdeadbeef);
    }

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
// construct an empty container
    Myhash_multimap c1;
    System::Console::WriteLine("size() = {0}", c1.size());

    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an ordering rule
    Myhash_multimap c2 = cliext::greater_equal<wchar_t>();
    System::Console::WriteLine("size() = {0}", c2.size());

    c2.insert(c1.begin(), c1.end());
    for each (Myhash_multimap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an ordering rule and hash function
    Myhash_multimap c2h(cliext::greater_equal<wchar_t>(),
        gcnew Myhash_multimap::hasher(&myfun));
    System::Console::WriteLine("size() = {0}", c2h.size());

    c2h.insert(c1.begin(), c1.end());
    for each (Myhash_multimap::value_type elem in c2h)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    System::Console::WriteLine();

    // construct with an iterator range
    Myhash_multimap c3(c1.begin(), c1.end());
    for each (Myhash_multimap::value_type elem in c3)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an iterator range and an ordering rule
    Myhash_multimap c4(c1.begin(), c1.end(),
        cliext::greater_equal<wchar_t>());
    for each (Myhash_multimap::value_type elem in c4)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an iterator range and an ordering rule and hash function
    Myhash_multimap c4h(c1.begin(), c1.end(),
        cliext::greater_equal<wchar_t>(),
        gcnew Myhash_multimap::hasher(&myfun));
    for each (Myhash_multimap::value_type elem in c4h)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    System::Console::WriteLine();

    // construct with an enumeration
    Myhash_multimap c5(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<
            Myhash_multimap::value_type>^)%c3);
    for each (Myhash_multimap::value_type elem in c5)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an enumeration and an ordering rule
    Myhash_multimap c6(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<
            Myhash_multimap::value_type>^)%c3,
                cliext::greater_equal<wchar_t>());
    for each (Myhash_multimap::value_type elem in c6)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct with an enumeration and an ordering rule and hash function
    Myhash_multimap c6h(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<
            Myhash_multimap::value_type>^)%c3,
                cliext::greater_equal<wchar_t>(),
                gcnew Myhash_multimap::hasher(&myfun));
    for each (Myhash_multimap::value_type elem in c6h)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    System::Console::WriteLine();

    // construct by copying another container
    Myhash_multimap c7(c4);
    for each (Myhash_multimap::value_type elem in c7)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct by copying a container handle
    Myhash_multimap c8(%c3);
    for each (Myhash_multimap::value_type elem in c8)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

size() = 0
[a 1] [b 2] [c 3]
size() = 0
[a 1] [b 2] [c 3]
size() = 0
[c 3] [b 2] [a 1]

[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[c 3] [b 2] [a 1]

[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]
[c 3] [b 2] [a 1]

[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]

`hash_multimap::hasher`

Delegado de hash de una clave.

Sintaxis

Microsoft::VisualC::StlClr::UnaryDelegate<GKey, int>
    hasher;

Comentarios

El tipo describe un delegado que convierte un valor de clave en un entero.

Ejemplo

// cliext_hash_multimap_hasher.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    Myhash_multimap::hasher^ myhash = c1.hash_delegate();

    System::Console::WriteLine("hash(L'a') = {0}", myhash(L'a'));
    System::Console::WriteLine("hash(L'b') = {0}", myhash(L'b'));
    return (0);
    }

hash(L'a') = 1616896120
hash(L'b') = 570892832

`hash_multimap::insert`

Agrega elementos.

Sintaxis

iterator insert(value_type val);
iterator insert(iterator where, value_type val);
template<typename InIter>
    void insert(InIter first, InIter last);
void insert(System::Collections::Generic::IEnumerable<value_type>^ right);

Parámetros

first
Principio del intervalo que se va a insertar.

last
Fin del intervalo que se va a insertar.

right
Enumeración que se va a insertar.

val
Valor de clave que se va a insertar.

where
Lugar en el que se realizará la inserción en el contenedor (solo sugerencia).

Comentarios

Cada una de las funciones miembro inserta una secuencia especificada por los operandos restantes.

La primera función miembro inserta un elemento con el valor valy devuelve un iterador que designa el elemento recién insertado. Se usa para insertar un solo elemento.

La segunda función miembro inserta un elemento con el valor val, utilizando where como sugerencia (para mejorar el rendimiento) y devuelve un iterador que designa el elemento recién insertado. Se usa para insertar un único elemento que podría estar junto a un elemento que conoce.

La tercera función miembro inserta la secuencia [first, last). Se usa para insertar cero o más elementos copiados de otra secuencia.

La cuarta función miembro inserta la secuencia designada por .right Se usa para insertar una secuencia descrita por un enumerador.

Cada inserción de elementos tarda un tiempo proporcional al logaritmo del número de elementos de la secuencia controlada. La inserción puede producirse en tiempo constante amortizado, sin embargo, dada una sugerencia que designa un elemento junto al punto de inserción.

Ejemplo

// cliext_hash_multimap_insert.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // insert a single value, unique and duplicate
    Myhash_multimap::iterator it =
        c1.insert(Myhash_multimap::make_value(L'x', 24));
    System::Console::WriteLine("insert([L'x' 24]) = [{0} {1}]",
        it->first, it->second);

    it = c1.insert(Myhash_multimap::make_value(L'b', 2));
    System::Console::WriteLine("insert([L'b' 2]) = [{0} {1}]",
        it->first, it->second);

    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // insert a single value with hint
    it = c1.insert(c1.begin(), Myhash_multimap::make_value(L'y', 25));
    System::Console::WriteLine("insert(begin(), [L'y' 25]) = [{0} {1}]",
        it->first, it->second);
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // insert an iterator range
    Myhash_multimap c2;
    it = c1.end();
    c2.insert(c1.begin(), --it);
    for each (Myhash_multimap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // insert an enumeration
    Myhash_multimap c3;
    c3.insert(   // NOTE: cast is not needed
        (System::Collections::Generic::
            IEnumerable<Myhash_multimap::value_type>^)%c1);
    for each (Myhash_multimap::value_type elem in c3)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
insert([L'x' 24]) = [x 24]
insert([L'b' 2]) = [b 2]
[a 1] [b 2] [b 2] [c 3] [x 24]
insert(begin(), [L'y' 25]) = [y 25]
[a 1] [b 2] [b 2] [c 3] [x 24] [y 25]
[a 1] [b 2] [b 2] [c 3] [x 24]
[a 1] [b 2] [b 2] [c 3] [x 24] [y 25]

`hash_multimap::iterator`

El tipo de un iterador para la secuencia controlada.

Sintaxis

typedef T1 iterator;

Comentarios

El tipo describe un objeto de tipo sin especificar T1 que puede actuar como un iterador bidireccional de la secuencia controlada.

Ejemplo

// cliext_hash_multimap_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Myhash_multimap::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        System::Console::Write("[{0} {1}] ", it->first, it->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]

`hash_multimap::key_comp`

Copia el delegado de ordenación de dos claves.

Sintaxis

key_compare^key_comp();

Comentarios

La función miembro devuelve el delegado de ordenación que se usa para ordenar la secuencia controlada. Se usa para comparar dos claves.

Ejemplo

// cliext_hash_multimap_key_comp.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    Myhash_multimap::key_compare^ kcomp = c1.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();

    // test a different ordering rule
    Myhash_multimap c2 = cliext::greater<wchar_t>();
    kcomp = c2.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    return (0);
    }

compare(L'a', L'a') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False

compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True

`hash_multimap::key_compare`

Delegado de ordenación para dos claves.

Sintaxis

Microsoft::VisualC::StlClr::BinaryDelegate<GKey, GKey, bool>
    key_compare;

Comentarios

El tipo es un sinónimo del delegado que determina la ordenación de sus argumentos de clave.

Ejemplo

// cliext_hash_multimap_key_compare.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    Myhash_multimap::key_compare^ kcomp = c1.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    System::Console::WriteLine();

    // test a different ordering rule
    Myhash_multimap c2 = cliext::greater<wchar_t>();
    kcomp = c2.key_comp();

    System::Console::WriteLine("compare(L'a', L'a') = {0}",
        kcomp(L'a', L'a'));
    System::Console::WriteLine("compare(L'a', L'b') = {0}",
        kcomp(L'a', L'b'));
    System::Console::WriteLine("compare(L'b', L'a') = {0}",
        kcomp(L'b', L'a'));
    return (0);
    }

compare(L'a', L'a') = True
compare(L'a', L'b') = True
compare(L'b', L'a') = False

compare(L'a', L'a') = False
compare(L'a', L'b') = False
compare(L'b', L'a') = True

`hash_multimap::key_type`

El tipo de una clave de ordenación.

Sintaxis

typedef Key key_type;

Comentarios

El tipo es un sinónimo del parámetro de plantilla Key.

Ejemplo

// cliext_hash_multimap_key_type.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" using key_type
    for (Myhash_multimap::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in key_type object
        Myhash_multimap::key_type val = it->first;

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

`hash_multimap::load_factor`

Cuenta los elementos promedio por depósito.

Sintaxis

float load_factor();

Comentarios

La función miembro devuelve (float)size() / bucket_count(). Se usa para determinar el tamaño medio del depósito.

Ejemplo

// cliext_hash_multimap_load_factor.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1 = gcnew Myhash_multimap;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }

[a 1] [b 2] [c 3]
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

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

`hash_multimap::lower_bound`

Busca el principio del intervalo que coincide con una clave especificada.

Sintaxis

iterator lower_bound(key_type key);

Parámetros

key
Valor de clave que se va a buscar.

Comentarios

La función miembro determina el primer elemento X de la secuencia controlada que aplica hash al mismo cubo key que y tiene un orden equivalente a key. Si no existe este elemento, devuelve hash_multimap::end(); de lo contrario, devuelve un iterador que designa X. Se usa para localizar el inicio de una secuencia de elementos que están actualmente en la secuencia controlada que coincide con una clave especificada.

Ejemplo

// cliext_hash_multimap_lower_bound.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("lower_bound(L'x')==end() = {0}",
        c1.lower_bound(L'x') == c1.end());

    Myhash_multimap::iterator it = c1.lower_bound(L'a');
    System::Console::WriteLine("*lower_bound(L'a') = [{0} {1}]",
        it->first, it->second);
    it = c1.lower_bound(L'b');
    System::Console::WriteLine("*lower_bound(L'b') = [{0} {1}]",
        it->first, it->second);
    return (0);
    }

[a 1] [b 2] [c 3]
lower_bound(L'x')==end() = True
*lower_bound(L'a') = [a 1]
*lower_bound(L'b') = [b 2]

`hash_multimap::make_value`

Construye un objeto de valor.

Sintaxis

static value_type make_value(key_type key, mapped_type mapped);

Parámetros

key
Valor de clave que se va a usar.

mapped
Valor asignado que se va a buscar.

Comentarios

La función miembro devuelve un value_type objeto cuya clave es key y cuyo valor asignado es mapped. Se usa para componer un objeto adecuado para su uso con otras funciones miembro.

Ejemplo

// cliext_hash_multimap_make_value.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]

`hash_multimap::mapped_type`

El tipo de un valor asignado asociado a cada clave.

Sintaxis

typedef Mapped mapped_type;

Comentarios

El tipo es un sinónimo del parámetro de plantilla Mapped.

Ejemplo

// cliext_hash_multimap_mapped_type.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" using mapped_type
    for (Myhash_multimap::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in mapped_type object
        Myhash_multimap::mapped_type val = it->second;

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }

1 2 3

`hash_multimap::max_load_factor`

Obtiene o establece los elementos máximos por depósito.

Sintaxis

float max_load_factor();
void max_load_factor(float new_factor);

Parámetros

new_factor
Nuevo factor de carga máxima para almacenar.

Comentarios

La primera función miembro devuelve el factor de carga máxima almacenado actualmente. Se usa para determinar el tamaño máximo medio del cubo.

La segunda función miembro reemplaza el factor de carga máximo del almacén por new_factor. No se produce ningún rehash automático hasta una inserción posterior.

Ejemplo

// cliext_hash_multimap_max_load_factor.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1 = gcnew Myhash_multimap;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }

[a 1] [b 2] [c 3]
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

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

`hash_multimap::operator=`

Reemplaza la secuencia controlada.

Sintaxis

hash_multimap<Key, Mapped>% operator=(hash_multimap<Key, Mapped>% right);

Parámetros

right
Contenedor que se va a copiar.

Comentarios

El operador miembro copia right en el objeto y, a continuación, devuelve *this. Se usa para reemplazar la secuencia controlada por una copia de la secuencia controlada de right.

Ejemplo

// cliext_hash_multimap_operator_as.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // assign to a new container
    Myhash_multimap c2;
    c2 = c1;
// display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
[a 1] [b 2] [c 3]

`hash_multimap::rbegin`

Designa el principio de la secuencia controlada inversa.

Sintaxis

reverse_iterator rbegin();

Comentarios

La función miembro devuelve un iterador inverso que designa el último elemento de la secuencia controlada o apunta inmediatamente después del principio de una secuencia vacía. Por lo tanto, designa el beginning de la secuencia inversa. Se usa para obtener un iterador que designe el current principio de la secuencia controlada vista en orden inverso, pero su estado puede cambiar si cambia la longitud de la secuencia controlada.

Ejemplo

// cliext_hash_multimap_rbegin.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect first two items in reversed sequence
    Myhash_multimap::reverse_iterator rit = c1.rbegin();
    System::Console::WriteLine("*rbegin() = [{0} {1}]",
        rit->first, rit->second);
    ++rit;
    System::Console::WriteLine("*++rbegin() = [{0} {1}]",
        rit->first, rit->second);
    return (0);
    }

[a 1] [b 2] [c 3]
*rbegin() = [c 3]
*++rbegin() = [b 2]

`hash_multimap::reference`

El tipo de una referencia a un elemento.

Sintaxis

typedef value_type% reference;

Comentarios

El tipo describe una referencia a un elemento.

Ejemplo

// cliext_hash_multimap_reference.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    Myhash_multimap::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        {   // get a reference to an element
        Myhash_multimap::reference ref = *it;
        System::Console::Write("[{0} {1}] ", ref->first, ref->second);
        }
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]

`hash_multimap::rehash`

Recompila la tabla hash.

Sintaxis

void rehash();

Comentarios

La función miembro vuelve a generar la tabla hash, asegurándose de que load_factor() <= max_load_factor(). De lo contrario, la tabla hash aumenta de tamaño solo según sea necesario después de una inserción. (Nunca disminuye automáticamente el tamaño). Se usa para ajustar el tamaño de la tabla hash.

Ejemplo

// cliext_hash_multimap_rehash.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1 = gcnew Myhash_multimap;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect current parameters
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // change max_load_factor and redisplay
    c1.max_load_factor(0.25f);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    System::Console::WriteLine();

    // rehash and redisplay
    c1.rehash(100);
    System::Console::WriteLine("bucket_count() = {0}", c1.bucket_count());
    System::Console::WriteLine("load_factor() = {0}", c1.load_factor());
    System::Console::WriteLine("max_load_factor() = {0}",
        c1.max_load_factor());
    return (0);
    }

[a 1] [b 2] [c 3]
bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 4

bucket_count() = 16
load_factor() = 0.1875
max_load_factor() = 0.25

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

`hash_multimap::rend`

Designa el final de la secuencia controlada inversa.

Sintaxis

reverse_iterator rend();

Comentarios

La función miembro devuelve un iterador inverso que apunta inmediatamente después del principio de la secuencia controlada. Por lo tanto, designa el end de la secuencia inversa. Se usa para obtener un iterador que designe el current final de la secuencia controlada vista en orden inverso, pero su estado puede cambiar si cambia la longitud de la secuencia controlada.

Ejemplo

// cliext_hash_multimap_rend.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // inspect first two items in reversed sequence
    Myhash_multimap::reverse_iterator rit = c1.rend();
    --rit;
    --rit;
    System::Console::WriteLine("*-- --rend() = [{0} {1}]",
        rit->first, rit->second);
    ++rit;
    System::Console::WriteLine("*--rend() = [{0} {1}]",
        rit->first, rit->second);
    return (0);
    }

[a 1] [b 2] [c 3]
*-- --rend() = [b 2]
*--rend() = [a 1]

`hash_multimap::reverse_iterator`

El tipo de un iterador invertido para la secuencia controlada.

Sintaxis

typedef T3 reverse_iterator;

Comentarios

El tipo describe un objeto de tipo sin especificar T3 que puede actuar como un iterador inverso de la secuencia controlada.

Ejemplo

// cliext_hash_multimap_reverse_iterator.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" reversed
    Myhash_multimap::reverse_iterator rit = c1.rbegin();
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("[{0} {1}] ", rit->first, rit->second);
    System::Console::WriteLine();
    return (0);
    }

[c 3] [b 2] [a 1]

`hash_multimap::size`

Cuenta el número de elementos.

Sintaxis

size_type size();

Comentarios

La función miembro devuelve la longitud de la secuencia controlada. Se usa para determinar el número de elementos que están actualmente en la secuencia controlada. Si todo lo que le interesa es si la secuencia tiene un tamaño distinto de cero, consulte hash_multimap::empty().

Ejemplo

// cliext_hash_multimap_size.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0} after clearing", c1.size());

    // add elements and clear again
    c1.insert(Myhash_multimap::make_value(L'd', 4));
    c1.insert(Myhash_multimap::make_value(L'e', 5));
    System::Console::WriteLine("size() = {0} after adding 2", c1.size());
    return (0);
    }

[a 1] [b 2] [c 3]
size() = 0 after clearing
size() = 2 after adding 2

`hash_multimap::size_type`

El tipo de una distancia con signo entre dos elementos.

Sintaxis

typedef int size_type;

Comentarios

El tipo describe un recuento de elementos no negativo.

Ejemplo

// cliext_hash_multimap_size_type.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // compute positive difference
    Myhash_multimap::size_type diff = 0;
    for (Myhash_multimap::iterator it = c1.begin(); it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);
    return (0);
    }

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

`hash_multimap::swap`

Intercambia el contenido de dos contenedores.

Sintaxis

void swap(hash_multimap<Key, Mapped>% right);

Parámetros

right
Contenedor con el que se va a intercambiar el contenido.

Comentarios

La función miembro intercambia las secuencias controladas entre this y right. Lo hace en tiempo constante y no inicia ninguna excepción. Se usa como una manera rápida de intercambiar el contenido de dos contenedores.

Ejemplo

// cliext_hash_multimap_swap.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // construct another container with repetition of values
    Myhash_multimap c2;
    c2.insert(Myhash_multimap::make_value(L'd', 4));
    c2.insert(Myhash_multimap::make_value(L'e', 5));
    c2.insert(Myhash_multimap::make_value(L'f', 6));
    for each (Myhash_multimap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // swap and redisplay
    c1.swap(c2);
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    for each (Myhash_multimap::value_type elem in c2)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]
[d 4] [e 5] [f 6]
[d 4] [e 5] [f 6]
[a 1] [b 2] [c 3]

`hash_multimap::to_array`

Copia la secuencia controlada en una nueva matriz.

Sintaxis

cli::array<value_type>^ to_array();

Comentarios

La función miembro devuelve una matriz que contiene la secuencia controlada. Se usa para obtener una copia de la secuencia controlada en forma de matriz.

Ejemplo

// cliext_hash_multimap_to_array.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // copy the container and modify it
    cli::array<Myhash_multimap::value_type>^ a1 = c1.to_array();

    c1.insert(Myhash_multimap::make_value(L'd', 4));
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    // display the earlier array copy
    for each (Myhash_multimap::value_type elem in a1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3] [d 4]
[a 1] [b 2] [c 3]

`hash_multimap::upper_bound`

Busca el final del intervalo que coincide con una clave especificada.

Sintaxis

iterator upper_bound(key_type key);

Parámetros

key
Valor de clave que se va a buscar.

Comentarios

La función miembro determina el último elemento X de la secuencia controlada que aplica hash al mismo cubo key que y tiene un orden equivalente a key. Si no existe ningún elemento de este tipo o si X es el último elemento de la secuencia controlada, devuelve hash_multimap::end(); de lo contrario, devuelve un iterador que designa el primer elemento más allá Xde . Se usa para localizar el final de una secuencia de elementos que están actualmente en la secuencia controlada que coincide con una clave especificada.

Ejemplo

// cliext_hash_multimap_upper_bound.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]"
    for each (Myhash_multimap::value_type elem in c1)
        System::Console::Write("[{0} {1}] ", elem->first, elem->second);
    System::Console::WriteLine();

    System::Console::WriteLine("upper_bound(L'x')==end() = {0}",
        c1.upper_bound(L'x') == c1.end());

    Myhash_multimap::iterator it = c1.upper_bound(L'a');
    System::Console::WriteLine("*upper_bound(L'a') = [{0} {1}]",
        it->first, it->second);
    it = c1.upper_bound(L'b');
    System::Console::WriteLine("*upper_bound(L'b') = [{0} {1}]",
        it->first, it->second);
    return (0);
    }

[a 1] [b 2] [c 3]
upper_bound(L'x')==end() = True
*upper_bound(L'a') = [b 2]
*upper_bound(L'b') = [c 3]

`hash_multimap::value_comp`

Copia el delegado de ordenación de dos valores de elementos.

Sintaxis

value_compare^ value_comp();

Comentarios

La función miembro devuelve el delegado de ordenación que se usa para ordenar la secuencia controlada. Se usa para comparar dos valores de elementos.

Ejemplo

// cliext_hash_multimap_value_comp.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    Myhash_multimap::value_compare^ kcomp = c1.value_comp();

    System::Console::WriteLine("compare([L'a', 1], [L'a', 1]) = {0}",
        kcomp(Myhash_multimap::make_value(L'a', 1),
            Myhash_multimap::make_value(L'a', 1)));
    System::Console::WriteLine("compare([L'a', 1], [L'b', 2]) = {0}",
        kcomp(Myhash_multimap::make_value(L'a', 1),
            Myhash_multimap::make_value(L'b', 2)));
    System::Console::WriteLine("compare([L'b', 2], [L'a', 1]) = {0}",
        kcomp(Myhash_multimap::make_value(L'b', 2),
            Myhash_multimap::make_value(L'a', 1)));
    System::Console::WriteLine();
    return (0);
    }

compare([L'a', 1], [L'a', 1]) = True
compare([L'a', 1], [L'b', 2]) = True
compare([L'b', 2], [L'a', 1]) = False

`hash_multimap::value_compare`

Delegado de ordenación de dos valores de elementos.

Sintaxis

Microsoft::VisualC::StlClr::BinaryDelegate<generic_value, generic_value, bool>
    value_compare;

Comentarios

El tipo es un sinónimo del delegado que determina la ordenación de sus argumentos de valores.

Ejemplo

// cliext_hash_multimap_value_compare.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_map<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    Myhash_multimap::value_compare^ kcomp = c1.value_comp();

    System::Console::WriteLine("compare([L'a', 1], [L'a', 1]) = {0}",
        kcomp(Myhash_multimap::make_value(L'a', 1),
            Myhash_multimap::make_value(L'a', 1)));
    System::Console::WriteLine("compare([L'a', 1], [L'b', 2]) = {0}",
        kcomp(Myhash_multimap::make_value(L'a', 1),
            Myhash_multimap::make_value(L'b', 2)));
    System::Console::WriteLine("compare([L'b', 2], [L'a', 1]) = {0}",
        kcomp(Myhash_multimap::make_value(L'b', 2),
            Myhash_multimap::make_value(L'a', 1)));
    System::Console::WriteLine();
    return (0);
    }

compare([L'a', 1], [L'a', 1]) = True
compare([L'a', 1], [L'b', 2]) = True
compare([L'b', 2], [L'a', 1]) = False

`hash_multimap::value_type`

El tipo de un elemento.

Sintaxis

typedef generic_value value_type;

Comentarios

El tipo es un sinónimo de generic_value.

Ejemplo

// cliext_hash_multimap_value_type.cpp
// compile with: /clr
#include <cliext/hash_map>

typedef cliext::hash_multimap<wchar_t, int> Myhash_multimap;
int main()
    {
    Myhash_multimap c1;
    c1.insert(Myhash_multimap::make_value(L'a', 1));
    c1.insert(Myhash_multimap::make_value(L'b', 2));
    c1.insert(Myhash_multimap::make_value(L'c', 3));

    // display contents " [a 1] [b 2] [c 3]" using value_type
    for (Myhash_multimap::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in value_type object
        Myhash_multimap::value_type val = *it;
        System::Console::Write("[{0} {1}] ", val->first, val->second);
        }
    System::Console::WriteLine();
    return (0);
    }

[a 1] [b 2] [c 3]

Compartir a través de

hash_multimap (STL/CLR)

Sintaxis

Parámetros

Requisitos

Declaraciones

Interfaces

Comentarios

Miembros

hash_multimap::begin

Sintaxis

Comentarios

Ejemplo

hash_multimap::bucket_count

Sintaxis

Comentarios

Ejemplo

hash_multimap::clear

Sintaxis

Comentarios

Ejemplo

hash_multimap::const_iterator

Sintaxis

Comentarios

Ejemplo

hash_multimap::const_reference

Sintaxis

Comentarios

Ejemplo

hash_multimap::const_reverse_iterator

Sintaxis

Comentarios

Ejemplo

hash_multimap::count

Sintaxis

Parámetros

Comentarios

Ejemplo

hash_multimap::d ifference_type

Sintaxis

Comentarios

Ejemplo

hash_multimap::empty

Sintaxis

Comentarios

Ejemplo

hash_multimap::end

Sintaxis

Comentarios

Ejemplo

hash_multimap::equal_range

Sintaxis

Parámetros

Comentarios

Ejemplo

hash_multimap::erase

Sintaxis

Parámetros

Comentarios

Ejemplo

hash_multimap::find

Sintaxis

Parámetros

Comentarios

Ejemplo

hash_multimap::generic_container

Sintaxis

Comentarios

Ejemplo

hash_multimap::generic_iterator

Sintaxis

Comentarios

Ejemplo

hash_multimap::generic_reverse_iterator

Sintaxis

Comentarios

Ejemplo

hash_multimap::generic_value

Sintaxis

Comentarios

`hash_multimap` (STL/CLR)

`hash_multimap::find`

`hash_multimap::generic_container`

`hash_multimap::generic_iterator`

`hash_multimap::generic_reverse_iterator`

`hash_multimap::generic_value`

`hash_multimap::hash_delegate`

`hash_multimap::hash_multimap`

`hash_multimap::hasher`

`hash_multimap::insert`

`hash_multimap::iterator`

`hash_multimap::key_comp`

`hash_multimap::key_compare`

`hash_multimap::key_type`

`hash_multimap::load_factor`

`hash_multimap::lower_bound`

`hash_multimap::make_value`

`hash_multimap::mapped_type`

`hash_multimap::max_load_factor`

`hash_multimap::operator=`

`hash_multimap::rbegin`

`hash_multimap::reference`