Clase multiset

La clase multiset de la Biblioteca estándar de C++ se usa para el almacenamiento y la recuperación de datos de una colección en la que los valores de los elementos contenidos no tienen por qué ser únicos y en la que actúan como valores de clave según los cuales los datos se ordenan automáticamente. El valor de clave de un elemento de multiset no se puede cambiar directamente. En su lugar, se deben eliminar los valores anteriores e insertar elementos con valores nuevos.

Sintaxis

template <class Key, class Compare =less <Key>, class Allocator =allocator <Key>>
class multiset

Parámetros

Key
Tipo de datos de elementos que se va a almacenar en la multiset.

Compare
Tipo que proporciona un objeto de función que puede comparar dos valores de elemento como claves de ordenación para determinar su orden relativo en multiset . El predicado binario menos Key es el valor > predeterminado.

En C++14, puede habilitar la búsqueda heterogéneo especificando el predicado o que std::less<> no tiene parámetros de std::greater<> tipo. Consulte Búsqueda heterogéneo en contenedores asociativos para obtener más información.

Allocator
Tipo que representa el objeto de asignador almacenado que encapsula detalles sobre la asignación y multiset desasignación de memoria de la clase . El valor predeterminado es allocator<Key>.

Comentarios

La clase biblioteca estándar de C++ multiset es:

  • Un contenedor asociativo de tamaño variable que admite la recuperación eficaz de valores de elemento según un valor de clave asociado.

  • Reversible, porque proporciona iteradores bidireccionales para tener acceso a sus elementos.

  • Ordenada, porque sus elementos se ordenan según los valores de clave dentro del contenedor de acuerdo con una función de comparación especificada.

  • Varios en el sentido de que sus elementos no necesitan tener claves únicas, por lo que un valor de clave puede tener muchos valores de elemento asociados.

  • Un contenedor asociativo simple porque sus valores de elemento son sus valores de clave.

  • Plantilla de clase, porque la funcionalidad que proporciona es genérica y, por tanto, independiente del tipo específico de datos contenidos como elementos. En su lugar, el tipo de datos que se usará se especifica como un parámetro en la plantilla de clase junto con la función de comparación y el asignador.

El iterador proporcionado por la clase es un iterador bidireccional, pero las funciones miembro de clase y tienen versiones que toman como parámetros de plantilla un iterador de entrada más débil, cuyos requisitos de funcionalidad son más mínimos que los garantizados por la clase de multisetinsertmultiset iteradores bidireccionales. Los distintos conceptos de iterador forman una familia relacionada por los refinamientos de su funcionalidad. Cada concepto de iterador tiene su propio conjunto de requisitos y los algoritmos que funcionan con ellos deben limitar sus suposiciones a los requisitos proporcionados por ese tipo de iterador. Se puede suponer que se puede desreferenciar un iterador de entrada para hacer referencia a un objeto y que se puede incrementar hasta el iterador siguiente de la secuencia. Se trata de un conjunto mínimo de función, pero es suficiente para poder comunicarse sobre un intervalo de iteradores [ First, Last) en el contexto de las funciones miembro de clase.

En general, la elección del tipo de contenedor se debe tomar según el tipo de búsqueda y de inserción que necesite la aplicación. Los contenedores asociativos están optimizados para las operaciones de búsqueda, inserción y eliminación. Las funciones miembro que admiten explícitamente estas operaciones son eficaces y se hacen en un tiempo que es proporcional en promedio al logaritmo del número de elementos del contenedor. La inserción de elementos no invalida ningún iterador y la eliminación de elementos invalida solo los iteradores que han apuntado a los elementos quitados.

debe ser el contenedor asociativo de su elección cuando la aplicación cumpla las condiciones que asocian los valores multiset a sus claves. Los elementos de un pueden ser varios y actuar como sus propias claves de multiset ordenación, por lo que las claves no son únicas. Un modelo para este tipo de estructura es una lista ordenada, por ejemplo, de palabras en las que las palabras pueden aparecer más de una vez. Si no se permitieran varias repeticiones de las palabras, la estructura de contenedor adecuada sería un set. Si se asociaron definiciones únicas como valores a la lista de palabras clave únicas, la estructura adecuada para contener estos datos sería una clase map. Si, en su lugar, las definiciones no fueran únicas, un sería multimap el contenedor de su elección.

ordena multiset la secuencia que controla llamando a un objeto de función almacenado de tipo Compare . Este objeto almacenado es una función de comparación a la que se puede tener acceso llamando a la función miembro key_comp . En general, los elementos deben ser simplemente menos que comparables para establecer este orden: para que, dados dos elementos cualquiera, se pueda determinar que son equivalentes (en el sentido de que ninguno es menor que el otro) o que uno es menor que el otro. Esto produce una ordenación entre los elementos no equivalentes. En un sentido más técnico, la función de comparación es un predicado binario que induce una ordenación débil estricta en el sentido matemático estándar. Un predicado binario f(x, y) es un objeto de función que tiene dos objetos de argumento x e y y un valor devuelto de o . Una ordenación impuesta en un conjunto es una ordenación débil estricta si el predicado binario es irreflectivo, antisímétrico y transitivo, y si la equivalencia es transitiva, donde dos objetos x e y se definen para ser equivalentes cuando f(x,y) y f(y,x) son false. Si la condición más fuerte de igualdad entre las claves reemplaza la de equivalencia, la ordenación se convierte en total (en el sentido de que todos los elementos se ordenan entre sí) y las claves coincidentes serán indiscernibles unas de otras.

En C++14, puede habilitar la búsqueda heterogéneo especificando el predicado o que std::less<> no tiene parámetros de std::greater<> tipo. Consulte Búsqueda heterogéneo en contenedores asociativos para obtener más información.

Constructores

Constructor Descripción
Multiset Construye un multiset que está vacío o que es una copia de todo o de parte de un multiset especificado.

Typedefs

Nombre de tipo Descripción
allocator_type Definición de tipos para la clase allocator del objeto multiset.
const_iterator Definición de tipos para un iterador bidireccional que puede leer un elemento const del multiset.
const_pointer Definición de tipos para un puntero a un elemento const de un multiset.
const_reference Definición de tipo para una referencia a const un elemento almacenado en para leer y realizar multisetconst operaciones.
const_reverse_iterator Definición de tipos para un iterador bidireccional que puede leer cualquier elemento const del multiset.
difference_type Definición de tipos enteros con signo para el número de elementos de un multiset en un intervalo entre los elementos a los que apuntan los iteradores.
iterator Definición de tipos para un iterador bidireccional que puede leer o modificar cualquier elemento de un multiset.
key_compare Definición de tipos para un objeto de función que puede comparar dos claves para determinar el orden relativo de dos elementos del multiset.
key_type Definición de tipos para un objeto de función que puede comparar dos claves de ordenación para determinar el orden relativo de dos elementos del multiset.
pointer Definición de tipos para un puntero a un elemento de un multiset.
reference Definición de tipos para una referencia a un elemento almacenado en un multiset.
reverse_iterator Definición de tipos para un iterador bidireccional que puede leer o modificar un elemento de un multiset invertido.
size_type Tipo entero sin signo que puede representar el número de elementos de un multiset.
value_compare Definición de tipos para un objeto de función que puede comparar dos elementos como claves de ordenación para determinar su orden relativo en el multiset.
value_type Definición de tipos que describe un objeto almacenado como un elemento como un multiset en su capacidad como valor.

Funciones miembro

