unordered_multiset (Clase)unordered_multiset Class

La plantilla de clase describe un objeto que controla una secuencia de elementos de longitud variable de tipo const Key .The class template describes an object that controls a varying-length sequence of elements of type const Key. La secuencia está ordenada débilmente por una función hash, que divide la secuencia en un conjunto ordenado subsecuencias denominadas depósitos.The sequence is weakly ordered by a hash function, which partitions the sequence into an ordered set of subsequences called buckets. Dentro de cada depósito una función de comparación determina si algún par de elementos tiene una ordenación equivalente.Within each bucket a comparison function determines whether any pair of elements has equivalent ordering. Cada elemento actúa como clave de ordenación y como valor.Each element serves as both a sort key and a value. 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.The sequence is represented in a way that permits lookup, insertion, and removal of an arbitrary element with a number of operations that can be independent of the number of elements in the sequence (constant time), at least when all buckets are of roughly equal length. 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).In the worst case, when all of the elements are in one bucket, the number of operations is proportional to the number of elements in the sequence (linear time). 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.Moreover, inserting an element invalidates no iterators, and removing an element invalidates only those iterators which point at the removed element.

SintaxisSyntax

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

ParámetrosParameters

ClaveKey
El tipo de clave.The key type.

LMHash
El tipo de objeto de la función hash.The hash function object type.

PronosticaPred
El tipo de objeto de función de comparación de igualdad.The equality comparison function object type.

AllocAlloc
Clase de asignador.The allocator class.

MiembrosMembers