Función de miembro Descripción
begin Devuelve un iterador que apunta al primer elemento del multiset.
cbegin Devuelve un iterador const que direcciona el primer elemento del multiset.
cend Devuelve un iterador constante que direcciona la ubicación que sigue al último elemento de multiset.
clear Borra todos los elementos de un multiset.
containscontains Compruebe si hay un elemento con la clave especificada en multiset .
count Devuelve el número de elementos de un multiset cuya clave coincide con la clave especificada como parámetro.
crbegin Devuelve un iterador constante que direcciona el primer elemento de multiset invertido.
crend Devuelve un iterador constante que direcciona la ubicación que sigue al último elemento de multiset invertido.
emplace Inserta en un multiset un elemento construido en contexto.
emplace_hint Inserta en un multiset un elemento construido en contexto, con una sugerencia de colocación.
empty Comprueba si un multiset está vacío.
end Devuelve un iterador que apunta a la ubicación posterior al último elemento de un multiset invertido.
equal_range Devuelve un par de iteradores. El primer iterador del par apunta al primer elemento de un multiset cuya clave es mayor que una clave especificada. El segundo iterador del par apunta al primer elemento del multiset cuya clave es igual o mayor que la clave especificada.
erase Quita un elemento o un intervalo de elementos de una clase multiset de las posiciones especificadas o quita los elementos que coinciden con una clave especificada.
find Devuelve un iterador que apunta a la primera ubicación de un elemento en un multiset que tiene una clave igual que una clave especificada.
get_allocator Devuelve una copia del objeto allocator utilizado para construir el multiset.
insert Inserta un elemento o un intervalo de elementos en un multiset.
key_comp Proporciona un objeto de función que puede comparar dos claves de ordenación para determinar el orden relativo de dos elementos en el multiset.
lower_bound Devuelve un iterador al primer elemento de un multiset cuya clave es igual o mayor que una clave especificada.
max_size Devuelve la longitud máxima del multiset.
rbegin Devuelve un iterador que apunta al primer elemento de un multiset invertido.
rend Devuelve un iterador que apunta a la ubicación posterior al último elemento de un multiset invertido.
size Devuelve el número de elementos de un multiset.
swap Intercambia los elementos de dos multiset.
upper_bound Devuelve un iterador al primer elemento de un multiset con una clave que es mayor que una clave especificada.
value_comp Recupera una copia del objeto de comparación que se emplea para ordenar los valores de elementos de un multiset.

Operadores

Operador Descripción
operator= Reemplaza los elementos de un multiset con una copia de otro multiset.

Requisitos

Rúbrica:

Nombres:

multiset::allocator_type

Tipo que representa la clase de asignador para el multiset objeto

typedef Allocator allocator_type;

Comentarios

allocator_type es un sinónimo del parámetro de plantilla Allocator.

Para obtener más información sobre Allocator, vea la sección Comentarios del tema Allocator.

Ejemplo

Vea el ejemplo para get_allocator obtener un ejemplo mediante allocator_type

multiset::begin

Devuelve un iterador que direcciona el primer elemento del multiset.

const_iterator begin() const;

iterator begin();

Valor devuelto

Iterador bidireccional que direcciona el primer elemento de o la ubicación siguiente multiset a un conjunto múltiple vacío.

Ejemplo

// multiset_begin.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int>::iterator ms1_Iter;
   multiset <int>::const_iterator ms1_cIter;

   ms1.insert( 1 );
   ms1.insert( 2 );
   ms1.insert( 3 );

   ms1_Iter = ms1.begin( );
   cout << "The first element of ms1 is " << *ms1_Iter << endl;

   ms1_Iter = ms1.begin( );
   ms1.erase( ms1_Iter );

   // The following 2 lines would err as the iterator is const
   // ms1_cIter = ms1.begin( );
   // ms1.erase( ms1_cIter );

   ms1_cIter = ms1.begin( );
   cout << "The first element of ms1 is now " << *ms1_cIter << endl;
}
The first element of ms1 is 1
The first element of ms1 is now 2

multiset::cbegin

Devuelve un iterador const que direcciona el primer elemento del intervalo.

const_iterator cbegin() const;

Valor devuelto

Iterador const de acceso bidireccional que apunta al primer elemento del intervalo o la ubicación situada más allá del final de un intervalo vacío (para un intervalo vacío, cbegin() == cend()).

Comentarios

Con el valor devuelto de , no se pueden modificar los elementos cbegin del intervalo.

Se puede usar esta función miembro en lugar de la función miembro begin() para garantizar que el valor devuelto es const_iterator. Normalmente, se usa junto con la palabra clave de deducción de tipos auto, como se muestra en el ejemplo siguiente. En el ejemplo se considera que Container es un contenedor modificable (distinto de const) de cualquier naturaleza que admite begin() y cbegin().

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

// i2 is Container<T>::const_iterator

multiset::cend

Devuelve un iterador const que direcciona la ubicación situada más allá del último elemento de un intervalo.

const_iterator cend() const;

Valor devuelto

Iterador const de acceso bidireccional que apunta justo después del final del intervalo.

Comentarios

cend se usa para probar si un iterador ha sobrepasado el final de su intervalo.

Se puede usar esta función miembro en lugar de la función miembro end() para garantizar que el valor devuelto es const_iterator. Normalmente, se usa junto con la palabra clave de deducción de tipos auto, como se muestra en el ejemplo siguiente. En el ejemplo se considera que Container es un contenedor modificable (distinto de const) de cualquier naturaleza que admite end() y cend().

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

// i2 is Container<T>::const_iterator

El valor devuelto cend por no debe desreferenciarse.

multiset::clear

Borra todos los elementos de un multiset.

void clear();

Ejemplo

// multiset_clear.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;

   ms1.insert( 1 );
   ms1.insert( 2 );

   cout << "The size of the multiset is initially "
        << ms1.size( ) << "." << endl;

   ms1.clear( );
   cout << "The size of the multiset after clearing is "
        << ms1.size( ) << "." << endl;
}
The size of the multiset is initially 2.
The size of the multiset after clearing is 0.

multiset::const_iterator

Tipo que proporciona un iterador bidireccional que puede leer un elemento const en multiset.

typedef implementation-defined const_iterator;

Comentarios

No se const_iterator puede usar un tipo para modificar el valor de un elemento.

Ejemplo

Vea el ejemplo para begin obtener un ejemplo mediante const_iterator .

multiset::const_pointer

Tipo que proporciona un puntero a un elemento const en un multiset.

typedef typename allocator_type::const_pointer const_pointer;

Comentarios

No se const_pointer puede usar un tipo para modificar el valor de un elemento.

En la mayoría de los casos, se debe usar un iterador para tener acceso a los elementos de un objeto .

multiset::const_reference

Tipo que proporciona una referencia a un const elemento almacenado en para leer y realizar multisetconst operaciones.

typedef typename allocator_type::const_reference const_reference;

Ejemplo

// multiset_const_ref.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;

   ms1.insert( 10 );
   ms1.insert( 20 );

   // Declare and initialize a const_reference &Ref1
   // to the 1st element
   const int &Ref1 = *ms1.begin( );

   cout << "The first element in the multiset is "
        << Ref1 << "." << endl;

   // The following line would cause an error because the
   // const_reference can't be used to modify the multiset
   // Ref1 = Ref1 + 5;
}
The first element in the multiset is 10.

multiset::const_reverse_iterator

Tipo que proporciona un iterador bidireccional que puede leer cualquier elemento const en multiset.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Comentarios

Un tipo const_reverse_iterator no puede modificar el valor de un elemento y se usa para recorrer en iteración in multiset reverse.

Ejemplo

Vea el ejemplo para rend obtener un ejemplo de cómo declarar y usar const_reverse_iterator .

multiset::contains

Compruebe si hay un elemento con la clave especificada en multiset .

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

Parámetros

K
Tipo de la clave.

key
Valor clave del elemento que se va a buscar.

Valor devuelto

true si el elemento se encuentra en el contenedor; false Lo contrario.

Comentarios

contains() es nuevo en C++20. Para usarlo, especifique la opción del compilador /std:c++20 o posterior.

template<class K> bool contains(const K& key) const solo participa en la resolución de sobrecargas key_compare si es transparente. Consulte Búsqueda heterogéneo en contenedores asociativos para obtener más información.

Ejemplo

// Requires /std:c++20 or /std:c++latest
#include <set>
#include <iostream>

int main()
{
    std::multiset<int> theMultiSet = {1, 2};

    std::cout << std::boolalpha; // so booleans show as 'true' or 'false'
    std::cout << theMultiSet.contains(2) << '\n';
    std::cout << theMultiSet.contains(3) << '\n';

    return 0;
}
true
false

multiset::count

Devuelve el número de elementos de un multiset cuya clave coincide con una clave especificada por un parámetro.

size_type count(const Key& key) const;

Parámetros

key
Clave de los elementos con los que se va a hacer coincidir desde multiset .

Valor devuelto

Número de elementos de cuya multiset clave de ordenación coincide con la clave de parámetro.

Comentarios

La función miembro devuelve el número de elementos x del intervalo

[ lower_bound( key ), upper_bound( key ) )

Ejemplo

En el ejemplo siguiente se muestra el uso de la multiset función miembro ::count.

// multiset_count.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main()
{
    using namespace std;
    multiset<int> ms1;
    multiset<int>::size_type i;

    ms1.insert(1);
    ms1.insert(1);
    ms1.insert(2);

    // Elements don't need to be unique in multiset,
    // so duplicates are allowed and counted.
    i = ms1.count(1);
    cout << "The number of elements in ms1 with a sort key of 1 is: "
         << i << "." << endl;

    i = ms1.count(2);
    cout << "The number of elements in ms1 with a sort key of 2 is: "
         << i << "." << endl;

    i = ms1.count(3);
    cout << "The number of elements in ms1 with a sort key of 3 is: "
         << i << "." << endl;
}
The number of elements in ms1 with a sort key of 1 is: 2.
The number of elements in ms1 with a sort key of 2 is: 1.
The number of elements in ms1 with a sort key of 3 is: 0.

multiset::crbegin

Devuelve un iterador const que direcciona el primer elemento de un conjunto múltiple invertido.

const_reverse_iterator crbegin() const;

Valor devuelto

Iterador const bidireccional invertido que direcciona el primer elemento de un conjunto múltiple invertido o que direcciona lo que habría sido el último elemento del conjunto múltiple sin invertir.

Comentarios

crbegin se usa con un conjunto múltiple invertido igual que begin se usa con multiset .

Con el valor devuelto de crbegin , el objeto no se puede multiset modificar.

crbegin puede usarse para iterar un objeto multiset hacia atrás.

Ejemplo

// multiset_crbegin.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int>::const_reverse_iterator ms1_crIter;

   ms1.insert( 10 );
   ms1.insert( 20 );
   ms1.insert( 30 );

   ms1_crIter = ms1.crbegin( );
   cout << "The first element in the reversed multiset is "
        << *ms1_crIter << "." << endl;
}
The first element in the reversed multiset is 30.

multiset::crend

Devuelve un iterador const que se dirige a la ubicación que sigue al último elemento de un conjunto múltiple invertido.

const_reverse_iterator crend() const;

Valor devuelto

Iterador bidireccional inverso const que direcciona la ubicación siguiente al último elemento de un conjunto múltiple invertido (la ubicación que había precedido al primer elemento del conjunto múltiple sin invertir).

Comentarios

crend se usa con un conjunto múltiple invertido igual end que se usa con multiset .

Con el valor devuelto de crend , el objeto no se puede multiset modificar.

Se puede utilizar crend para comprobar si un iterador inverso llegó al final de su multiset.

El valor devuelto crend por no debe desreferenciarse.

Ejemplo

// multiset_crend.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main() {
   using namespace std;
   multiset <int> ms1;
   multiset <int>::const_reverse_iterator ms1_crIter;

   ms1.insert( 10 );
   ms1.insert( 20 );
   ms1.insert( 30 );

   ms1_crIter = ms1.crend( ) ;
   ms1_crIter--;
   cout << "The last element in the reversed multiset is "
        << *ms1_crIter << "." << endl;
}

multiset::difference_type

Tipo entero con signo que se puede usar para representar el número de elementos de un multiset en un intervalo entre elementos a los que apuntan los iteradores.

typedef typename allocator_type::difference_type difference_type;

Comentarios

El difference_type es el tipo devuelto al restar o incrementar los iteradores del contenedor. difference_type se suele usar para representar el número de elementos que hay en el intervalo [ first, last) entre los iteradores first y last. Incluye el elemento al que apunta first y el intervalo de elementos que abarca hasta el elemento al que apunta last sin incluirlo.

Aunque está disponible para todos los iteradores que cumplen los requisitos de un iterador de entrada, que incluye la clase de iteradores bidireccionales compatibles con contenedores reversibles como set, la resta entre iteradores solo es compatible con iteradores de acceso aleatorio proporcionados por un contenedor de acceso aleatorio como difference_type vector.

Ejemplo

// multiset_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <set>
#include <algorithm>

int main( )
{
   using namespace std;

   multiset <int> ms1;
   multiset <int>::iterator ms1_Iter, ms1_bIter, ms1_eIter;

   ms1.insert( 20 );
   ms1.insert( 10 );
   ms1.insert( 20 );

   ms1_bIter = ms1.begin( );
   ms1_eIter = ms1.end( );

   multiset <int>::difference_type   df_typ5, df_typ10, df_typ20;

   df_typ5 = count( ms1_bIter, ms1_eIter, 5 );
   df_typ10 = count( ms1_bIter, ms1_eIter, 10 );
   df_typ20 = count( ms1_bIter, ms1_eIter, 20 );

   // The keys, and hence the elements, of a multiset aren't unique
   cout << "The number '5' occurs " << df_typ5
        << " times in multiset ms1.\n";
   cout << "The number '10' occurs " << df_typ10
        << " times in multiset ms1.\n";
   cout << "The number '20' occurs " << df_typ20
        << " times in multiset ms1.\n";

   // Count the number of elements in a multiset
   multiset <int>::difference_type  df_count = 0;
   ms1_Iter = ms1.begin( );
   while ( ms1_Iter != ms1_eIter)
   {
      df_count++;
      ms1_Iter++;
   }

   cout << "The number of elements in the multiset ms1 is: "
        << df_count << "." << endl;
}
The number '5' occurs 0 times in multiset ms1.
The number '10' occurs 1 times in multiset ms1.
The number '20' occurs 2 times in multiset ms1.
The number of elements in the multiset ms1 is: 3.

multiset::emplace

Inserta un elemento construido en contexto (no se realiza ninguna operación de copia o de movimiento), con una sugerencia de colocación.

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

Parámetros

args
Argumentos reenviados para construir un elemento que se va a insertar en multiset .

Valor devuelto

Iterador al elemento recién insertado.

Comentarios

Esta función no invalida ninguna referencia a elementos contenedores, pero puede invalidar todos los iteradores al contenedor.

Durante la instalación, si se produce una excepción, el estado del contenedor no se modifica.

Ejemplo

// multiset_emplace.cpp
// compile with: /EHsc
#include <set>
#include <string>
#include <iostream>

using namespace std;

template <typename S> void print(const S& s) {
    cout << s.size() << " elements: ";

    for (const auto& p : s) {
        cout << "(" << p << ") ";
    }

    cout << endl;
}

int main()
{
    multiset<string> s1;

    s1.emplace("Anna");
    s1.emplace("Bob");
    s1.emplace("Carmine");

    cout << "multiset modified, now contains ";
    print(s1);
    cout << endl;

    s1.emplace("Bob");

    cout << "multiset modified, now contains ";
    print(s1);
    cout << endl;
}

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.

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

Parámetros

args
Argumentos reenviados para construir un elemento que se va a insertar en multiset .