Definición de tipoType Definition DescripciónDescription
allocator_typeallocator_type El tipo de un asignador para administrar el almacenamiento.The type of an allocator for managing storage.
const_iteratorconst_iterator El tipo de un iterador constante para la secuencia controlada.The type of a constant iterator for the controlled sequence.
const_local_iteratorconst_local_iterator El tipo de un iterador de depósito constante para la secuencia controlada.The type of a constant bucket iterator for the controlled sequence.
const_pointerconst_pointer El tipo de un puntero constante a un elemento.The type of a constant pointer to an element.
const_referenceconst_reference El tipo de una referencia constante a un elemento.The type of a constant reference to an element.
difference_typedifference_type El tipo de una distancia con signo entre dos elementos.The type of a signed distance between two elements.
Hasherhasher El tipo de la función hash.The type of the hash function.
apuntaiterator El tipo de un iterador para la secuencia controlada.The type of an iterator for the controlled sequence.
key_equalkey_equal El tipo de la función de comparación.The type of the comparison function.
key_typekey_type El tipo de una clave de ordenación.The type of an ordering key.
local_iteratorlocal_iterator El tipo de un iterador de depósito para la secuencia controlada.The type of a bucket iterator for the controlled sequence.
punteropointer El tipo de un puntero a un elemento.The type of a pointer to an element.
referencereference El tipo de una referencia a un elemento.The type of a reference to an element.
size_typesize_type El tipo de una distancia sin signo entre dos elementos.The type of an unsigned distance between two elements.
value_typevalue_type El tipo de un elemento.The type of an element.
Función miembroMember Function DescripciónDescription
iniciabegin Designa el principio de la secuencia controlada.Designates the beginning of the controlled sequence.
bucketbucket Obtiene el número de depósito para un valor de clave.Gets the bucket number for a key value.
bucket_countbucket_count Obtiene el número de depósitos.Gets the number of buckets.
bucket_sizebucket_size Obtiene el tamaño de un depósito.Gets the size of a bucket.
cbegincbegin Designa el principio de la secuencia controlada.Designates the beginning of the controlled sequence.
cendcend Designa el final de la secuencia controlada.Designates the end of the controlled sequence.
clearclear Quita todos los elementos.Removes all elements.
contienec++ 20containsC++20 Comprueba si hay un elemento con la clave especificada.Checks if there's an element with the specified key.
countcount Busca el número de elementos que coinciden con una clave especificada.Finds the number of elements matching a specified key.
emplaceemplace Agrega un elemento construido en contexto.Adds an element constructed in place.
emplace_hintemplace_hint Agrega un elemento construido en contexto, con sugerencia.Adds an element constructed in place, with hint.
emptyempty Comprueba si no hay ningún elemento presente.Tests whether no elements are present.
endend Designa el final de la secuencia controlada.Designates the end of the controlled sequence.
equal_rangeequal_range Busca el intervalo que coincide con una clave especificada.Finds range that matches a specified key.
eraseerase Quita los elementos de las posiciones especificadas.Removes elements at specified positions.
findfind Busca un elemento que coincide con una clave especificada.Finds an element that matches a specified key.
get_allocatorget_allocator Obtiene el objeto de asignador almacenado.Gets the stored allocator object.
hash_functionhash_function Obtiene el objeto de función hash almacenado.Gets the stored hash function object.
insertinsert Agrega elementos.Adds elements.
key_eqkey_eq Obtiene el objeto de función de comparación almacenado.Gets the stored comparison function object.
load_factorload_factor Cuenta los elementos promedio por depósito.Counts the average elements per bucket.
max_bucket_countmax_bucket_count Obtiene el número máximo de depósitos.Gets the maximum number of buckets.
max_load_factormax_load_factor Obtiene o establece los elementos máximos por depósito.Gets or sets the maximum elements per bucket.
max_sizemax_size Obtiene el tamaño máximo de la secuencia controlada.Gets the maximum size of the controlled sequence.
rehash (rehash Recompila la tabla hash.Rebuilds the hash table.
sizesize Cuenta el número de elementos.Counts the number of elements.
swapswap Intercambia el contenido de dos contenedores.Swaps the contents of two containers.
unordered_multisetunordered_multiset Construye un objeto contenedor.Constructs a container object.
OperatorOperator DescripciónDescription
unordered_multiset:: Operator =unordered_multiset::operator= Copia una tabla hash.Copies a hash table.

ObservacionesRemarks

El objeto ordena la secuencia que controla llamando a dos objetos almacenados, un objeto de función de comparación de tipo unordered_multiset::key_equal y un objeto de función hash de tipo unordered_multiset::hasher.The object orders the sequence it controls by calling two stored objects, a comparison function object of type unordered_multiset::key_equal and a hash function object of type unordered_multiset::hasher. Tiene acceso al primer objeto almacenado llamando a la función miembro unordered_multiset:: key_eq () ; y tiene acceso al segundo objeto almacenado llamando a la función miembro unordered_multiset:: hash_function () .You access the first stored object by calling the member function unordered_multiset::key_eq(); and you access the second stored object by calling the member function unordered_multiset::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.Specifically, for all values X and Y of type Key, the call key_eq()(X, Y) returns true only if the two argument values have equivalent ordering; the call hash_function()(keyval) yields a distribution of values of type size_t. A diferencia de la clase de unordered_setde plantilla de clase, un objeto de tipo no unordered_multiset garantiza que key_eq()(X, Y) sea siempre false para dos elementos cualesquiera de la secuencia controlada.Unlike class template unordered_set Class, an object of type unordered_multiset does not ensure that key_eq()(X, Y) is always false for any two elements of the controlled sequence. (No es necesario que las claves sean únicas).(Keys need not be unique.)

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.The object also stores a maximum load factor, which specifies the maximum desired average number of elements per bucket. Si la inserción de un elemento hace que unordered_multiset:: load_factor () supere el factor de carga máximo, el contenedor aumenta el número de cubos y vuelve a generar la tabla hash según sea necesario.If inserting an element causes unordered_multiset::load_factor() to exceed the maximum load factor, the container increases the number of buckets and rebuilds the hash table as needed.

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.The actual order of elements in the controlled sequence depends on the hash function, the comparison function, the order of insertion, the maximum load factor, and the current number of buckets. En general no se puede predecir el orden de los elementos de la secuencia controlada.You cannot in general predict the order of elements in the controlled sequence. Sin embargo, siempre se puede asegurar que cualquier subconjunto de elementos que tengan una ordenación equivalente son adyacentes en la secuencia controlada.You can always be assured, however, that any subset of elements that have equivalent ordering are adjacent in the controlled sequence.

El objeto asigna y libera almacenamiento para la secuencia que controla a través de un objeto asignador almacenado de tipo unordered_multiset::allocator_type.The object allocates and frees storage for the sequence it controls through a stored allocator object of type unordered_multiset::allocator_type. Dicho objeto de asignador debe tener la misma interfaz externa que un objeto de tipo allocator .Such an allocator object must have the same external interface as an object of type allocator. Tenga en cuenta que el objeto de asignador almacenado no se copia cuando se asigna el objeto contenedor.Note that the stored allocator object is not copied when the container object is assigned.

RequisitosRequirements

Encabezado:<unordered_set>Header: <unordered_set>

Espacio de nombres: stdNamespace: std

unordered_multiset:: allocator_typeunordered_multiset::allocator_type

El tipo de un asignador para administrar el almacenamiento.The type of an allocator for managing storage.

typedef Alloc allocator_type;

ObservacionesRemarks

El tipo es un sinónimo del parámetro de plantilla Alloc.The type is a synonym for the template parameter Alloc.

EjemploExample

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

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

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

    return (0);
}
al == std::allocator() is true

unordered_multiset:: Beginunordered_multiset::begin

Designa el principio de la secuencia controlada o un depósito.Designates the beginning of the controlled sequence or a bucket.

iterator begin();

const_iterator begin() const;

local_iterator begin(size_type nbucket);

const_local_iterator begin(size_type nbucket) const;

ParámetrosParameters

nbucketnbucket
Número de depósito.The bucket number.

ObservacionesRemarks

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).The first two member functions return a forward iterator that points at the first element of the sequence (or just beyond the end of an empty sequence). Las dos últimas funciones miembro devuelven un iterador hacia delante que apunta al primer elemento del depósito nbucket (o justo más allá del final de un depósito vacío).The last two member functions return a forward iterator that points at the first element of bucket nbucket (or just beyond the end of an empty bucket).

EjemploExample

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

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

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

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

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

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

    return (0);
}
[c] [b] [a]
[c] [b]
[a]

unordered_multiset:: bucketunordered_multiset::bucket

Obtiene el número de depósito para un valor de clave.Gets the bucket number for a key value.

size_type bucket(const Key& keyval) const;

ParámetrosParameters

keyvalkeyval
Valor de clave que se va a asignar.The key value to map.

ObservacionesRemarks