where
Lugar donde se va a iniciar la búsqueda del punto de inserción correcto. (Si ese punto precede inmediatamente a where, la inserción se puede realizar en tiempo constante amortizado en lugar de en tiempo logarítmico).

Valor devuelto

Iterador al elemento recién insertado.

Comentarios

Esta función no invalida ninguna referencia a elementos contenedores, pero puede invalidar todos los iteradores al contenedor.

Durante la instalación, si se produce una excepción, el estado del contenedor no se modifica.

Para obtener un ejemplo de código, vea set::emplace_hint.

multiset::empty

Comprueba si un multiset está vacío.

bool empty() const;

Valor devuelto

true si está multiset vacío; false si no está multiset vacío.

Ejemplo

// multiset_empty.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main()
{
   using namespace std;
   multiset <int> ms1, ms2;
   ms1.insert ( 1 );

   if ( ms1.empty( ) )
      cout << "The multiset ms1 is empty." << endl;
   else
      cout << "The multiset ms1 is not empty." << endl;

   if ( ms2.empty( ) )
      cout << "The multiset ms2 is empty." << endl;
   else
      cout << "The multiset ms2 is not empty." << endl;
}
The multiset ms1 is not empty.
The multiset ms2 is empty.

multiset::end

Devuelve el iterador más allá del final.

const_iterator end() const;

iterator end();

Valor devuelto

El iterador siguiente al final. Si el multiset está vacío, multiset::end() == multiset::begin().

Comentarios

end se usa para probar si un iterador ha pasado el final de su conjunto múltiple.

El valor devuelto end por no debe desreferenciarse.

Para obtener un ejemplo de código, vea multiset::find.

multiset::equal_range

Devuelve un par de iteradores respectivamente al primer elemento de multiset cuya clave mayor es que una clave especificada y al primer elemento del multiset cuya clave es igual o mayor que la clave especificada.

pair <const_iterator, const_iterator> equal_range (const Key& key) const;

pair <iterator, iterator> equal_range (const Key& key);

Parámetros

key
Clave de argumento que se va a comparar con la clave de ordenación de un elemento del multiset objeto que se está buscando.

Valor devuelto

Un par de iteradores de tal forma que el primero es el de la clave y el lower_bound segundo es el de la upper_bound clave.

Para tener acceso al primer iterador de un par pr devuelto por la función miembro, use pr. first, y para desreferenciar el iterador de límite inferior, use *( pr . first). Para tener acceso al segundo iterador de un par pr devuelto por la función miembro, use pr. second, y para desreferenciar el iterador de límite superior, use *( pr . second).

Ejemplo

// multiset_equal_range.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   typedef multiset<int, less<int> > IntSet;
   IntSet ms1;
   multiset <int> :: const_iterator ms1_RcIter;

   ms1.insert( 10 );
   ms1.insert( 20 );
   ms1.insert( 30 );

   pair <IntSet::const_iterator, IntSet::const_iterator> p1, p2;
   p1 = ms1.equal_range( 20 );

   cout << "The upper bound of the element with "
        << "a key of 20 in the multiset ms1 is: "
        << *( p1.second ) << "." << endl;

   cout << "The lower bound of the element with "
        << "a key of 20 in the multiset ms1 is: "
        << *( p1.first ) << "." << endl;

   // Compare the upper_bound called directly
   ms1_RcIter = ms1.upper_bound( 20 );
   cout << "A direct call of upper_bound( 20 ) gives "
        << *ms1_RcIter << "," << endl
        << "matching the 2nd element of the pair"
        << " returned by equal_range( 20 )." << endl;

   p2 = ms1.equal_range( 40 );

   // If no match is found for the key,
   // both elements of the pair return end( )
   if ( ( p2.first == ms1.end( ) ) && ( p2.second == ms1.end( ) ) )
      cout << "The multiset ms1 doesn't have an element "
              << "with a key less than 40." << endl;
   else
      cout << "The element of multiset ms1 with a key >= 40 is: "
                << *( p1.first ) << "." << endl;
}
The upper bound of the element with a key of 20 in the multiset ms1 is: 30.
The lower bound of the element with a key of 20 in the multiset ms1 is: 20.
A direct call of upper_bound( 20 ) gives 30,
matching the 2nd element of the pair returned by equal_range( 20 ).
The multiset ms1 doesn't have an element with a key less than 40.

multiset::erase

Quita un elemento o un intervalo de elementos de una clase multiset de las posiciones especificadas o quita los elementos que coinciden con una clave especificada.

iterator erase(
    const_iterator Where);

iterator erase(
    const_iterator First,
    const_iterator Last);

size_type erase(
    const key_type& Key);

Parámetros

Where
Posición del elemento que se va a quitar.

First
Posición del primer elemento que se va a quitar.

Last
Posición situada más allá del último elemento que se va a quitar.

key
Valor de clave de los elementos que se van a quitar.

Valor devuelto

Para las dos primeras funciones miembro, un iterador bidireccional que designa el primer elemento que queda más allá de los elementos quitados, o un elemento que es el final de si no existe dicho multiset elemento.

Para la tercera función miembro, devuelve el número de elementos que se han quitado de multiset .

Comentarios

Para obtener un ejemplo de código, vea set::erase.

multiset::find

Devuelve un iterador que hace referencia a la ubicación de un elemento de que multiset tiene una clave equivalente a una clave especificada.

iterator find(const Key& key);

const_iterator find(const Key& key) const;

Parámetros

key
Valor de clave que debe coincidir con la clave de ordenación de un elemento del multiset objeto que se está buscando.

Valor devuelto

Iterador que hace referencia a la ubicación de un elemento con una clave especificada o a la ubicación siguiente al último elemento de ( ) si no se encuentra ninguna coincidencia para multisetmultiset::end() la clave.

Comentarios

La función miembro devuelve un iterador que hace referencia a un elemento de cuya clave es equivalente al argumento bajo un predicado binario que induce una ordenación basada en una relación de comparabilidad menor multisetkey que.

Si el valor devuelto de find se asigna a , el objeto no se puede const_iteratormultiset modificar. Si el valor devuelto de find se asigna a , el objeto se puede iteratormultiset modificar

Ejemplo

// compile with: /EHsc /W4 /MTd
#include <set>
#include <iostream>
#include <vector>
#include <string>

using namespace std;

template <typename T> void print_elem(const T& t) {
    cout << "(" << t << ") ";
}

template <typename T> void print_collection(const T& t) {
    cout << t.size() << " elements: ";

    for (const auto& p : t) {
        print_elem(p);
    }
    cout << endl;
}

template <typename C, class T> void findit(const C& c, T val) {
    cout << "Trying find() on value " << val << endl;
    auto result = c.find(val);
    if (result != c.end()) {
        cout << "Element found: "; print_elem(*result); cout << endl;
    } else {
        cout << "Element not found." << endl;
    }
}

int main()
{
    multiset<int> s1({ 40, 45 });
    cout << "The starting multiset s1 is: " << endl;
    print_collection(s1);

    vector<int> v;
    v.push_back(43);
    v.push_back(41);
    v.push_back(46);
    v.push_back(42);
    v.push_back(44);
    v.push_back(44); // attempt a duplicate

    cout << "Inserting the following vector data into s1: " << endl;
    print_collection(v);

    s1.insert(v.begin(), v.end());

    cout << "The modified multiset s1 is: " << endl;
    print_collection(s1);
    cout << endl;
    findit(s1, 45);
    findit(s1, 6);
}

multiset::get_allocator

Devuelve una copia del objeto de asignador utilizado para construir multiset .

allocator_type get_allocator() const;

Valor devuelto

Asignador utilizado por multiset .

Comentarios

Los asignadores de la multiset clase especifican cómo administra el almacenamiento la clase. Los asignadores predeterminados proporcionados con las clases contenedoras de la biblioteca estándar de C++ son suficientes para la mayoría de las necesidades de programación. La escritura y el uso de sus propias clases de asignador son temas avanzados de C++.

Ejemplo

// multiset_get_allocator.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int>::allocator_type ms1_Alloc;
   multiset <int>::allocator_type ms2_Alloc;
   multiset <double>::allocator_type ms3_Alloc;
   multiset <int>::allocator_type ms4_Alloc;

   // The following lines declare objects
   // that use the default allocator.
   multiset <int> ms1;
   multiset <int, allocator<int> > ms2;
   multiset <double, allocator<double> > ms3;

   cout << "The number of integers that can be allocated"
        << endl << "before free memory is exhausted: "
        << ms2.max_size( ) << "." << endl;

   cout << "The number of doubles that can be allocated"
        << endl << "before free memory is exhausted: "
        << ms3.max_size( ) <<  "." << endl;

   // The following lines create a multiset ms4
   // with the allocator of multiset ms1
   ms1_Alloc = ms1.get_allocator( );
   multiset <int> ms4( less<int>( ), ms1_Alloc );
   ms4_Alloc = ms4.get_allocator( );

   // Two allocators are interchangeable if
   // storage allocated from each can be
   // deallocated with the other
   if( ms1_Alloc == ms4_Alloc )
   {
      cout << "Allocators are interchangeable."
           << endl;
   }
   else
   {
      cout << "Allocators are not interchangeable."
           << endl;
   }
}

multiset::insert

Inserta un elemento o un intervalo de elementos en un 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ámetros

Val
Valor de un elemento que se va a insertar en multiset .

Where
Lugar donde se va a iniciar la búsqueda del punto de inserción correcto. (Si ese punto precede inmediatamente a Where, la inserción se puede realizar en tiempo constante amortizado en lugar de en tiempo logarítmico).

ValTy
Parámetro de plantilla que especifica el tipo de argumento que puede usar para construir un elemento de y avanza perfectamente multisetvalue_type como Val argumento.

First
Posición del primer elemento que se va a copiar.

Last
Posición situada más allá del último elemento que se va a copiar.

1
Argumento de función de plantilla que cumple los requisitos de que apunta a elementos de un tipo que input_iterator_tag se pueden usar para construir input_iterator_tag objeto.

IList
del initializer_list que se copian los elementos.

Valor devuelto

Las funciones miembro single-element-insert (1) y (2) devuelven un iterador a la posición donde se insertó el nuevo elemento en multiset .

Las funciones miembro single-element-with-hint (3) y (4) devuelven un iterador que apunta a la posición donde se insertó el nuevo elemento en multiset .

Comentarios

Esta función no invalida ningún puntero ni ninguna referencia, pero puede invalidar todos los iteradores al contenedor.

Durante la inserción de un solo elemento, si se produce una excepción, el estado del contenedor no se modifica. Durante la inserción de varios elementos, si se produce una excepción, el contenedor se deja en un estado sin especificar pero válido.

El value_type de un contenedor es una definición de tipo que pertenece al contenedor y, para set, es de tipo multiset<V>::value_typeconst V .

La función miembro de intervalo (5) inserta la secuencia de valores de elemento en un que corresponde a cada elemento que dirige un iterador en el intervalo ; por lo tanto, no se multiset[First, Last)Last inserta. La función miembro de contenedor end() hace referencia a la posición situada justo después del último elemento del contenedor; por ejemplo, la instrucción s.insert(v.begin(), v.end()); inserta todos los elementos de v en s.

La función miembro de lista de inicializadores (6) usa para initializer_list copiar elementos en multiset .

Para la inserción de un elemento construido en su lugar (es decir, no se realiza ninguna operación de copia o movimiento), vea multiset::emplace y multiset::emplace_hint .

Ejemplo

// multiset_insert.cpp
// compile with: /EHsc
#include <set>
#include <iostream>
#include <string>
#include <vector>

using namespace std;

template <typename S> void print(const S& s) {
    cout << s.size() << " elements: ";

    for (const auto& p : s) {
        cout << "(" << p << ") ";
    }

    cout << endl;
}

int main()
{

    // insert single values
    multiset<int> s1;
    // call insert(const value_type&) version
    s1.insert({ 1, 10 });
    // call insert(ValTy&&) version
    s1.insert(20);

    cout << "The original multiset values of s1 are:" << endl;
    print(s1);

    // intentionally attempt a duplicate, single element
    s1.insert(1);
    cout << "The modified multiset values of s1 are:" << endl;
    print(s1);
    cout << endl;

    // single element, with hint
    s1.insert(s1.end(), 30);
    cout << "The modified multiset values of s1 are:" << endl;
    print(s1);
    cout << endl;

    // The templatized version inserting a jumbled range
    multiset<int> s2;
    vector<int> v;
    v.push_back(43);
    v.push_back(294);
    v.push_back(41);
    v.push_back(330);
    v.push_back(42);
    v.push_back(45);

    cout << "Inserting the following vector data into s2:" << endl;
    print(v);

    s2.insert(v.begin(), v.end());

    cout << "The modified multiset values of s2 are:" << endl;
    print(s2);
    cout << endl;

    // The templatized versions move-constructing elements
    multiset<string>  s3;
    string str1("blue"), str2("green");

    // single element
    s3.insert(move(str1));
    cout << "After the first move insertion, s3 contains:" << endl;
    print(s3);

    // single element with hint
    s3.insert(s3.end(), move(str2));
    cout << "After the second move insertion, s3 contains:" << endl;
    print(s3);
    cout << endl;

    multiset<int> s4;
    // Insert the elements from an initializer_list
    s4.insert({ 4, 44, 2, 22, 3, 33, 1, 11, 5, 55 });
    cout << "After initializer_list insertion, s4 contains:" << endl;
    print(s4);
    cout << endl;
}

multiset::iterator

Tipo que proporciona un iterador bidireccional constante que puede leer cualquier elemento de .

typedef implementation-defined iterator;

Ejemplo

Vea el ejemplo de begin para obtener un ejemplo de cómo declarar y usar .

multiset::key_comp

Recupera una copia del objeto de comparación utilizado para ordenar claves de un multiset.

key_compare key_comp() const;

Valor devuelto

Devuelve el objeto de función que multiset utiliza para ordenar sus elementos, que es el parámetro de plantilla Compare .

Para obtener más información sobre Compare, vea la sección Comentarios del tema Compare.

Comentarios

El objeto almacenado define la función miembro:

operador bool( const Keyx, const Keyy);

que devuelve True si x precede estrictamente a y en el criterio de ordenación.

Y key_compare son value_compare sinónimos del parámetro de plantilla Compare . Ambos tipos se proporcionan para el conjunto de clases y multiset, donde son idénticos, para la compatibilidad con las clases map y multimap, donde son distintas.

Ejemplo

// multiset_key_comp.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;

   multiset <int, less<int> > ms1;
   multiset <int, less<int> >::key_compare kc1 = ms1.key_comp( ) ;
   bool result1 = kc1( 2, 3 ) ;
   if( result1 == true )
   {
      cout << "kc1( 2,3 ) returns value of true, "
           << "where kc1 is the function object of s1."
           << endl;
   }
   else
   {
      cout << "kc1( 2,3 ) returns value of false "
           << "where kc1 is the function object of ms1."
           << endl;
   }

   multiset <int, greater<int> > ms2;
   multiset <int, greater<int> >::key_compare kc2 = ms2.key_comp( ) ;
   bool result2 = kc2( 2, 3 ) ;
   if( result2 == true )
   {
      cout << "kc2( 2,3 ) returns value of true, "
           << "where kc2 is the function object of ms2."
           << endl;
   }
   else
   {
      cout << "kc2( 2,3 ) returns value of false, "
           << "where kc2 is the function object of ms2."
           << endl;
   }
}
kc1( 2,3 ) returns value of true, where kc1 is the function object of s1.
kc2( 2,3 ) returns value of false, where kc2 is the function object of ms2.