La función miembro devuelve el número de depósito que corresponde actualmente al valor de clave keyval.The member function returns the bucket number currently corresponding to the key value keyval.

EjemploExample

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

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

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

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

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

    return (0);
}
[c] [b] [a]
bucket('a') == 7
bucket_size(7) == 1

unordered_multiset:: bucket_countunordered_multiset::bucket_count

Obtiene el número de depósitos.Gets the number of buckets.

size_type bucket_count() const;

ObservacionesRemarks

La función miembro devuelve el número actual de depósitos.The member function returns the current number of buckets.

EjemploExample

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

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

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

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

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

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

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

    return (0);
}
[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4

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

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

unordered_multiset:: bucket_sizeunordered_multiset::bucket_size

Obtiene el tamaño de un depósito.Gets the size of a bucket

size_type bucket_size(size_type nbucket) const;

ParámetrosParameters

nbucketnbucket
Número de depósito.The bucket number.

ObservacionesRemarks

Las funciones miembro devuelven el tamaño del número de depósito nbucket.The member functions returns the size of bucket number nbucket.

EjemploExample

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

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

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

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

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

    return (0);
}
[c] [b] [a]
bucket('a') == 7
bucket_size(7) == 1

unordered_multiset:: cbegin (unordered_multiset::cbegin

Devuelve un const iterador que direcciona el primer elemento del intervalo.Returns a const iterator that addresses the first element in the range.

const_iterator cbegin() const;

Valor devueltoReturn Value

Un const iterador 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() ).A const forward-access iterator that points at the first element of the range, or the location just beyond the end of an empty range (for an empty range, cbegin() == cend()).

ObservacionesRemarks

Con el valor devuelto de cbegin, los elementos del intervalo no se pueden modificar.With the return value of cbegin, the elements in the range cannot be modified.

Se puede usar esta función miembro en lugar de la función miembro begin() para garantizar que el valor devuelto es const_iterator.You can use this member function in place of the begin() member function to guarantee that the return value is const_iterator. Normalmente, se usa junto con la palabra clave de deducción de tipos auto, como se muestra en el ejemplo siguiente.Typically, it's used in conjunction with the auto type deduction keyword, as shown in the following example. En el ejemplo, considere Container ser un contenedor modificable (no const ) de cualquier tipo que admita begin() y cbegin() .In the example, consider Container to be a modifiable (non- const) container of any kind that supports begin() and cbegin().

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

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

unordered_multiset:: cendunordered_multiset::cend

Devuelve un const iterador que direcciona la ubicación situada más allá del último elemento de un intervalo.Returns a const iterator that addresses the location just beyond the last element in a range.

const_iterator cend() const;

Valor devueltoReturn Value

Un const iterador de acceso hacia delante que apunta justo después del final del intervalo.A const forward-access iterator that points just beyond the end of the range.

ObservacionesRemarks

cend se usa para probar si un iterador ha sobrepasado el final de su intervalo.cend is used to test whether an iterator has passed the end of its range.

Se puede usar esta función miembro en lugar de la función miembro end() para garantizar que el valor devuelto es const_iterator.You can use this member function in place of the end() member function to guarantee that the return value is const_iterator. Normalmente, se usa junto con la palabra clave de deducción de tipos auto, como se muestra en el ejemplo siguiente.Typically, it's used in conjunction with the auto type deduction keyword, as shown in the following example. En el ejemplo, considere Container ser un contenedor modificable (no const ) de cualquier tipo que admita end() y cend() .In the example, consider Container to be a modifiable (non- const) container of any kind that supports end() and 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.The value returned by cend should not be dereferenced.

unordered_multiset:: Clearunordered_multiset::clear

Quita todos los elementos.Removes all elements.

void clear();

ObservacionesRemarks

La función miembro llama a unordered_multiset::erase( unordered_multiset::begin(), unordered_multiset::end()).The member function calls unordered_multiset::erase( unordered_multiset::begin(), unordered_multiset::end()).

EjemploExample

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

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

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

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

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

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

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

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

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

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

unordered_multiset:: const_iteratorunordered_multiset::const_iterator

El tipo de un iterador constante para la secuencia controlada.The type of a constant iterator for the controlled sequence.

typedef T1 const_iterator;

ObservacionesRemarks

El tipo describe un objeto que puede actuar como un iterador de avance constante de la secuencia controlada.The type describes an object that can serve as a constant forward iterator for the controlled sequence. Aquí se describe como sinónimo del tipo definido por implementación T1.It is described here as a synonym for the implementation-defined type T1.

EjemploExample

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

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

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

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

    return (0);
}
[c] [b] [a]

unordered_multiset:: const_local_iteratorunordered_multiset::const_local_iterator

El tipo de un iterador de depósito constante para la secuencia controlada.The type of a constant bucket iterator for the controlled sequence.

typedef T5 const_local_iterator;

ObservacionesRemarks

El tipo describe un objeto que puede actuar como iterador constante hacia delante para un depósito.The type describes an object that can serve as a constant forward iterator for a bucket. Aquí se describe como sinónimo del tipo definido por implementación T5.It is described here as a synonym for the implementation-defined type T5.

EjemploExample

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

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

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

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

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

    return (0);
}
[c] [b] [a]
[a]

unordered_multiset:: const_pointerunordered_multiset::const_pointer

El tipo de un puntero constante a un elemento.The type of a constant pointer to an element.