multiset::key_compare

Tipo que proporciona un objeto de función que puede comparar dos claves de ordenación para determinar el orden relativo de dos elementos en el multiset.

typedef Compare key_compare;

Comentarios

key_compare es un sinónimo del parámetro de plantilla Compare.

Para obtener más información Compare sobre , vea la sección Comentarios del tema Compare .

Ejemplo

Vea el ejemplo para key_comp obtener un ejemplo de cómo declarar y usar key_compare .

multiset::key_type

Tipo que proporciona un objeto de función que puede comparar las claves de ordenación para determinar el orden relativo de dos elementos de multiset .

typedef Key key_type;

Comentarios

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

Para obtener más información Key sobre , vea la sección Comentarios del tema Key .

Ejemplo

Vea el ejemplo para value_type obtener un ejemplo de cómo declarar y usar key_type .

multiset::lower_bound

Devuelve un iterador al primer elemento de un multiset cuya clave es igual o mayor que una clave especificada.

const_iterator lower_bound(const Key& key) const;

iterator lower_bound(const Key& key);

Parámetros

key
Clave de argumento que se va a comparar con la clave de ordenación de un elemento del multiset objeto que se está buscando.

Valor devuelto

o que direcciona la ubicación de un elemento de que tiene una clave igual o mayor que la clave de argumento, o que direcciona la ubicación siguiente al último elemento de si no se encuentra ninguna coincidencia para la iteratorconst_iteratormultisetmultiset clave.

Ejemplo

// multiset_lower_bound.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int> :: const_iterator ms1_AcIter, ms1_RcIter;

   ms1.insert( 10 );
   ms1.insert( 20 );
   ms1.insert( 30 );

   ms1_RcIter = ms1.lower_bound( 20 );
   cout << "The element of multiset ms1 with a key of 20 is: "
        << *ms1_RcIter << "." << endl;

   ms1_RcIter = ms1.lower_bound( 40 );

   // If no match is found for the key, end( ) is returned
   if ( ms1_RcIter == ms1.end( ) )
      cout << "The multiset ms1 doesn't have an element "
           << "with a key of 40." << endl;
   else
      cout << "The element of multiset ms1 with a key of 40 is: "
           << *ms1_RcIter << "." << endl;

   // The element at a specific location in the multiset can be
   // found using a dereferenced iterator addressing the location
   ms1_AcIter = ms1.end( );
   ms1_AcIter--;
   ms1_RcIter = ms1.lower_bound( *ms1_AcIter );
   cout << "The element of ms1 with a key matching "
        << "that of the last element is: "
        << *ms1_RcIter << "." << endl;
}
The element of multiset ms1 with a key of 20 is: 20.
The multiset ms1 doesn't have an element with a key of 40.
The element of ms1 with a key matching that of the last element is: 30.

multiset::max_size

Devuelve la longitud máxima del multiset.

size_type max_size() const;

Valor devuelto

Longitud máxima posible de multiset .

Ejemplo

// multiset_max_size.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int>::size_type i;

   i = ms1.max_size( );
   cout << "The maximum possible length "
        << "of the multiset is " << i << "." << endl;
}

multiset::multiset

Construye un multiset que está vacío o que es una copia de todo o de parte de otro multiset.

multiset();

explicit multiset (
    const Compare& Comp);

multiset (
    const Compare& Comp,
    const Allocator& Al);

multiset(
    const multiset& Right);

multiset(
    multiset&& Right);

multiset(
    initializer_list<Type> IList);

multiset(
    initializer_list<Type> IList,
    const Compare& Comp);

multiset(
    initializer_list<Type> IList,
    const Compare& Comp,
    const Allocator& Al);

template <class InputIterator>
multiset (
    InputIterator First,
    InputIterator Last);

template <class InputIterator>
multiset (
    InputIterator First,
    InputIterator Last,
    const Compare& Comp);

template <class InputIterator>
multiset (
    InputIterator First,
    InputIterator Last,
    const Compare& Comp,
    const Allocator& Al);

Parámetros

Al
Clase de asignador de almacenamiento que se va a utilizar para este objeto multiset, que toma como valor predeterminado Allocator.

Comp
Función de comparación de tipo const Compare que se utiliza para ordenar los elementos de multiset, que toma como valor predeterminado Compare.

Right
del multiset que el conjunto múltiple construido va a ser una copia.

First
Posición del primer elemento en el intervalo de elementos que se va a copiar.

Last
Posición del primer elemento más allá del intervalo de elementos que se va a copiar.

IList
del initializer_list que se copian los elementos.

Comentarios

Todos los constructores almacenan un tipo de objeto de asignador que administra el almacenamiento de memoria para y que se puede devolver más adelante multiset llamando a get_allocator . El parámetro de asignador se suele omitir en las declaraciones de clase y las macros de preprocesamiento que se utilizan para sustituir asignadores alternativos.

Todos los constructores inicializan su multiset.

Todos los constructores almacenan un objeto de función de tipo Compare que se usa para establecer un orden entre las claves de y que se puede devolver más adelante llamando multiset a key_comp .

Los tres primeros constructores especifican un conjunto múltiple inicial vacío, el segundo especifica el tipo de función de comparación ( ) que se va a usar para establecer el orden de los elementos y el tercero especifica explícitamente el tipo de asignador ( ) que se va a CompAl usar. La palabra clave explicit suprime ciertas clases de conversión automática de tipos.

El cuarto constructor especifica una copia de multisetRight .

El quinto constructor especifica una copia de moviendo multisetRight .

Los constructores 6, 7 y 8 especifican una initializer_list desde la que se copian los elementos.

Los tres constructores siguientes copian el intervalo de con mayor explicitidad al especificar el tipo de función de [First, Last)multiset comparación y el asignador.

Ejemplo

// multiset_ctor.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main()
{
    using namespace std;
    //multiset <int>::iterator ms1_Iter, ms2_Iter, ms3_Iter;
    multiset <int>::iterator ms4_Iter, ms5_Iter, ms6_Iter, ms7_Iter;

    // Create an empty multiset ms0 of key type integer
    multiset <int> ms0;

    // Create an empty multiset ms1 with the key comparison
    // function of less than, then insert 4 elements
    multiset <int, less<int> > ms1;
    ms1.insert(10);
    ms1.insert(20);
    ms1.insert(20);
    ms1.insert(40);

    // Create an empty multiset ms2 with the key comparison
    // function of greater than, then insert 2 elements
    multiset <int, less<int> > ms2;
    ms2.insert(10);
    ms2.insert(20);

    // Create a multiset ms3 with the
    // allocator of multiset ms1
    multiset <int>::allocator_type ms1_Alloc;
    ms1_Alloc = ms1.get_allocator();
    multiset <int> ms3(less<int>(), ms1_Alloc);
    ms3.insert(30);

    // Create a copy, multiset ms4, of multiset ms1
    multiset <int> ms4(ms1);

    // Create a multiset ms5 by copying the range ms1[ first,  last)
    multiset <int>::const_iterator ms1_bcIter, ms1_ecIter;
    ms1_bcIter = ms1.begin();
    ms1_ecIter = ms1.begin();
    ms1_ecIter++;
    ms1_ecIter++;
    multiset <int> ms5(ms1_bcIter, ms1_ecIter);

    // Create a multiset ms6 by copying the range ms4[ first,  last)
    // and with the allocator of multiset ms2
    multiset <int>::allocator_type ms2_Alloc;
    ms2_Alloc = ms2.get_allocator();
    multiset <int> ms6(ms4.begin(), ++ms4.begin(), less<int>(), ms2_Alloc);

    cout << "ms1 =";
    for (auto i : ms1)
        cout << " " << i;
    cout << endl;

    cout << "ms2 =";
    for (auto i : ms2)
        cout << " " << i;
   cout << endl;

   cout << "ms3 =";
   for (auto i : ms3)
       cout << " " << i;
    cout << endl;

    cout << "ms4 =";
    for (auto i : ms4)
        cout << " " << i;
    cout << endl;

    cout << "ms5 =";
    for (auto i : ms5)
        cout << " " << i;
    cout << endl;

    cout << "ms6 =";
    for (auto i : ms6)
        cout << " " << i;
    cout << endl;

    // Create a multiset by moving ms5
    multiset<int> ms7(move(ms5));
    cout << "ms7 =";
    for (auto i : ms7)
        cout << " " << i;
    cout << endl;

    // Create a multiset with an initializer_list
    multiset<int> ms8({1, 2, 3, 4});
    cout << "ms8=";
    for (auto i : ms8)
        cout << " " << i;
    cout << endl;
}

multiset::operator=

Reemplaza los elementos de este multiset con elementos de otro multiset.

multiset& operator=(const multiset& right);

multiset& operator=(multiset&& right);

Parámetros

Right
El objeto multiset del que se copian o mueven los elementos.

Comentarios

operator= copia o mueve los elementos de Right en multiset, dependiendo del tipo de referencia (lvalue o rvalue) que se ha usado. Se descartan los elementos que estén en este multiset antes de que operator= se ejecute.

Ejemplo

// multiset_operator_as.cpp
// compile with: /EHsc
#include <multiset>
#include <iostream>

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

multiset::pointer

Tipo que proporciona un puntero a un elemento de multiset.

typedef typename allocator_type::pointer pointer;

Comentarios

Se puede pointer usar un tipo para modificar el valor de un elemento.

En la mayoría de los casos, se debe usar un iterador para tener acceso a los elementos de un objeto .

multiset::rbegin

Devuelve un iterador que direcciona el primer elemento en un conjunto múltiple invertido.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Valor devuelto

Iterador bidireccional inverso que direcciona el primer elemento de un objeto invertido o que direcciona lo que había sido el último elemento del multiset objeto sin multiset invertir.

Comentarios

rbegin se usa con un invertido multiset igual que rbegin se usa con multiset .

Si el valor devuelto de rbegin se asigna a , el objeto no se puede const_reverse_iteratormultiset modificar. Si el valor devuelto de rbegin se asigna a , el objeto se puede reverse_iteratormultiset modificar.

rbegin puede usarse para iterar un objeto multiset hacia atrás.

Ejemplo

// multiset_rbegin.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int>::iterator ms1_Iter;
   multiset <int>::reverse_iterator ms1_rIter;

   ms1.insert( 10 );
   ms1.insert( 20 );
   ms1.insert( 30 );

   ms1_rIter = ms1.rbegin( );
   cout << "The first element in the reversed multiset is "
        << *ms1_rIter << "." << endl;

   // begin can be used to start an iteration
   // through a multiset in a forward order
   cout << "The multiset is:";
   for ( ms1_Iter = ms1.begin( ) ; ms1_Iter != ms1.end( ); ms1_Iter++ )
      cout << " " << *ms1_Iter;
   cout << endl;

   // rbegin can be used to start an iteration
   // through a multiset in a reverse order
   cout << "The reversed multiset is:";
   for ( ms1_rIter = ms1.rbegin( ) ; ms1_rIter != ms1.rend( ); ms1_rIter++ )
      cout << " " << *ms1_rIter;
   cout << endl;

   // a multiset element can be erased by dereferencing to its key
   ms1_rIter = ms1.rbegin( );
   ms1.erase ( *ms1_rIter );

   ms1_rIter = ms1.rbegin( );
   cout << "After the erasure, the first element "
        << "in the reversed multiset is "<< *ms1_rIter << "."
        << endl;
}
The first element in the reversed multiset is 30.
The multiset is: 10 20 30
The reversed multiset is: 30 20 10
After the erasure, the first element in the reversed multiset is 20.

multiset::reference

Tipo que proporciona una referencia a un elemento almacenado en un multiset.

typedef typename allocator_type::reference reference;

Ejemplo

// multiset_ref.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;

   ms1.insert( 10 );
   ms1.insert( 20 );

   // Declare and initialize a reference &Ref1 to the 1st element
   const int &Ref1 = *ms1.begin( );

   cout << "The first element in the multiset is "
        << Ref1 << "." << endl;
}
The first element in the multiset is 10.

multiset::rend

Devuelve un iterador que direcciona la ubicación que sigue al último elemento de multiset invertido.

const_reverse_iterator rend() const;

reverse_iterator rend();

Valor devuelto

Iterador bidireccional inverso que direcciona la ubicación siguiente al último elemento de un invertido (la ubicación que había precedido al primer elemento del objeto sin multisetmultiset invertir).

Comentarios

rend se usa con un conjunto múltiple invertido igual end que se usa con multiset .

Si el valor devuelto de rend se asigna a , el objeto no se puede const_reverse_iteratormultiset modificar. Si el valor devuelto de rend se asigna a , el objeto se puede reverse_iteratormultiset modificar.

Se puede usar rend para comprobar si un iterador inverso ha llegado al final de su conjunto múltiple.

El valor devuelto rend por no debe desreferenciarse.

Ejemplo

// multiset_rend.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main() {
   using namespace std;
   multiset <int> ms1;
   multiset <int>::iterator ms1_Iter;
   multiset <int>::reverse_iterator ms1_rIter;
   multiset <int>::const_reverse_iterator ms1_crIter;

   ms1.insert( 10 );
   ms1.insert( 20 );
   ms1.insert( 30 );

   ms1_rIter = ms1.rend( ) ;
   ms1_rIter--;
   cout << "The last element in the reversed multiset is "
        << *ms1_rIter << "." << endl;

   // end can be used to terminate an iteration
   // through a multiset in a forward order
   cout << "The multiset is: ";
   for ( ms1_Iter = ms1.begin( ) ; ms1_Iter != ms1.end( ); ms1_Iter++ )
      cout << *ms1_Iter << " ";
   cout << "." << endl;

   // rend can be used to terminate an iteration
   // through a multiset in a reverse order
   cout << "The reversed multiset is: ";
   for ( ms1_rIter = ms1.rbegin( ) ; ms1_rIter != ms1.rend( ); ms1_rIter++ )
      cout << *ms1_rIter << " ";
   cout << "." << endl;

   ms1_rIter = ms1.rend( );
   ms1_rIter--;
   ms1.erase ( *ms1_rIter );

   ms1_rIter = ms1.rend( );
   --ms1_rIter;
   cout << "After the erasure, the last element in the "
        << "reversed multiset is " << *ms1_rIter << "." << endl;
}

multiset::reverse_iterator

Un tipo que proporciona un iterador bidireccional que puede leer o modificar un elemento en un conjunto múltiple invertido.

typedef std::reverse_iterator<iterator> reverse_iterator;

Comentarios

Un tipo reverse_iterator se usa para recorrer en iteración el objeto en orden multiset inverso.

Ejemplo

Vea el ejemplo rbegin para obtener un ejemplo de cómo declarar y usar reverse_iterator .

multiset::size

Devuelve el número de elementos de multiset.

size_type size() const;

Valor devuelto

Longitud actual de multiset .

Ejemplo

// multiset_size.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int> :: size_type i;

   ms1.insert( 1 );
   i = ms1.size( );
   cout << "The multiset length is " << i << "." << endl;

   ms1.insert( 2 );
   i = ms1.size( );
   cout << "The multiset length is now " << i << "." << endl;
}
The multiset length is 1.
The multiset length is now 2.

multiset::size_type

Tipo entero sin signo que puede representar el número de elementos de un multiset.

typedef typename allocator_type::size_type size_type;

Ejemplo

Vea el ejemplo size para obtener un ejemplo de cómo declarar y usar size_type