typedef Alloc::const_pointer const_pointer;

ObservacionesRemarks

El tipo describe un objeto que puede actuar como puntero constante a un elemento de la secuencia controlada.The type describes an object that can serve as a constant pointer to an element of the controlled sequence.

EjemploExample

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

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

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

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

    return (0);
}
[c] [b] [a]

unordered_multiset:: const_referenceunordered_multiset::const_reference

El tipo de una referencia constante a un elemento.The type of a constant reference to an element.

typedef Alloc::const_reference const_reference;

ObservacionesRemarks

El tipo describe un objeto que puede actuar como referencia constante a un elemento de la secuencia controlada.The type describes an object that can serve as a constant reference to an element of the controlled sequence.

EjemploExample

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

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

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

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

    return (0);
}
[c] [b] [a]

unordered_multiset:: Containsunordered_multiset::contains

Comprueba si hay un elemento con la clave especificada en unordered_multiset .Checks if there's an element with the specified key in the unordered_multiset.

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

ParámetrosParameters

KK
Tipo de la clave.The type of the key.

clavekey
Valor de clave del elemento que se va a buscar.The element's key value to look for.

Valor devueltoReturn Value

true Si el elemento se encuentra en el contenedor; false en caso contrario,.true if the element is found in the container; false otherwise.

ObservacionesRemarks

contains() es nuevo en C++ 20.contains() is new in C++20. Para usarlo, especifique la opción del compilador /STD: c + + latest .To use it, specify the /std:c++latest compiler option.

template<class K> bool contains(const K& key) const solo participa en la resolución de sobrecarga si key_compare es transparente.template<class K> bool contains(const K& key) const only participates in overload resolution if key_compare is transparent.

EjemploExample

// Requires /std:c++latest
#include <unordered_set>
#include <iostream>

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

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

    return 0;
}
true
false

unordered_multiset:: Countunordered_multiset::count

Busca el número de elementos que coinciden con una clave especificada.Finds the number of elements matching a specified key.

size_type count(const Key& keyval) const;

ParámetrosParameters

keyvalkeyval
Valor de clave que se va a buscar.Key value to search for.

ObservacionesRemarks

La función miembro devuelve el número de elementos del intervalo delimitado por unordered_multiset:: equal_range (keyval) .The member function returns the number of elements in the range delimited by unordered_multiset::equal_range(keyval).

EjemploExample

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

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

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

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

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

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

unordered_multiset::d ifference_typeunordered_multiset::difference_type

El tipo de una distancia con signo entre dos elementos.The type of a signed distance between two elements.

typedef T3 difference_type;

ObservacionesRemarks

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.The signed integer type describes an object that can represent the difference between the addresses of any two elements in the controlled sequence. Aquí se describe como sinónimo del tipo definido por implementación T3.It is described here as a synonym for the implementation-defined type T3.

EjemploExample

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

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

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

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

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

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

    return (0);
}
[c] [b] [a]
end()-begin() == 3
begin()-end() == -3

unordered_multiset:: Emplaceunordered_multiset::emplace

Inserta un elemento construido en contexto (no se realiza ninguna operación de copia o de movimiento).Inserts an element constructed in place (no copy or move operations are performed).

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

ParámetrosParameters

argsargs
Argumentos reenviados para construir un elemento que se va a insertar en el unordered_multiset.The arguments forwarded to construct an element to be inserted into the unordered_multiset.

Valor devueltoReturn Value

Iterador al elemento recién insertado.An iterator to the newly inserted element.

ObservacionesRemarks

Esta función no invalida ninguna referencia a elementos contenedores, pero puede invalidar todos los iteradores al contenedor.No references to container elements are invalidated by this function, but it may invalidate all iterators to the container.

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.During the insertion, if an exception is thrown but does not occur in the container's hash function, the container is not modified. Si la excepción se produce en la función hash, el resultado es indefinido.If the exception is thrown in the hash function, the result is undefined.

Para obtener un ejemplo de código, vea multiset::emplace.For a code example, see multiset::emplace.

unordered_multiset:: emplace_hintunordered_multiset::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.Inserts an element constructed in place (no copy or move operations are performed), with a placement hint.

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

ParámetrosParameters

argsargs
Argumentos reenviados para construir un elemento que se va a insertar en el unordered_multiset.The arguments forwarded to construct an element to be inserted into the unordered_multiset.

mientraswhere
Sugerencia con respecto al lugar donde se va a empezar a buscar el punto correcto de inserción.A hint regarding the place to start searching for the correct point of insertion.

Valor devueltoReturn Value

Iterador al elemento recién insertado.An iterator to the newly inserted element.

ObservacionesRemarks

Esta función no invalida ninguna referencia a elementos contenedores, pero puede invalidar todos los iteradores al contenedor.No references to container elements are invalidated by this function, but it may invalidate all iterators to the container.

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.During the insertion, if an exception is thrown but does not occur in the container's hash function, the container is not modified. Si la excepción se produce en la función hash, el resultado es indefinido.If the exception is thrown in the hash function, the result is undefined.

Para obtener un ejemplo de código, vea set::emplace_hint.For a code example, see set::emplace_hint.

unordered_multiset:: Emptyunordered_multiset::empty

Comprueba si no hay ningún elemento presente.Tests whether no elements are present.

bool empty() const;

ObservacionesRemarks

La función miembro devuelve true para una secuencia controlada vacía.The member function returns true for an empty controlled sequence.

EjemploExample

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

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

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

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

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

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

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

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

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

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

unordered_multiset:: endunordered_multiset::end

Designa el final de la secuencia controlada.Designates the end of the controlled sequence.

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

ParámetrosParameters

nbucketnbucket
Número de depósito.The bucket number.

ObservacionesRemarks

Las dos primeras funciones miembro devuelven un iterador hacia delante que apunta inmediatamente después del final de la secuencia.The first two member functions return a forward iterator that points just beyond the end of the sequence. Las dos últimas funciones miembro devuelven un iterador hacia delante que apunta inmediatamente después del final del nbucketde cubo.The last two member functions return a forward iterator that points just beyond the end of bucket nbucket.

EjemploExample

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

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

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

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

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

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

    return (0);
}
[c] [b] [a]
[a] [b]
[a]

unordered_multiset:: equal_rangeunordered_multiset::equal_range

Busca el intervalo que coincide con una clave especificada.Finds range that matches a specified key.

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

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

ParámetrosParameters

keyvalkeyval
Valor de clave que se va a buscar.Key value to search for.

ObservacionesRemarks

La función miembro devuelve un par de iteradores X que [X.first, X.second) delimitan solo los elementos de la secuencia controlada que tienen una ordenación equivalente con keyval.The member function returns a pair of iterators X such that [X.first, X.second) delimits just those elements of the controlled sequence that have equivalent ordering with keyval. Si no hay elementos de este tipo, los dos iteradores son end().If no such elements exist, both iterators are end().

EjemploExample

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

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

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

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

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

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

    return (0);
}
[c] [b] [a]
equal_range('x'):
equal_range('b'): [b]

unordered_multiset:: Eraseunordered_multiset::erase

Quita un elemento o un intervalo de elementos de un unordered_multiset de las posiciones especificadas o quita los elementos que coinciden con una clave especificada.Removes an element or a range of elements in a unordered_multiset from specified positions or removes elements that match a specified key.

iterator erase(
    const_iterator Where);

iterator erase(
    const_iterator First,
    const_iterator Last);

size_type erase(
    const key_type& Key);

ParámetrosParameters

MientrasWhere
Posición del elemento que se va a quitar.Position of the element to be removed.

LugarFirst
Posición del primer elemento que se va a quitar.Position of the first element to be removed.

GuardadoLast
Posición situada más allá del último elemento que se va a quitar.Position just beyond the last element to be removed.

ClaveKey
Valor de clave de los elementos que se van a quitar.The key value of the elements to be removed.

Valor devueltoReturn Value

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 unordered_multiset si no existe ese elemento.For the first two member functions, a bidirectional iterator that designates the first element remaining beyond any elements removed, or an element that is the end of the unordered_multiset if no such element exists.

Para la tercera función miembro, devuelve el número de elementos que se han quitado de unordered_multiset.For the third member function, returns the number of elements that have been removed from the unordered_multiset.

ObservacionesRemarks

Para obtener un ejemplo de código, vea set::erase.For a code example, see set::erase.

unordered_multiset:: Findunordered_multiset::find

Busca un elemento que coincide con una clave especificada.Finds an element that matches a specified key.

const_iterator find(const Key& keyval) const;

ParámetrosParameters

keyvalkeyval
Valor de clave que se va a buscar.Key value to search for.

ObservacionesRemarks

La función miembro devuelve unordered_multiset:: equal_range (keyval).first .The member function returns unordered_multiset::equal_range(keyval).first.

EjemploExample

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

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

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

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

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

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

    return (0);
}
[c] [b] [a]
find('A') == false
find('b') == true: [b]

unordered_multiset:: get_allocatorunordered_multiset::get_allocator

Obtiene el objeto de asignador almacenado.Gets the stored allocator object.

Alloc get_allocator() const;

ObservacionesRemarks

La función miembro devuelve el objeto de asignador almacenado.The member function returns the stored allocator object.

EjemploExample

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

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

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

    return (0);
}
al == std::allocator() is true

unordered_multiset:: hash_functionunordered_multiset::hash_function

Obtiene el objeto de función hash almacenado.Gets the stored hash function object.

Hash hash_function() const;

ObservacionesRemarks

La función miembro devuelve el objeto de función hash almacenado.The member function returns the stored hash function object.

EjemploExample

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

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

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

    return (0);
}
hfn('a') == 1630279
hfn('b') == 1647086

unordered_multiset:: Hasherunordered_multiset::hasher

El tipo de la función hash.The type of the hash function.

typedef Hash hasher;

ObservacionesRemarks

El tipo es un sinónimo del parámetro de plantilla Hash.The type is a synonym for the template parameter Hash.

EjemploExample

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

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

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

    return (0);
}
hfn('a') == 1630279
hfn('b') == 1647086

unordered_multiset:: Insertunordered_multiset::insert

Inserta un elemento o un intervalo de elementos en un unordered_multiset.Inserts an element or a range of elements into an unordered_multiset.

// (1) single element
pair<iterator, bool> insert(
    const value_type& Val);

// (2) single element, perfect forwarded
template <class ValTy>
pair<iterator, bool>
insert(
    ValTy&& Val);