multiset::swap

Intercambia los elementos de dos conjuntos múltiples.

void swap(
    multiset<Key, Compare, Allocator>& right);

Parámetros

Right
El conjunto múltiple de argumentos que proporciona los elementos que se van a intercambiar con el conjunto múltiple de destino.

Comentarios

La función miembro no invalida ninguna referencia, puntero o iterador que designan los elementos de los dos conjuntos múltiples cuyos elementos se intercambian.

Ejemplo

// multiset_swap.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1, ms2, ms3;
   multiset <int>::iterator ms1_Iter;

   ms1.insert( 10 );
   ms1.insert( 20 );
   ms1.insert( 30 );
   ms2.insert( 100 );
   ms2.insert( 200 );
   ms3.insert( 300 );

   cout << "The original multiset ms1 is:";
   for ( ms1_Iter = ms1.begin( ); ms1_Iter != ms1.end( ); ms1_Iter++ )
      cout << " " << *ms1_Iter;
   cout << "." << endl;

   // This is the member function version of swap
   ms1.swap( ms2 );

   cout << "After swapping with ms2, list ms1 is:";
   for ( ms1_Iter = ms1.begin( ); ms1_Iter != ms1.end( ); ms1_Iter++ )
      cout << " " << *ms1_Iter;
   cout << "." << endl;

   // This is the specialized template version of swap
   swap( ms1, ms3 );

   cout << "After swapping with ms3, list ms1 is:";
   for ( ms1_Iter = ms1.begin( ); ms1_Iter != ms1.end( ); ms1_Iter++ )
      cout << " " << *ms1_Iter;
   cout   << "." << endl;
}
The original multiset ms1 is: 10 20 30.
After swapping with ms2, list ms1 is: 100 200.
After swapping with ms3, list ms1 is: 300.

multiset::upper_bound

Devuelve un iterador al primer elemento de un multiset con una clave que es mayor que una clave especificada.

const_iterator upper_bound(const Key& key) const;

iterator upper_bound(const Key& key);

Parámetros

key
Clave de argumento que se va a comparar con la clave de ordenación de un elemento del multiset objeto que se está buscando.

Valor devuelto

Iterador o que direcciona la ubicación de un elemento de con una clave mayor que la clave de argumento, o que direcciona la ubicación siguiente al último elemento de si no se encuentra ninguna coincidencia para la multisetmultiset clave.

Ejemplo

// multiset_upper_bound.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int> :: const_iterator ms1_AcIter, ms1_RcIter;

   ms1.insert( 10 );
   ms1.insert( 20 );
   ms1.insert( 30 );

   ms1_RcIter = ms1.upper_bound( 20 );
   cout << "The first element of multiset ms1 with a key greater "
           << "than 20 is: " << *ms1_RcIter << "." << endl;

   ms1_RcIter = ms1.upper_bound( 30 );

   // If no match is found for the key, end( ) is returned
   if ( ms1_RcIter == ms1.end( ) )
      cout << "The multiset ms1 doesn't have an element "
              << "with a key greater than 30." << endl;
   else
      cout << "The element of multiset ms1 with a key > 40 is: "
           << *ms1_RcIter << "." << endl;

   // The element at a specific location in the multiset can be
   // found using a dereferenced iterator addressing the location
   ms1_AcIter = ms1.begin( );
   ms1_RcIter = ms1.upper_bound( *ms1_AcIter );
   cout << "The first element of ms1 with a key greater than"
        << endl << "that of the initial element of ms1 is: "
        << *ms1_RcIter << "." << endl;
}
The first element of multiset ms1 with a key greater than 20 is: 30.
The multiset ms1 doesn't have an element with a key greater than 30.
The first element of ms1 with a key greater than
that of the initial element of ms1 is: 20.

multiset::value_comp

Recupera una copia del objeto de comparación utilizado para ordenar valores de elemento de multiset.

value_compare value_comp() const;

Valor devuelto

Devuelve el objeto de función que multiset utiliza para ordenar sus elementos, que es el parámetro de plantilla Compare .

Para obtener más información Compare sobre , vea la sección Comentarios del tema Compare .

Comentarios

El objeto almacenado define la función miembro:

operador bool( const Key, const Key _yVal );

que devuelve true si _xVal precede a y no es igual a en el criterio de _yVal ordenación.

Y key_compare son value_compare sinónimos del parámetro de plantilla Compare . Ambos tipos se proporcionan para el conjunto de clases y , donde son idénticos, para la compatibilidad con la asignación de clases y , donde multisetmultimap son distintos.

Ejemplo

// multiset_value_comp.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;

   multiset <int, less<int> > ms1;
   multiset <int, less<int> >::value_compare vc1 = ms1.value_comp( );
   bool result1 = vc1( 2, 3 );
   if( result1 == true )
   {
      cout << "vc1( 2,3 ) returns value of true, "
           << "where vc1 is the function object of ms1."
           << endl;
   }
   else
   {
      cout << "vc1( 2,3 ) returns value of false, "
           << "where vc1 is the function object of ms1."
           << endl;
   }

   set <int, greater<int> > ms2;
   set<int, greater<int> >::value_compare vc2 = ms2.value_comp( );
   bool result2 = vc2( 2, 3 );
   if( result2 == true )
   {
      cout << "vc2( 2,3 ) returns value of true, "
           << "where vc2 is the function object of ms2."
           << endl;
   }
   else
   {
      cout << "vc2( 2,3 ) returns value of false, "
           << "where vc2 is the function object of ms2."
           << endl;
   }
}
vc1( 2,3 ) returns value of true, where vc1 is the function object of ms1.
vc2( 2,3 ) returns value of false, where vc2 is the function object of ms2.

multiset::value_compare

Tipo que proporciona un objeto de función que puede comparar dos claves de ordenación para determinar su orden relativo en multiset .

typedef key_compare value_compare;

Comentarios

value_compare es un sinónimo del parámetro de plantilla Compare.

Y key_compare son value_compare sinónimos del parámetro de plantilla Compare . Ambos tipos se proporcionan para el conjunto de clases y , donde son idénticos, para la compatibilidad con la asignación de clases y , donde multisetmultimap son distintos.

Para obtener más información sobre Compare, vea la sección Comentarios del tema Compare.

Ejemplo

Vea el ejemplo para value_comp obtener un ejemplo de cómo declarar y usar value_compare .

multiset::value_type

Tipo que describe un objeto almacenado como un elemento como multiset en su capacidad como un valor.

typedef Key value_type;

Comentarios

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

Y key_type son value_type sinónimos del parámetro de plantilla Key . Ambos tipos se proporcionan para el conjunto de clases y multiset, donde son idénticos, para la compatibilidad con las clases map y multimap, donde son distintas.

Para obtener más información sobre Key, vea la sección Comentarios del tema.

Ejemplo

// multiset_value_type.cpp
// compile with: /EHsc
#include <set>
#include <iostream>

int main( )
{
   using namespace std;
   multiset <int> ms1;
   multiset <int>::iterator ms1_Iter;

   multiset <int> :: value_type svt_Int;   // Declare value_type
   svt_Int = 10;             // Initialize value_type

   multiset <int> :: key_type skt_Int;   // Declare key_type
   skt_Int = 20;             // Initialize key_type

   ms1.insert( svt_Int );         // Insert value into s1
   ms1.insert( skt_Int );         // Insert key into s1

   // a multiset accepts key_types or value_types as elements
   cout << "The multiset has elements:";
   for ( ms1_Iter = ms1.begin( ) ; ms1_Iter != ms1.end( ); ms1_Iter++ )
      cout << " " << *ms1_Iter;
   cout << "." << endl;
}
The multiset has elements: 10 20.

Vea también

Contenedores
Seguridad para subprocesos en la biblioteca estándar de C++
Referencia de la biblioteca estándar de C++