// (3) single element with hint
iterator insert(
    const_iterator Where,
    const value_type& Val);

// (4) single element, perfect forwarded, with hint
template <class ValTy>
iterator insert(
    const_iterator Where,
    ValTy&& Val);

// (5) range
template <class InputIterator>
void insert(
    InputIterator First,
    InputIterator Last);

// (6) initializer list
void insert(
    initializer_list<value_type>
IList);

ParámetrosParameters

ValVal
Valor de un elemento que se va a insertar en el unordered_multiset.The value of an element to be inserted into the unordered_multiset.

MientrasWhere
Lugar donde se va a iniciar la búsqueda del punto de inserción correcto.The place to start searching for the correct point of insertion.

ValTyValTy
Parámetro de plantilla que especifica el tipo de argumento que el unordered_multiset puede usar para construir un elemento de value_typey reenvía de forma perfecta el Val como argumento.Template parameter that specifies the argument type that the unordered_multiset can use to construct an element of value_type, and perfect-forwards Val as an argument.

LugarFirst
Posición del primer elemento que se va a copiar.The position of the first element to be copied.

GuardadoLast
Posición situada más allá del último elemento que se va a copiar.The position just beyond the last element to be copied.

InputIteratorInputIterator
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.Template function argument that meets the requirements of an input iterator that points to elements of a type that can be used to construct value_type objects.

IListIList
El elemento initializer_list del que se van a copiar los elementos.The initializer_list from which to copy the elements.

Valor devueltoReturn Value

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_multiset.The single-element-insert member functions, (1) and (2), return an iterator to the position where the new element was inserted into the unordered_multiset.

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_multiset.The single-element-with-hint member functions, (3) and (4), return an iterator that points to the position where the new element was inserted into the unordered_multiset.

ObservacionesRemarks

Esta función no invalida ningún puntero ni ninguna referencia, pero puede invalidar todos los iteradores al contenedor.No pointers or references are invalidated by this function, but it may invalidate all iterators to the container.

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.During the insertion of just one element, if an exception is thrown but does not occur in the container's hash function, the container's state is not modified. Si la excepción se produce en la función hash, el resultado es indefinido.If the exception is thrown in the hash function, the result is undefined. 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.During the insertion of multiple elements, if an exception is thrown, the container is left in an unspecified but valid state.

El objeto value_type de un contenedor es una definición de tipo que pertenece al contenedor y, para set, unordered_multiset<V>::value_type es de tipo const V.The value_type of a container is a typedef that belongs to the container, and, for set, unordered_multiset<V>::value_type is type const V.

La función miembro de intervalo (5) inserta la secuencia de valores de elemento en una unordered_multiset que corresponde a cada elemento direccionado por un iterador en el intervalo [First, Last) ; por tanto, Last no se inserta.The range member function (5) inserts the sequence of element values into an unordered_multiset that corresponds to each element addressed by an iterator in the range [First, Last); therefore, Last does not get inserted. 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.The container member function end() refers to the position just after the last element in the container—for example, the statement m.insert(v.begin(), v.end()); inserts all elements of v into m.

La función miembro de lista de inicializadores (6) usa una initializer_list para copiar los elementos al unordered_multiset.The initializer list member function (6) uses an initializer_list to copy elements into the unordered_multiset.

Para la inserción de un elemento construido en contexto (es decir, no se realiza ninguna operación de copia o movimiento), vea unordered_multiset::emplace y unordered_multiset::emplace_hint.For insertion of an element constructed in place—that is, no copy or move operations are performed—see unordered_multiset::emplace and unordered_multiset::emplace_hint.

Para obtener un ejemplo de código, vea multiset::insert.For a code example, see multiset::insert.

unordered_multiset:: iteratorunordered_multiset::iterator

Tipo que proporciona un iterador hacia delante constante que puede leer elementos en un unordered_multiset.A type that provides a constant forward iterator that can read elements in an unordered_multiset.

typedef implementation-defined iterator;

EjemploExample

Vea el ejemplo de begin para obtener un ejemplo de cómo declarar y usar un iterador.See the example for begin for an example of how to declare and use an iterator.

unordered_multiset:: key_equnordered_multiset::key_eq

Obtiene el objeto de función de comparación almacenado.Gets the stored comparison function object.

Pred key_eq() const;

ObservacionesRemarks

La función miembro devuelve el objeto de función de comparación almacenado.The member function returns the stored comparison function object.

EjemploExample

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

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

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

    return (0);
}
cmpfn('a', 'a') == true
cmpfn('a', 'b') == false

unordered_multiset:: key_equalunordered_multiset::key_equal

El tipo de la función de comparación.The type of the comparison function.

typedef Pred key_equal;

ObservacionesRemarks

El tipo es un sinónimo del parámetro de plantilla Pred.The type is a synonym for the template parameter Pred.

EjemploExample

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

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

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

    return (0);
}
cmpfn('a', 'a') == true
cmpfn('a', 'b') == false

unordered_multiset:: key_typeunordered_multiset::key_type

El tipo de una clave de ordenación.The type of an ordering key.

typedef Key key_type;

ObservacionesRemarks

El tipo es un sinónimo del parámetro de plantilla Key.The type is a synonym for the template parameter Key.

EjemploExample

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

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

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

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

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

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

    return (0);
}
[c] [b] [a]
[d] [c] [b] [a]

unordered_multiset:: load_factorunordered_multiset::load_factor

Cuenta los elementos promedio por depósito.Counts the average elements per bucket.

float load_factor() const;

ObservacionesRemarks

La función miembro devuelve (float) unordered_multiset:: Size () / (float) unordered_multiset:: bucket_count () , el promedio de elementos por depósito.The member function returns (float)unordered_multiset::size() / (float)unordered_multiset::bucket_count(), the average number of elements per bucket.

EjemploExample

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

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

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

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

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

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

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

    return (0);
}

unordered_multiset:: local_iteratorunordered_multiset::local_iterator

Tipo de un iterador de depósito.The type of a bucket iterator.

typedef T4 local_iterator;

ObservacionesRemarks

El tipo describe un objeto que puede actuar como iterador hacia delante para un depósito.The type describes an object that can serve as a forward iterator for a bucket. Aquí se describe como sinónimo del tipo definido por implementación T4.It is described here as a synonym for the implementation-defined type T4.

EjemploExample

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

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

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

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

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

    return (0);
}
[c] [b] [a]
[a]

unordered_multiset:: max_bucket_countunordered_multiset::max_bucket_count

Obtiene el número máximo de depósitos.Gets the maximum number of buckets.

size_type max_bucket_count() const;

ObservacionesRemarks

La función miembro devuelve el número máximo de depósitos que se admiten actualmente.The member function returns the maximum number of buckets currently permitted.

EjemploExample

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

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

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

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

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

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

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

    return (0);
}
[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4

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

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

unordered_multiset:: max_load_factorunordered_multiset::max_load_factor

Obtiene o establece los elementos máximos por depósito.Gets or sets the maximum elements per bucket.

float max_load_factor() const;

void max_load_factor(float factor);

ParámetrosParameters

diezfactor
El nuevo factor de carga máxima.The new maximum load factor.

ObservacionesRemarks

La primera función miembro devuelve el factor de carga máxima almacenado.The first member function returns the stored maximum load factor. La segunda función miembro reemplaza el factor de carga máximo almacenado por factor.The second member function replaces the stored maximum load factor with factor.

EjemploExample

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

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

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

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

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

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

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

    return (0);
}
[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_bucket_count() == 8
max_load_factor() == 4

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

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

unordered_multiset:: max_sizeunordered_multiset::max_size

Obtiene el tamaño máximo de la secuencia controlada.Gets the maximum size of the controlled sequence.

size_type max_size() const;

ObservacionesRemarks

La función miembro devuelve la longitud de la secuencia más larga que puede controlar el objeto.The member function returns the length of the longest sequence that the object can control.

EjemploExample

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

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

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

    return (0);
}
max_size() == 4294967295

unordered_multiset:: Operator =unordered_multiset::operator=

Copia una tabla hash.Copies a hash table.

unordered_multiset& operator=(const unordered_multiset& right);

unordered_multiset& operator=(unordered_multiset&& right);

ParámetrosParameters

correctaright
El unordered_multiset que se copia en el unordered_multiset.The unordered_multiset being copied into the unordered_multiset.

ObservacionesRemarks

Después de borrar los elementos existentes en un unordered_multiset , operator= copia o mueve el contenido de a la derecha unordered_multiset .After erasing any existing elements in an unordered_multiset, operator= either copies or moves the contents of right into the unordered_multiset.

EjemploExample

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

int main( )
{
    using namespace std;
    unordered_multiset<int> v1, v2, v3;
    unordered_multiset<int>::iterator iter;

    v1.insert(10);

    cout << "v1 = " ;
    for (iter = v1.begin(); iter != v1.end(); iter++)
        cout << *iter << " ";
    cout << endl;

    v2 = v1;
    cout << "v2 = ";
    for (iter = v2.begin(); iter != v2.end(); iter++)
        cout << *iter << " ";
    cout << endl;

    // move v1 into v2
    v2.clear();
    v2 = move(v1);
    cout << "v2 = ";
    for (iter = v2.begin(); iter != v2.end(); iter++)
        cout << *iter << " ";
    cout << endl;
}

unordered_multiset::p ointerunordered_multiset::pointer

El tipo de un puntero a un elemento.The type of a pointer to an element.

typedef Alloc::pointer pointer;

ObservacionesRemarks

El tipo describe un objeto que puede actuar como puntero a un elemento de la secuencia controlada.The type describes an object that can serve as a pointer to an element of the controlled sequence.

EjemploExample

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

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

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

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

    return (0);
}
[c] [b] [a]

unordered_multiset:: Referenceunordered_multiset::reference

El tipo de una referencia a un elemento.The type of a reference to an element.

typedef Alloc::reference reference;

ObservacionesRemarks

El tipo describe un objeto que puede actuar como referencia a un elemento de la secuencia controlada.The type describes an object that can serve as a reference to an element of the controlled sequence.

EjemploExample

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

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

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

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

    return (0);
}
[c] [b] [a]

unordered_multiset:: rehashunordered_multiset::rehash

Recompila la tabla hash.Rebuilds the hash table.

void rehash(size_type nbuckets);

ParámetrosParameters

nbucketsnbuckets
Número solicitado de depósitos.The requested number of buckets.

ObservacionesRemarks

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.The member function alters the number of buckets to be at least nbuckets and rebuilds the hash table as needed.

EjemploExample

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

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

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

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

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

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

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

    return (0);
}
[c] [b] [a]
bucket_count() == 8
load_factor() == 0.375
max_load_factor() == 4

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

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

unordered_multiset:: Sizeunordered_multiset::size

Cuenta el número de elementos.Counts the number of elements.

size_type size() const;

ObservacionesRemarks

La función miembro devuelve la longitud de la secuencia controlada.The member function returns the length of the controlled sequence.

EjemploExample

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

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

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

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

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

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

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

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

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

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

unordered_multiset:: size_typeunordered_multiset::size_type

El tipo de una distancia sin signo entre dos elementos.The type of an unsigned distance between two elements.

typedef T2 size_type;

ObservacionesRemarks

El tipo de entero sin signo describe un objeto que puede representar la longitud de cualquier secuencia controlada.The unsigned integer type describes an object that can represent the length of any controlled sequence. Aquí se describe como sinónimo del tipo definido por implementación T2.It is described here as a synonym for the implementation-defined type T2.

EjemploExample

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

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

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

    return (0);
}
size == 0

unordered_multiset:: swapunordered_multiset::swap

Intercambia el contenido de dos contenedores.Swaps the contents of two containers.

void swap(unordered_multiset& right);

ParámetrosParameters

correctaright
El contenedor con el que se intercambia.The container to swap with.

ObservacionesRemarks

La función miembro intercambia las secuencias controladas entre *this y a la derecha.The member function swaps the controlled sequences between *this and right. Si unordered_multiset:: 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 ninguna referencia, puntero o iterador que designen elementos en las dos secuencias controladas de.If unordered_multiset::get_allocator() == right.get_allocator(), it does so in constant time, it throws an exception only as a result of copying the stored traits object of type Tr, and it invalidates no references, pointers, or iterators that designate elements in the two controlled sequences. De lo contrario, realiza varias asignaciones de elementos y llamadas de constructor proporcionales al número de elementos de ambas secuencias controladas.Otherwise, it performs a number of element assignments and constructor calls proportional to the number of elements in the two controlled sequences.

EjemploExample

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

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

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

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

    Myset c2;

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

    c1.swap(c2);

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

    swap(c1, c2);

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

    return (0);
}
[c] [b] [a]
[f] [e] [d]
[c] [b] [a]

unordered_multiset:: unordered_multisetunordered_multiset::unordered_multiset

Construye un objeto contenedor.Constructs a container object.

unordered_multiset(
    const unordered_multiset& Right);

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

unordered_multiset(
    unordered_multiset&& Right);

unordered_set(
    initializer_list<Type> IList);

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

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

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

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

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

ParámetrosParameters

InputIteratorInputIterator
Tipo de iterador.The iterator type.

AlabamaAl
Objeto de asignador que se va a almacenar.The allocator object to store.

COMPComp
Objeto de función de comparación que se va a almacenar.The comparison function object to store.

LMHash
Objeto de función hash que se va a almacenar.The hash function object to store.

Bucket_countBucket_count
Número mínimo de depósitos.The minimum number of buckets.

CorrectaRight
Contenedor que se va a copiar.The container to copy.

IListIList
initializer_list de la que se va a copiar.The initializer_list from which to copy.

ObservacionesRemarks

El primer constructor especifica una copia de la secuencia controlada por la derecha.The first constructor specifies a copy of the sequence controlled by Right. El segundo constructor especifica una secuencia controlada vacía.The second constructor specifies an empty controlled sequence. El tercer constructor inserta la secuencia de valores de elemento [First, Last).The third constructor inserts the sequence of element values [First, Last). El cuarto constructor especifica una copia de la secuencia moviendo right.The fourth constructor specifies a copy of the sequence by moving Right.

Todos los constructores también inicializan varios valores almacenados.All constructors also initialize several stored values. En el constructor de copias, los valores se obtienen de la derecha.For the copy constructor, the values are obtained from Right. De lo contrario:Otherwise:

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 definido por la implementación N0 .The minimum number of buckets is the argument Bucket_count, if present; otherwise it is a default value described here as the implementation-defined value N0.

El objeto de función hash es el hashde argumento, si está presente; en caso contrario, es Hash() .The hash function object is the argument Hash, if present; otherwise it is Hash().

El objeto de función de comparación es el argumento COMP, si está presente; en caso contrario, es Comp() .The comparison function object is the argument Comp, if present; otherwise it is Comp().

El objeto de asignador es el argumento al, si está presente; de lo contrario, es Alloc() .The allocator object is the argument Al, if present; otherwise, it is Alloc().

unordered_multiset:: value_typeunordered_multiset::value_type

El tipo de un elemento.The type of an element.

typedef Key value_type;

ObservacionesRemarks

El tipo describe un elemento de la secuencia controlada.The type describes an element of the controlled sequence.

EjemploExample

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

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

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

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

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

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

    return (0);
}
[c] [b] [a]
[d] [c] [b] [a]

Vea tambiénSee also

<unordered_set><unordered_set>
ContainerContainers
Seguridad para subprocesos en la biblioteca estándar de C++Thread Safety in the C++ Standard Library
Referencia de la biblioteca estándar de C++C++ Standard Library Reference