set (Clase)

 

Publicado: julio de 2016

Para obtener la documentación más reciente de Visual Studio 2017 RC, consulte Documentación de Visual Studio 2017 RC.

El conjunto de clases contenedoras STL se usa para el almacenamiento y la recuperación de datos de una colección en la que los valores de los elementos contenidos son únicos y sirven como valores de clave según los cuales se ordenan automáticamente los datos. El valor de un elemento de un conjunto no se puede cambiar directamente. Lo que se debe hacer es eliminar los valores antiguos e insertar elementos con nuevos valores.

template <class Key,   
    class Traits=less<Key>,   
    class Allocator=allocator<Key>>  
class set  

Parámetros

Key
Tipo de datos de los elementos que se va a almacenar en el conjunto.

Traits
Tipo que proporciona un objeto de función que puede comparar dos valores de elementos como criterios de ordenación para determinar su orden relativo en el conjunto. Este argumento es opcional y el predicado binario menos * <> > * es el valor predeterminado.

En C++14 puede habilitar la búsqueda heterogénea especificando el predicado std::less<> o std::greater<>, que no tienen ningún parámetro de tipo. Para obtener más información, consulte búsqueda heterogénea en los contenedores asociativos

Allocator
Tipo que representa el objeto asignador almacenado que encapsula los detalles acerca de la asignación y desasignación de memoria del conjunto. Este argumento es opcional y el valor predeterminado es asignador<>>.

Un conjunto STL 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. Es más, es un contenedor asociativo simple porque los valores de elemento son sus valores de clave.

  • Reversible, porque proporciona un iterador bidireccional 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.

  • Único en el sentido de que cada uno de sus elementos debe tener una clave única. Puesto que el conjunto es también un contenedor asociativo simple, sus elementos también son únicos.

Un conjunto también se describe como una clase de plantilla, porque la funcionalidad que proporciona es genérica e 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.

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 estas operaciones explícitamente las realizan de forma eficiente 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 al quitar elementos solo se invalidan los iteradores que habían apuntado específicamente a los elementos quitados.

El conjunto debe ser el contenedor asociativo elegido cuando la aplicación satisfaga las condiciones que asocian los valores a sus claves. Los elementos de un conjunto son únicos y actúan como sus propios criterios de ordenación. Un modelo para este tipo de estructura es una lista ordenada, por ejemplo, de palabras en las que las palabras pueden aparecer solo una vez. Si se permitieran varias repeticiones de las palabras, la estructura de contenedor adecuada sería multiset. Si los valores necesitan estar asociados a una lista de palabras clave únicas, un mapa sería una estructura adecuada para contener estos datos. Si, por el contrario, las claves no son únicas, un multimap sería el contenedor preferido.

El conjunto ordena la secuencia que se controla mediante una llamada a un objeto de función almacenado de tipo key_compare. Este objeto almacenado es una función de comparación que se accede mediante una llamada a la función miembro key_comp. En general, los elementos deben ser meramente menos que comparables para establecer este orden de forma que, dados dos elementos cualesquiera, 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 y y y un valor devuelto de true o false. Una ordenación impuesta en un conjunto es una ordenación débil estricta si el predicado binario es Irreflexivo, antisimétrico y transitivo, y si la equivalencia es transitiva, donde dos objetos x y y se definen como equivalentes cuando tanto 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énea especificando el predicado std::less<> o std::greater<>, que no tienen ningún parámetro de tipo. Para obtener más información, consulte búsqueda heterogénea en los contenedores asociativos

El iterador proporcionado por la clase del conjunto es un iterador bidireccional, pero las funciones de miembro de clase insertar y establecer 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 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 funcionalidad, pero es suficiente para poder comunicarse sobre un intervalo de iteradores [ First, Last) en el contexto de las funciones miembro de clase.

Constructores

setConstruye un conjunto que está vacío o que es una copia de todo o de parte de otro conjunto.

Definiciones de tipo

allocator_typeTipo que representa la clase allocator para el conjunto.
const_iteratorTipo que proporciona un iterador bidireccional que puede leer un elemento const en el conjunto.
const_pointerTipo que proporciona un puntero a un elemento const en un conjunto.
const_referenceTipo que proporciona una referencia a un elemento const almacenado en un conjunto para leer y realizar operaciones const.
const_reverse_iteratorTipo que proporciona un iterador bidireccional que puede leer cualquier elemento const del conjunto.
difference_typeTipo entero con signo que se puede usar para representar el número de elementos de un conjunto en un intervalo entre elementos a los que apuntan los iteradores.
iteradorTipo que proporciona un iterador bidireccional que puede leer o modificar cualquier elemento de un conjunto.
key_compareTipo que proporciona un objeto de función que puede comparar dos criterios de ordenación para determinar el orden relativo de dos elementos en el conjunto.
KEY_TYPEEl tipo describe un objeto almacenado como un elemento de un conjunto en su capacidad como criterio de ordenación.
punteroTipo que proporciona un puntero a un elemento de un conjunto.
referenciaTipo que proporciona una referencia a un elemento almacenado en un conjunto.
reverse_iteratorTipo que proporciona un iterador bidireccional que puede leer o modificar un elemento en un conjunto invertido.
size_typeTipo entero sin signo que puede representar el número de elementos de un conjunto.
value_compareTipo que proporciona un objeto de función que puede comparar dos elementos como criterios de ordenación para determinar su orden relativo en el conjunto.
value_typeEl tipo describe un objeto almacenado como un elemento de un conjunto en su capacidad como valor.

Funciones miembro

comenzarDevuelve un iterador que direcciona el primer elemento del conjunto.
cbeginDevuelve un iterador const que direcciona el primer elemento del conjunto.
cendDevuelve un iterador constante que direcciona la ubicación que sigue al último elemento de un conjunto.
BorrarBorra todos los elementos de un conjunto.
recuentoDevuelve el número de elementos de un conjunto cuya clave coincide con una clave especificada por un parámetro.
crbeginDevuelve un iterador const que direcciona el primer elemento de un set invertido.
crendDevuelve un iterador const que direcciona la ubicación que sigue al último elemento de un set invertido.
emplaceInserta un elemento construido en contexto dentro de un conjunto.
emplace_hintInserta un elemento construido en contexto dentro de un conjunto, con una sugerencia de colocación.
vacíaComprueba si un conjunto está vacío.
finalDevuelve un iterador que direcciona la ubicación que sigue al último elemento de un conjunto.
equal_rangeDevuelve un par de iteradores, respectivamente, al primer elemento de un conjunto cuya clave mayor es que una clave especificada y al primer elemento del conjunto cuya clave es igual o mayor que la clave especificada.
BorrarQuita un elemento o un intervalo de elementos de un conjunto de las posiciones especificadas o quita los elementos que coinciden con una clave especificada.
BuscarDevuelve un iterador que direcciona la ubicación de un elemento en un conjunto que tiene una clave equivalente a una clave especificada.
get_allocatorDevuelve una copia del objeto allocator utilizado para construir el conjunto.
InsertarInserta un elemento o un intervalo de elementos en un conjunto.
key_compRecupera una copia del objeto de comparación utilizado para ordenar claves de un conjunto.
lower_boundDevuelve un iterador al primer elemento de un conjunto cuyo valor de clave es igual o mayor que el de una clave especificada.
max_sizeDevuelve la longitud máxima del conjunto.
rbeginDevuelve un iterador que direcciona el primer elemento en un conjunto invertido.
rendDevuelve un iterador que direcciona la ubicación que sigue al último elemento en un conjunto invertido.
tamañoDevuelve el número de elementos del conjunto.
intercambioIntercambia los elementos de dos conjuntos.
upper_boundDevuelve un iterador al primer elemento de conjunto con un valor de clave que es mayor que una clave especificada.
value_compRecupera una copia del objeto de comparación utilizado para ordenar valores de elemento de un conjunto.

Operadores

operador =Reemplaza los elementos de un conjunto con una copia de otro conjunto.

Encabezado:<>>

Espacio de nombres: std

Tipo que representa la clase de asignador para el objeto de conjunto.

typedef Allocator allocator_type;  

Comentarios

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

Devuelve el objeto de función que utiliza un conjunto múltiple para ordenar sus elementos, que es el parámetro de plantilla Allocator.

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

Ejemplo

Vea el ejemplo de get_allocator para obtener un ejemplo que usa allocator_type.

Devuelve un iterador que direcciona el primer elemento del conjunto.

const_iterator begin() const;

iterator begin();

Valor devuelto

Iterador bidireccional que direcciona el primer elemento en el conjunto o en la ubicación que sigue un conjunto vacío.

Comentarios

Si el valor devuelto de comenzar se asigna a un const_iterator, no se puede modificar los elementos en el objeto de conjunto. Si el valor devuelto de comenzar se asigna a un iterador, se pueden modificar los elementos en el objeto de conjunto.

Ejemplo

// set_begin.cpp  
// compile with: /EHsc  
#include <set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   set <int> s1;  
   set <int>::iterator s1_Iter;  
   set <int>::const_iterator s1_cIter;  
  
   s1.insert( 1 );  
   s1.insert( 2 );  
   s1.insert( 3 );  
  
   s1_Iter = s1.begin( );  
   cout << "The first element of s1 is " << *s1_Iter << endl;  
  
   s1_Iter = s1.begin( );  
   s1.erase( s1_Iter );  
  
   // The following 2 lines would err because the iterator is const  
   // s1_cIter = s1.begin( );  
   // s1.erase( s1_cIter );  
  
   s1_cIter = s1.begin( );  
   cout << "The first element of s1 is now " << *s1_cIter << endl;  
}  

The first element of s1 is 1  
The first element of s1 is now 2  

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 cbegin, los elementos del intervalo no se pueden modificar.

Se puede usar esta función miembro en lugar de la función miembro begin() para garantizar que el valor devuelto es const_iterator. Normalmente, se usa junto con el automática escriba la palabra clave de deducción, tal como se muestra en el ejemplo siguiente. En el ejemplo, considere la posibilidad de Container sea un modificable (no - const) contenedor 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  

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 el automática escriba la palabra clave de deducción, tal como se muestra en el ejemplo siguiente. En el ejemplo, considere la posibilidad de Container sea un modificable (no - const) contenedor de cualquier naturaleza que admite end() y cend().

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

// i2 is Container<T>::const_iterator  

El valor devuelto por cend no se debe desreferenciar.

Borra todos los elementos de un conjunto.

void clear();

Ejemplo

// set_clear.cpp  
// compile with: /EHsc  
#include <set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;     
   set <int> s1;  
  
   s1.insert( 1 );  
   s1.insert( 2 );  
  
   cout << "The size of the set is initially " << s1.size( )  
        << "." << endl;  
  
   s1.clear( );  
   cout << "The size of the set after clearing is "   
        << s1.size( ) << "." << endl;  
}  

The size of the set is initially 2.  
The size of the set after clearing is 0.  

Un tipo que proporciona un iterador bidireccional que puede leer una const elemento del conjunto.

typedef implementation-defined const_iterator;  

Comentarios

Un tipo const_iterator no se puede utilizar para modificar el valor de un elemento.

Ejemplo

Vea el ejemplo de comenzar para obtener un ejemplo que usa const_iterator.

Un tipo que proporciona un puntero a un const elemento de un conjunto.

typedef typename allocator_type::const_pointer const_pointer;  

Comentarios

Un tipo const_pointer no se puede utilizar para modificar el valor de un elemento.

En la mayoría de los casos, un const_iterator debe utilizarse para tener acceso a los elementos de un objeto de conjunto const.

Un tipo que proporciona una referencia a un const elemento almacenado en un conjunto para leer y realizar const operaciones.

typedef typename allocator_type::const_reference const_reference;  

Ejemplo

// set_const_ref.cpp  
// compile with: /EHsc  
#include <set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   set <int> s1;  
  
   s1.insert( 10 );  
   s1.insert( 20 );  
  
   // Declare and initialize a const_reference &Ref1   
   // to the 1st element  
   const int &Ref1 = *s1.begin( );  
  
   cout << "The first element in the set is "  
        << Ref1 << "." << endl;  
  
   // The following line would cause an error because the   
   // const_reference cannot be used to modify the set  
   // Ref1 = Ref1 + 5;  
}  

The first element in the set is 10.  

Un tipo que proporciona un iterador bidireccional que puede lee cualquier const elemento del conjunto.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;  

Comentarios

Un tipo de const_reverse_iterator no se puede modificar el valor de un elemento y se utiliza para recorrer en iteración el conjunto en orden inverso.

Ejemplo

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

Devuelve el número de elementos de un conjunto 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 del conjunto que deben coincidir.

Valor devuelto

Es&1; si el conjunto contiene un elemento cuyo criterio de ordenación coincide con la clave de parámetro. Es&0; si el conjunto no contiene ningún elemento con una clave coincidente.

Comentarios

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

[ lower_bound (_ Key ), upper_bound (_ Key ) ).

Ejemplo

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

// set_count.cpp  
// compile with: /EHsc  
#include <set>  
#include <iostream>  
  
int main()  
{  
    using namespace std;  
    set<int> s1;  
    set<int>::size_type i;  
  
    s1.insert(1);  
    s1.insert(1);  
  
    // Keys must be unique in set, so duplicates are ignored  
    i = s1.count(1);  
    cout << "The number of elements in s1 with a sort key of 1 is: "  
         << i << "." << endl;  
  
    i = s1.count(2);  
    cout << "The number of elements in s1 with a sort key of 2 is: "  
         << i << "." << endl;  
}  

The number of elements in s1 with a sort key of 1 is: 1.  
The number of elements in s1 with a sort key of 2 is: 0.  

Devuelve un iterador const que direcciona el primer elemento de un set invertido.

const_reverse_iterator crbegin() const;

Valor devuelto

Un iterador constante bidireccional inverso dirige al primer elemento en un conjunto invertido o direccionamiento lo que habría sido el último elemento del conjunto irreversible.

Comentarios

crbeginse utiliza con un conjunto invertido como comenzar se usa con un conjunto.

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

Ejemplo

// set_crbegin.cpp  
// compile with: /EHsc  
#include <set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;     
   set <int> s1;  
   set <int>::const_reverse_iterator s1_crIter;  
  
   s1.insert( 10 );  
   s1.insert( 20 );  
   s1.insert( 30 );  
  
   s1_crIter = s1.crbegin( );  
   cout << "The first element in the reversed set is "  
        << *s1_crIter << "." << endl;  
}  

The first element in the reversed set is 30.  

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

const_reverse_iterator crend() const;

Valor devuelto

Un iterador constante bidireccional inverso que direcciona la ubicación del último elemento de un conjunto invertido (la ubicación que había precedido al primer elemento en el conjunto sin invertir).

Comentarios

crendse utiliza con un conjunto invertido como final se usa con un conjunto.

Con el valor devuelto de crend, no se puede modificar el objeto de conjunto. El valor devuelto por crend no se debe desreferenciar.

crendpuede utilizarse para probar si un iterador inverso llegó al final de su conjunto.

Ejemplo

// set_crend.cpp  
// compile with: /EHsc  
#include <set>  
#include <iostream>  
  
int main() {  
   using namespace std;     
   set <int> s1;  
   set <int>::const_reverse_iterator s1_crIter;  
  
   s1.insert( 10 );  
   s1.insert( 20 );  
   s1.insert( 30 );  
  
   s1_crIter = s1.crend( );  
   s1_crIter--;  
   cout << "The last element in the reversed set is "  
        << *s1_crIter << "." << endl;  
}  

Tipo entero con signo que se puede usar para representar el número de elementos de un conjunto 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. El difference_type normalmente se utiliza para representar el número de elementos del intervalo [first y last) entre los iteradores first y last, incluye el elemento al que apunta first y el intervalo de elementos hasta, pero sin incluir, el elemento al que apunta last.

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

Ejemplo

// set_diff_type.cpp  
// compile with: /EHsc  
#include <iostream>  
#include <set>  
#include <algorithm>  
  
int main( )  
{  
   using namespace std;  
  
   set <int> s1;  
   set <int>::iterator s1_Iter, s1_bIter, s1_eIter;  
  
   s1.insert( 20 );  
   s1.insert( 10 );  
   s1.insert( 20 );   // won't insert as set elements are unique  
  
   s1_bIter = s1.begin( );  
   s1_eIter = s1.end( );  
  
   set <int>::difference_type   df_typ5, df_typ10, df_typ20;  
  
   df_typ5 = count( s1_bIter, s1_eIter, 5 );  
   df_typ10 = count( s1_bIter, s1_eIter, 10 );  
   df_typ20 = count( s1_bIter, s1_eIter, 20 );  
  
   // the keys, and hence the elements of a set are unique,  
   // so there is at most one of a given value  
   cout << "The number '5' occurs " << df_typ5  
        << " times in set s1.\n";  
   cout << "The number '10' occurs " << df_typ10  
        << " times in set s1.\n";  
   cout << "The number '20' occurs " << df_typ20  
        << " times in set s1.\n";  
  
   // count the number of elements in a set  
   set <int>::difference_type  df_count = 0;  
   s1_Iter = s1.begin( );  
   while ( s1_Iter != s1_eIter)     
   {  
      df_count++;  
      s1_Iter++;  
   }  
  
   cout << "The number of elements in the set s1 is: "   
        << df_count << "." << endl;  
}  

The number '5' occurs 0 times in set s1.  
The number '10' occurs 1 times in set s1.  
The number '20' occurs 1 times in set s1.  
The number of elements in the set s1 is: 2.  

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

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

Parámetros

ParámetroDescripción
argsArgumentos reenviados para construir un elemento que se va a insertar en el conjunto, a menos que ya contenga un elemento cuyo valor esté ordenado de forma equivalente.

Valor devuelto

Un par cuyo componente bool devuelve true si se realizó una inserción y false si el mapa ya contenía un elemento cuyo valor tenía un valor equivalente en la ordenación. El componente iterator del valor devuelto pair devuelve la dirección donde se insertó un nuevo elemento (si el componente bool es true) o donde ya se encontraba el elemento (si el componente bool es false).

Comentarios

Esta función no invalida ningún iterador ni ninguna referencia.

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

Ejemplo

  
// set_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()  
{  
    set<string> s1;  
  
    auto ret = s1.emplace("ten");  
  
    if (!ret.second){  
        cout << "Emplace failed, element with value \"ten\" already exists."  
            << endl << "  The existing element is (" << *ret.first << ")"  
            << endl;  
        cout << "set not modified" << endl;  
    }  
    else{  
        cout << "set modified, now contains ";  
        print(s1);  
    }  
    cout << endl;  
  
    ret = s1.emplace("ten");  
  
    if (!ret.second){  
        cout << "Emplace failed, element with value \"ten\" already exists."  
            << endl << "  The existing element is (" << *ret.first << ")"  
            << endl;  
    }  
    else{  
        cout << "set modified, now contains ";  
        print(s1);  
    }  
    cout << endl;  
}  
  

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

ParámetroDescripción
argsArgumentos reenviados para construir un elemento que se va a insertar en el conjunto a menos que el conjunto ya contenga ese elemento o, más en general, a menos que ya contenga un elemento cuyo valor esté ordenado de manera equivalente.
whereLugar 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.

Si se produjo un error en la inserción porque el elemento ya existe, devuelve un iterador al elemento existente.

Comentarios

Esta función no invalida ningún iterador ni ninguna referencia.

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

Ejemplo

  
// set_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: " << endl;  
  
    for (const auto& p : s) {  
        cout << "(" << p <<  ") ";  
    }  
  
    cout << endl;  
}  
  
int main()  
{  
    set<string> s1;  
  
    // Emplace some test data  
    s1.emplace("Anna");  
    s1.emplace("Bob");  
    s1.emplace("Carmine");  
  
    cout << "set starting data: ";  
    print(s1);  
    cout << endl;  
  
    // Emplace with hint  
    // s1.end() should be the "next" element after this emplacement  
    s1.emplace_hint(s1.end(), "Doug");  
  
    cout << "set modified, now contains ";  
    print(s1);  
    cout << endl;  
}  
  

Comprueba si un conjunto está vacío.

bool empty() const;

Valor devuelto

True si el conjunto está vacío; false si el conjunto está vacío.

Ejemplo

// set_empty.cpp  
// compile with: /EHsc  
#include <set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   set <int> s1, s2;  
   s1.insert ( 1 );  
  
   if ( s1.empty( ) )  
      cout << "The set s1 is empty." << endl;  
   else  
      cout << "The set s1 is not empty." << endl;  
  
   if ( s2.empty( ) )  
      cout << "The set s2 is empty." << endl;  
   else  
      cout << "The set s2 is not empty." << endl;  
}  

The set s1 is not empty.  
The set s2 is empty.  

Devuelve el iterador más allá del final.

const_iterator end() const;

 
 
iterator end();

Valor devuelto

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

Comentarios

end se utiliza para probar si un iterador sobrepasó el final de su conjunto.

El valor devuelto por final no se debe desreferenciar.

Para obtener un ejemplo de código, consulte Set:: Find.

Devuelve un par de iteradores, respectivamente en el primer elemento de un conjunto con una clave que es mayor o igual a una clave especificada y hasta el primer elemento del conjunto cuya clave es mayor que la clave.

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 el criterio de ordenación de un elemento del conjunto que se está buscando.

Valor devuelto

Un par de iteradores donde el primero es el lower_bound de la clave y el segundo es el upper_bound de la clave.

Para obtener acceso a la primera iterador de un par pr devuelto por la función miembro, utilice pr. primeray para desreferenciar el iterador de límite inferior, utilice *( pr. en primer lugar). Para tener acceso el iterador de segundo de un par pr devuelto por la función miembro, utilice pr. segundoy para desreferenciar el iterador de límite superior, use *( pr. en segundo lugar).

Ejemplo

// set_equal_range.cpp  
// compile with: /EHsc  
#include <set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   typedef set<int, less< int > > IntSet;  
   IntSet s1;  
   set <int, less< int > > :: const_iterator s1_RcIter;  
  
   s1.insert( 10 );  
   s1.insert( 20 );  
   s1.insert( 30 );  
  
   pair <IntSet::const_iterator, IntSet::const_iterator> p1, p2;  
   p1 = s1.equal_range( 20 );  
  
   cout << "The upper bound of the element with "  
        << "a key of 20 in the set s1 is: "  
        << *(p1.second) << "." << endl;  
  
   cout << "The lower bound of the element with "  
        << "a key of 20 in the set s1 is: "  
        << *(p1.first) << "." << endl;  
  
   // Compare the upper_bound called directly   
   s1_RcIter = s1.upper_bound( 20 );  
   cout << "A direct call of upper_bound( 20 ) gives "  
        << *s1_RcIter << "," << endl  
        << "matching the 2nd element of the pair"  
        << " returned by equal_range( 20 )." << endl;  
  
   p2 = s1.equal_range( 40 );  
  
   // If no match is found for the key,  
   // both elements of the pair return end( )  
   if ( ( p2.first == s1.end( ) ) && ( p2.second == s1.end( ) ) )  
      cout << "The set s1 doesn't have an element "  
           << "with a key less than 40." << endl;  
   else  
      cout << "The element of set s1 with a key >= 40 is: "  
           << *(p1.first) << "." << endl;  
}  

The upper bound of the element with a key of 20 in the set s1 is: 30.  
The lower bound of the element with a key of 20 in the set s1 is: 20.  
A direct call of upper_bound( 20 ) gives 30,  
matching the 2nd element of the pair returned by equal_range( 20 ).  
The set s1 doesn't have an element with a key less than 40.  

Quita un elemento o un intervalo de elementos de un conjunto 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, iterador bidireccional que designa el primer elemento que permanece más allá de los elementos quitados, o un elemento que es el final del conjunto si no existe ese elemento.

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

Comentarios

Ejemplo

// set_erase.cpp  
// compile with: /EHsc  
#include <set>  
#include <string>  
#include <iostream>  
#include <iterator> // next() and prev() helper functions  
  
using namespace std;  
  
using myset = set<string>;  
  
void printset(const myset& s) {  
    for (const auto& iter : s) {  
        cout << " [" << iter << "]";  
    }  
    cout << endl << "size() == " << s.size() << endl << endl;  
}  
  
int main()  
{  
    myset s1;  
  
    // Fill in some data to test with, one at a time  
    s1.insert("Bob");  
    s1.insert("Robert");  
    s1.insert("Bert");  
    s1.insert("Rob");  
    s1.insert("Bobby");  
  
    cout << "Starting data of set s1 is:" << endl;  
    printset(s1);  
    // The 1st member function removes an element at a given position  
    s1.erase(next(s1.begin()));  
    cout << "After the 2nd element is deleted, the set s1 is:" << endl;  
    printset(s1);  
  
    // Fill in some data to test with, one at a time, using an intializer list  
    myset s2{ "meow", "hiss", "purr", "growl", "yowl" };  
  
    cout << "Starting data of set s2 is:" << endl;  
    printset(s2);  
    // The 2nd member function removes elements  
    // in the range [First, Last)  
    s2.erase(next(s2.begin()), prev(s2.end()));  
    cout << "After the middle elements are deleted, the set s2 is:" << endl;  
    printset(s2);  
  
    myset s3;  
  
    // Fill in some data to test with, one at a time, using emplace  
    s3.emplace("C");  
    s3.emplace("C#");  
    s3.emplace("D");  
    s3.emplace("D#");  
    s3.emplace("E");  
    s3.emplace("E#");  
    s3.emplace("F");  
    s3.emplace("F#");  
    s3.emplace("G");  
    s3.emplace("G#");  
    s3.emplace("A");  
    s3.emplace("A#");  
    s3.emplace("B");  
  
    cout << "Starting data of set s3 is:" << endl;  
    printset(s3);  
    // The 3rd member function removes elements with a given Key  
    myset::size_type count = s3.erase("E#");  
    // The 3rd member function also returns the number of elements removed  
    cout << "The number of elements removed from s3 is: " << count << "." << endl;  
    cout << "After the element with a key of \"E#\" is deleted, the set s3 is:" << endl;  
    printset(s3);  
}  
  

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

iterator find(const Key& key);

 
const_iterator find(const Key& key) const;

Parámetros

key
El valor de clave que debe coincidir con la clave de ordenación de un elemento del conjunto que se está buscando.

Valor devuelto

Un iterador que hace referencia a la ubicación de un elemento con una clave especificada, o la ubicación que sigue al último elemento del conjunto ( set::end()) si se encuentra ninguna coincidencia para la clave.

Comentarios

La función miembro devuelve un iterador que hace referencia a un elemento del conjunto cuya clave equivale al argumento key en un predicado binario que induce a una ordenación basada en una relación de comparabilidad menor que.

Si el valor devuelto de buscar se asigna a un const_iterator, no se puede modificar el objeto de conjunto. Si el valor devuelto de buscar se asigna a un iterador, se puede modificar el objeto de conjunto

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()  
{  
    set<int> s1({ 40, 45 });  
    cout << "The starting set 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 set s1 is: " << endl;  
    print_collection(s1);  
    cout << endl;  
    findit(s1, 45);  
    findit(s1, 6);  
}  
  

Devuelve una copia del objeto de asignador utilizado para construir el conjunto.

allocator_type get_allocator() const;

Valor devuelto

El asignador utilizado por el conjunto de administración de memoria, que es el parámetro de plantilla Allocator.

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

Comentarios

Los asignadores de la clase de conjunto especifican cómo la clase administra el almacenamiento. Los asignadores predeterminados proporcionados con las clases de contenedor STL es suficiente para la mayoría de necesidades de programación. La escritura y el uso de sus propias clases de asignador son temas avanzados de C++.

Ejemplo

// set_get_allocator.cpp  
// compile with: /EHsc  
#include <set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   set <int>::allocator_type s1_Alloc;  
   set <int>::allocator_type s2_Alloc;  
   set <double>::allocator_type s3_Alloc;  
   set <int>::allocator_type s4_Alloc;  
  
   // The following lines declare objects  
   // that use the default allocator.  
   set <int> s1;  
   set <int, allocator<int> > s2;  
   set <double, allocator<double> > s3;  
  
   s1_Alloc = s1.get_allocator( );  
   s2_Alloc = s2.get_allocator( );  
   s3_Alloc = s3.get_allocator( );  
  
   cout << "The number of integers that can be allocated"  
        << endl << "before free memory is exhausted: "  
        << s2.max_size( ) << "." << endl;  
  
   cout << "\nThe number of doubles that can be allocated"  
        << endl << "before free memory is exhausted: "  
        << s3.max_size( ) <<  "." << endl;  
  
   // The following line creates a set s4  
   // with the allocator of multiset s1.  
   set <int> s4( less<int>( ), s1_Alloc );  
  
   s4_Alloc = s4.get_allocator( );  
  
   // Two allocators are interchangeable if  
   // storage allocated from each can be  
   // deallocated by the other  
   if( s1_Alloc == s4_Alloc )  
   {  
      cout << "\nThe allocators are interchangeable."  
           << endl;  
   }  
   else  
   {  
      cout << "\nThe allocators are not interchangeable."  
           << endl;  
   }  
}  

Inserta un elemento o un intervalo de elementos en un conjunto.

// (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

ParámetroDescripción
ValValor de un elemento que se va a insertar en el conjunto a menos que ya contenga un elemento cuyo valor se ordena de forma equivalente.
WhereLugar 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).
ValTyParámetro de plantilla que especifica el tipo de argumento que se puede utilizar el conjunto para construir un elemento de value_typey el reenvío directo Val como argumento.
FirstPosición del primer elemento que se va a copiar.
LastPosición situada más allá del último elemento que se va a copiar.
InputIteratorArgumento de función de plantilla que cumpla los requisitos de un iterador de entrada que apunta a los elementos de un tipo que se puede utilizar para construir value_type objetos.
IListEl initializer_list desde el que se va a copiar los elementos.

Valor devuelto

Las funciones de miembro único elemento, (1) y (2), devuelven un par cuyo bool componente es true si se realizó una inserción y false si el conjunto ya contenía un elemento de valor equivalente en la ordenación. El componente de iterador del par de valor devuelto apunta al elemento recién insertado si el componente bool es true, o al elemento existente si el componente bool es false.

Las funciones miembro 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 conjunto, o bien, si ya existe un elemento con una clave equivalente, al elemento existente.

Comentarios

Esta función no invalida ningún iterador, puntero o referencia.

Durante la inserción de un solo elemento, si se produce una excepción, no se modifica el estado del contenedor. 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.

Para tener acceso al componente de iterador de un pair``pr devuelto por las funciones miembro de elemento único, use pr.first; para desreferenciar el iterador dentro del par devuelto, utilice *pr.first, especificando un elemento. Para tener acceso al componente bool, utilice pr.second. Para obtener un ejemplo, vea el código de ejemplo que se muestra más adelante en este artículo.

El value_type de un contenedor es un typedef que pertenece al contenedor y, en conjunto, set<V>::value_type es de tipo const V.

La función miembro de intervalo (5) inserta la secuencia de valores de elemento en un conjunto que corresponde a cada elemento direccionado por un iterador en el intervalo [First, Last); por tanto, Last no se inserta. La función miembro de contenedor end() hace referencia a la posición situada justo después del último elemento del contenedor; por ejemplo, la instrucción s.insert(v.begin(), v.end()); intenta insertar todos los elementos de v en s. Solo se insertan los elementos que tienen valores únicos en el intervalo; se omiten los duplicados. Para observar qué elementos se rechazan, utilice las versiones de un solo elemento de insert.

La lista función miembro inicializadores (6) utiliza un initializer_list para copiar elementos en el conjunto.

Inserción de un elemento construido en contexto, es decir, no se llevan a cabo ninguna operación de copiar o mover, consulte set::emplace y set::emplace_hint.

Ejemplo

  
// set_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   
    set<int> s1;  
    // call insert(const value_type&) version  
    s1.insert({ 1, 10 });  
    // call insert(ValTy&&) version   
    s1.insert(20);  
  
    cout << "The original set values of s1 are:" << endl;  
    print(s1);  
  
    // intentionally attempt a duplicate, single element  
    auto ret = s1.insert(1);  
    if (!ret.second){  
        auto elem = *ret.first;  
        cout << "Insert failed, element with value 1 already exists."  
            << endl << "  The existing element is (" << elem << ")"  
            << endl;  
    }  
    else{  
        cout << "The modified set values of s1 are:" << endl;  
        print(s1);  
    }  
    cout << endl;  
  
    // single element, with hint  
    s1.insert(s1.end(), 30);  
    cout << "The modified set values of s1 are:" << endl;  
    print(s1);  
    cout << endl;  
  
    // The templatized version inserting a jumbled range  
    set<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 set values of s2 are:" << endl;  
    print(s2);  
    cout << endl;  
  
    // The templatized versions move-constructing elements  
    set<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;  
  
    set<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;  
}  
  

Un tipo que proporciona una constante iterador bidireccional que puede leer cualquier elemento de un conjunto.

typedef implementation-defined iterator;  

Ejemplo

Vea el ejemplo de comenzar para obtener un ejemplo de cómo declarar y utilizar una iterador.

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

key_compare key_comp() const;

Valor devuelto

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

Para obtener más información sobre Traits ver el establezca clase tema.

Comentarios

El objeto almacenado define la función miembro:

bool operator()( const Key&_xVal, const Key&_yVal);

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

Tenga en cuenta que ambos key_compare y value_compare son sinónimos para el parámetro de plantilla rasgos. Ambos tipos se proporcionan para el conjunto y clases de conjunto múltiple, donde son idénticos para la compatibilidad con el mapa y clases multimap, donde son distintos.

Ejemplo

// set_key_comp.cpp  
// compile with: /EHsc  
#include <set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
  
   set <int, less<int> > s1;  
   set<int, less<int> >::key_compare kc1 = s1.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 s1."  
           << endl;  
   }  
  
   set <int, greater<int> > s2;  
   set<int, greater<int> >::key_compare kc2 = s2.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 s2."  
           << endl;  
   }  
   else     
   {  
      cout << "kc2( 2,3 ) returns value of false, "  
           << "where kc2 is the function object of s2."  
           << 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 s2.  

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

typedef Traits key_compare;  

Comentarios

key_comparees un sinónimo del parámetro de plantilla Traits.

Para obtener más información sobre Traits ver el establezca clase tema.

Tenga en cuenta que ambos key_compare y value_compare son sinónimos para el parámetro de plantilla rasgos. Ambos tipos se proporcionan para el conjunto y clases de conjunto múltiple, donde son idénticos para la compatibilidad con el mapa y clases multimap, donde son distintos.

Ejemplo

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

Un tipo que describe un objeto almacenado como un elemento de un conjunto en su capacidad como criterio de ordenación.

typedef Key key_type;  

Comentarios

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

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

Tenga en cuenta que ambos key_type y value_type son sinónimos para el parámetro de plantilla clave. Ambos tipos se proporcionan para el conjunto y clases de conjunto múltiple, donde son idénticos para la compatibilidad con el mapa y clases multimap, donde son distintos.

Ejemplo

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

Devuelve un iterador al primer elemento de un conjunto cuyo valor de clave es igual o mayor que el de 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 el criterio de ordenación de un elemento del conjunto que se está buscando.

Valor devuelto

Un iterador o const_iterator que direcciones de la ubicación de un elemento de un conjunto que con una clave que es igual o mayor que la clave de argumento o que dirige a la ubicación siguiente al último elemento del conjunto si no coinciden se encuentra la clave.

Ejemplo

// set_lower_bound.cpp  
// compile with: /EHsc  
#include <set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   set <int> s1;  
   set <int> :: const_iterator s1_AcIter, s1_RcIter;  
  
   s1.insert( 10 );  
   s1.insert( 20 );  
   s1.insert( 30 );  
  
   s1_RcIter = s1.lower_bound( 20 );  
   cout << "The element of set s1 with a key of 20 is: "  
        << *s1_RcIter << "." << endl;  
  
   s1_RcIter = s1.lower_bound( 40 );  
  
   // If no match is found for the key, end( ) is returned  
   if ( s1_RcIter == s1.end( ) )  
      cout << "The set s1 doesn't have an element "  
           << "with a key of 40." << endl;  
   else  
      cout << "The element of set s1 with a key of 40 is: "  
           << *s1_RcIter << "." << endl;  
  
   // The element at a specific location in the set can be found   
   // by using a dereferenced iterator that addresses the location  
   s1_AcIter = s1.end( );  
   s1_AcIter--;  
   s1_RcIter = s1.lower_bound( *s1_AcIter );  
   cout << "The element of s1 with a key matching "  
        << "that of the last element is: "  
        << *s1_RcIter << "." << endl;  
}  

The element of set s1 with a key of 20 is: 20.  
The set s1 doesn't have an element with a key of 40.  
The element of s1 with a key matching that of the last element is: 30.  

Devuelve la longitud máxima del conjunto.

size_type max_size() const;

Valor devuelto

La longitud máxima permitida del conjunto.

Ejemplo

// set_max_size.cpp  
// compile with: /EHsc  
#include <set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;     
   set <int> s1;  
   set <int>::size_type i;  
  
   i = s1.max_size( );     
   cout << "The maximum possible length "  
        << "of the set is " << i << "." << endl;  
}  

Reemplaza los elementos de esta set con elementos de otro set.

set& operator=(const set& right);

set& operator=(set&& right);

Parámetros

ParámetroDescripción
rightEl set proporcionar nuevos elementos que se asignará a esta set.

Comentarios

La primera versión de operator= utiliza un referencia lvalue de right, para copiar los elementos right a esta set.

La segunda versión usa un referencia rvalue derecho. Mueve los elementos de right a esta set.

Todos los elementos en esta set antes de que se ejecuta la función de operador se descartan.

Ejemplo

// set_operator_as.cpp  
// compile with: /EHsc  
#include <set>  
#include <iostream>  
  
int main( )  
   {  
   using namespace std;  
   set<int> v1, v2, v3;  
   set<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;  
   }  

Tipo que proporciona un puntero a un elemento de un conjunto.

typedef typename allocator_type::pointer pointer;  

Comentarios

Un tipo de puntero puede utilizarse para modificar el valor de un elemento.

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

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

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Valor devuelto

Iterador bidireccional inverso dirige al primer elemento en un conjunto invertido o direccionamiento lo que habría sido el último elemento del conjunto irreversible.

Comentarios

rbeginse utiliza con un conjunto invertido como comenzar se usa con un conjunto.

Si el valor devuelto de rbegin se asigna a un const_reverse_iterator, entonces no se puede modificar el objeto de conjunto. Si el valor devuelto de rbegin se asigna a un reverse_iterator, a continuación, el objeto de conjunto se puede modificar.

rbeginpuede utilizarse para recorrer en iteración un conjunto con versiones anteriores.

Ejemplo

// set_rbegin.cpp  
// compile with: /EHsc  
#include <set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;     
   set <int> s1;  
   set <int>::iterator s1_Iter;  
   set <int>::reverse_iterator s1_rIter;  
  
   s1.insert( 10 );  
   s1.insert( 20 );  
   s1.insert( 30 );  
  
   s1_rIter = s1.rbegin( );  
   cout << "The first element in the reversed set is "  
        << *s1_rIter << "." << endl;  
  
   // begin can be used to start an iteration   
   // throught a set in a forward order  
   cout << "The set is:";  
   for ( s1_Iter = s1.begin( ) ; s1_Iter != s1.end( ); s1_Iter++ )  
      cout << " " << *s1_Iter;  
   cout << endl;  
  
   // rbegin can be used to start an iteration   
   // throught a set in a reverse order  
   cout << "The reversed set is:";  
   for ( s1_rIter = s1.rbegin( ) ; s1_rIter != s1.rend( ); s1_rIter++ )  
      cout << " " << *s1_rIter;  
   cout << endl;  
  
   // A set element can be erased by dereferencing to its key   
   s1_rIter = s1.rbegin( );  
   s1.erase ( *s1_rIter );  
  
   s1_rIter = s1.rbegin( );  
   cout << "After the erasure, the first element "  
        << "in the reversed set is "<< *s1_rIter << "." << endl;  
}  

The first element in the reversed set is 30.  
The set is: 10 20 30  
The reversed set is: 30 20 10  
After the erasure, the first element in the reversed set is 20.  

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

typedef typename allocator_type::reference reference;  

Ejemplo

// set_reference.cpp  
// compile with: /EHsc  
#include <set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   set <int> s1;  
  
   s1.insert( 10 );  
   s1.insert( 20 );  
  
   // Declare and initialize a reference &Ref1 to the 1st element  
   const int &Ref1 = *s1.begin( );  
  
   cout << "The first element in the set is "  
        << Ref1 << "." << endl;  
}  

The first element in the set is 10.  

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

const_reverse_iterator rend() const;

reverse_iterator rend();

Valor devuelto

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

Comentarios

rendse utiliza con un conjunto invertido como final se usa con un conjunto.

Si el valor devuelto de rend se asigna a un const_reverse_iterator, entonces no se puede modificar el objeto de conjunto. Si el valor devuelto de rend se asigna a un reverse_iterator, a continuación, el objeto de conjunto se puede modificar. El valor devuelto por rend no se debe desreferenciar.

rendpuede utilizarse para probar si un iterador inverso llegó al final de su conjunto.

Ejemplo

// set_rend.cpp  
// compile with: /EHsc  
#include <set>  
#include <iostream>  
  
int main() {  
   using namespace std;     
   set <int> s1;  
   set <int>::iterator s1_Iter;  
   set <int>::reverse_iterator s1_rIter;  
   set <int>::const_reverse_iterator s1_crIter;  
  
   s1.insert( 10 );  
   s1.insert( 20 );  
   s1.insert( 30 );  
  
   s1_rIter = s1.rend( );  
   s1_rIter--;  
   cout << "The last element in the reversed set is "  
        << *s1_rIter << "." << endl;  
  
   // end can be used to terminate an iteration   
   // throught a set in a forward order  
   cout << "The set is: ";  
   for ( s1_Iter = s1.begin( ) ; s1_Iter != s1.end( ); s1_Iter++ )  
      cout << *s1_Iter << " ";  
   cout << "." << endl;  
  
   // rend can be used to terminate an iteration   
   // throught a set in a reverse order  
   cout << "The reversed set is: ";  
   for ( s1_rIter = s1.rbegin( ) ; s1_rIter != s1.rend( ); s1_rIter++ )  
      cout << *s1_rIter << " ";  
   cout << "." << endl;  
  
   s1_rIter = s1.rend( );  
   s1_rIter--;  
   s1.erase ( *s1_rIter );  
  
   s1_rIter = s1.rend( );  
   --s1_rIter;  
   cout << "After the erasure, the last element in the "  
        << "reversed set is " << *s1_rIter << "." << endl;  
}  

Tipo que proporciona un iterador bidireccional que puede leer o modificar un elemento en un conjunto invertido.

typedef std::reverse_iterator<iterator> reverse_iterator;  

Comentarios

Un tipo reverse_iterator se utiliza para recorrer en iteración el conjunto en orden inverso.

Ejemplo

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

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

set();

explicit set(
    const Traits& Comp);

set(
    const Traits& Comp,  
    const Allocator& Al);

set(
    const set& Right);

set(
    set&& Right);

set(
    initializer_list<Type> IList);

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

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

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

template <class InputIterator>  
set(
 InputIterator First,  
    InputIterator Last,  
    const Traits& Comp);

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

Parámetros

ParámetroDescripción
AlLa clase de asignador de almacenamiento que se utilizará para este objeto de conjunto, cuyo valor predeterminado es asignador.
CompFunción de comparación de tipo const Traits que se utiliza para ordenar los elementos del conjunto, que de forma predeterminada es Compare.
RghtConjunto del que el conjunto construido va a ser una copia.
FirstPosición del primer elemento en el intervalo de elementos que se va a copiar.
LastPosición del primer elemento más allá del intervalo de elementos que se va a copiar.
IListinitializer_list de la que se van a copiar los elementos.

Comentarios

Todos los constructores almacenan un tipo de objeto de asignador que administra el almacenamiento de memoria para el conjunto y que puede devolver más adelante 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 sus conjuntos.

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

Los tres primeros constructores especifican un conjunto inicial vacío, el segundo especifica el tipo de función de comparación ( comp) que se utilizará para establecer el orden de los elementos y el tercero especifica explícitamente el asignador de tipo ( al) que se utilizará. La palabra clave explícita suprime ciertas clases de conversión automática de tipos.

El cuarto constructor especifica una copia del conjunto right.

Los tres constructores siguientes utilizan una initializer_list para especificar los elementos.

Los tres constructores siguientes copian el intervalo [ first, last) de un conjunto cada vez más explícita para especificar el tipo de función de comparación de clase rasgos y asignador.

El octavo constructor especifica una copia del conjunto moviendo right.

Ejemplo

// set_set.cpp  
// compile with: /EHsc  
#include <set>  
#include <iostream>  
  
int main()  
{  
    using namespace std;  
  
    // Create an empty set s0 of key type integer  
    set <int> s0;  
  
    // Create an empty set s1 with the key comparison  
    // function of less than, then insert 4 elements  
    set <int, less<int> > s1;  
    s1.insert(10);  
    s1.insert(20);  
    s1.insert(30);  
    s1.insert(40);  
  
    // Create an empty set s2 with the key comparison  
    // function of less than, then insert 2 elements  
    set <int, less<int> > s2;  
    s2.insert(10);  
    s2.insert(20);  
  
    // Create a set s3 with the   
    // allocator of set s1  
    set <int>::allocator_type s1_Alloc;  
    s1_Alloc = s1.get_allocator();  
    set <int> s3(less<int>(), s1_Alloc);  
    s3.insert(30);  
  
    // Create a copy, set s4, of set s1  
    set <int> s4(s1);  
  
    // Create a set s5 by copying the range s1[ first,  last)  
    set <int>::const_iterator s1_bcIter, s1_ecIter;  
    s1_bcIter = s1.begin();  
    s1_ecIter = s1.begin();  
    s1_ecIter++;  
    s1_ecIter++;  
    set <int> s5(s1_bcIter, s1_ecIter);  
  
    // Create a set s6 by copying the range s4[ first,  last)  
    // and with the allocator of set s2  
    set <int>::allocator_type s2_Alloc;  
    s2_Alloc = s2.get_allocator();  
    set <int> s6(s4.begin(), ++s4.begin(), less<int>(), s2_Alloc);  
  
    cout << "s1 =";  
    for (auto i : s1)  
        cout << " " << i;  
    cout << endl;  
  
    cout << "s2 = " << *s2.begin() << " " << *++s2.begin() << endl;  
  
    cout << "s3 =";  
    for (auto i : s3)  
        cout << " " << i;  
    cout << endl;  
  
    cout << "s4 =";  
    for (auto i : s4)  
        cout << " " << i;  
    cout << endl;  
  
    cout << "s5 =";  
    for (auto i : s5)  
        cout << " " << i;  
    cout << endl;  
  
    cout << "s6 =";  
    for (auto i : s6)  
        cout << " " << i;  
    cout << endl;  
  
    // Create a set by moving s5  
    set<int> s7(move(s5));  
    cout << "s7 =";  
    for (auto i : s7)  
        cout << " " << i;  
    cout << endl;  
  
    // Create a set with an initializer_list  
    cout << "s8 =";  
    set<int> s8{ { 1, 2, 3, 4 } };  
    for (auto i : s8)  
        cout << " " << i;  
    cout << endl;  
  
    cout << "s9 =";  
    set<int> s9{ { 5, 6, 7, 8 }, less<int>() };  
    for (auto i : s9)  
        cout << " " << i;  
    cout << endl;  
  
    cout << "s10 =";  
    set<int> s10{ { 10, 20, 30, 40 }, less<int>(), s9.get_allocator() };  
    for (auto i : s10)  
        cout << " " << i;  
    cout << endl;  
}  
  

s1 = 10 20 30 40s2 = 10 20s3 = 30s4 = 10 20 30 40s5 = 10 20s6 = 10s7 = 10 20s8 = 1 2 3 4s9 = 5 6 7 8s10 = 10 20 30 40  

Devuelve el número de elementos del conjunto.

size_type size() const;

Valor devuelto

La longitud actual del conjunto.

Ejemplo

// set_size.cpp  
// compile with: /EHsc  
#include <set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   set <int> s1;  
   set <int> :: size_type i;  
  
   s1.insert( 1 );  
   i = s1.size( );  
   cout << "The set length is " << i << "." << endl;  
  
   s1.insert( 2 );  
   i = s1.size( );  
   cout << "The set length is now " << i << "." << endl;  
}  

The set length is 1.  
The set length is now 2.  

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

typedef typename allocator_type::size_type size_type;  

Ejemplo

Vea el ejemplo de tamaño para obtener un ejemplo de cómo declarar y utilizarsize_type

Intercambia los elementos de dos conjuntos.

void swap(
    set<Key, Traits, Allocator>& right);

Parámetros

right
Establezca el argumento establecido proporciona los elementos deben intercambiar con el destino.

Comentarios

La función miembro no invalida ninguna referencias, punteros o iteradores que designan los elementos de los dos conjuntos cuyos elementos se intercambian.

Ejemplo

// set_swap.cpp  
// compile with: /EHsc  
#include <set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   set <int> s1, s2, s3;  
   set <int>::iterator s1_Iter;  
  
   s1.insert( 10 );  
   s1.insert( 20 );  
   s1.insert( 30 );  
   s2.insert( 100 );  
   s2.insert( 200 );  
   s3.insert( 300 );  
  
   cout << "The original set s1 is:";  
   for ( s1_Iter = s1.begin( ); s1_Iter != s1.end( ); s1_Iter++ )  
      cout << " " << *s1_Iter;  
   cout   << "." << endl;  
  
   // This is the member function version of swap  
   s1.swap( s2 );  
  
   cout << "After swapping with s2, list s1 is:";  
   for ( s1_Iter = s1.begin( ); s1_Iter != s1.end( ); s1_Iter++ )  
      cout << " " << *s1_Iter;  
   cout  << "." << endl;  
  
   // This is the specialized template version of swap  
   swap( s1, s3 );  
  
   cout << "After swapping with s3, list s1 is:";  
   for ( s1_Iter = s1.begin( ); s1_Iter != s1.end( ); s1_Iter++ )  
      cout << " " << *s1_Iter;  
   cout   << "." << endl;  
}  

The original set s1 is: 10 20 30.  
After swapping with s2, list s1 is: 100 200.  
After swapping with s3, list s1 is: 300.  

Devuelve un iterador al primer elemento de un conjunto que 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 el criterio de ordenación de un elemento del conjunto que se está buscando.

Valor devuelto

Un iterador o const_iterator que direcciones de la ubicación de un elemento de un conjunto que con una clave que es mayor que la clave de argumento o que dirige a la ubicación siguiente al último elemento del conjunto si no coinciden se encuentra la clave.

Ejemplo

// set_upper_bound.cpp  
// compile with: /EHsc  
#include <set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;     
   set <int> s1;  
   set <int> :: const_iterator s1_AcIter, s1_RcIter;  
  
   s1.insert( 10 );  
   s1.insert( 20 );  
   s1.insert( 30 );  
  
   s1_RcIter = s1.upper_bound( 20 );  
   cout << "The first element of set s1 with a key greater "  
        << "than 20 is: " << *s1_RcIter << "." << endl;  
  
   s1_RcIter = s1.upper_bound( 30 );  
  
   // If no match is found for the key, end( ) is returned  
   if ( s1_RcIter == s1.end( ) )  
      cout << "The set s1 doesn't have an element "  
           << "with a key greater than 30." << endl;  
   else  
      cout << "The element of set s1 with a key > 40 is: "  
           << *s1_RcIter << "." << endl;  
  
   // The element at a specific location in the set can be found   
   // by using a dereferenced iterator addressing the location  
   s1_AcIter = s1.begin( );  
   s1_RcIter = s1.upper_bound( *s1_AcIter );  
   cout << "The first element of s1 with a key greater than"  
        << endl << "that of the initial element of s1 is: "  
        << *s1_RcIter << "." << endl;  
}  

The first element of set s1 with a key greater than 20 is: 30.  
The set s1 doesn't have an element with a key greater than 30.  
The first element of s1 with a key greater than  
that of the initial element of s1 is: 20.  

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

value_compare value_comp() const;

Valor devuelto

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

Para obtener más información sobre Traits ver el establezca clase tema.

Comentarios

El objeto almacenado define la función miembro:

bool operator( const Key&_xVal, const Key&_yVal);

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

Tenga en cuenta que ambos value_compare y key_compare son sinónimos para el parámetro de plantilla rasgos. Ambos tipos se proporcionan para el conjunto y clases de conjunto múltiple, donde son idénticos para la compatibilidad con el mapa y clases multimap, donde son distintos.

Ejemplo

// set_value_comp.cpp  
// compile with: /EHsc  
#include <set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
  
   set <int, less<int> > s1;  
   set <int, less<int> >::value_compare vc1 = s1.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 s1."  
           << endl;  
   }  
   else     
   {  
      cout << "vc1( 2,3 ) returns value of false, "  
           << "where vc1 is the function object of s1."  
           << endl;  
   }  
  
   set <int, greater<int> > s2;  
   set<int, greater<int> >::value_compare vc2 = s2.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 s2."  
           << endl;  
   }  
   else     
   {  
      cout << "vc2( 2,3 ) returns value of false, "  
           << "where vc2 is the function object of s2."  
           << endl;  
   }  
}  

vc1( 2,3 ) returns value of true, where vc1 is the function object of s1.  
vc2( 2,3 ) returns value of false, where vc2 is the function object of s2.  

Un tipo que proporciona un objeto de función que puede comparar dos valores de elemento para determinar su orden relativo en el conjunto.

typedef key_compare value_compare;  

Comentarios

value_comparees un sinónimo del parámetro de plantilla Traits.

Para obtener más información sobre Traits ver el establezca clase tema.

Tenga en cuenta que ambos key_compare y value_compare son sinónimos para el parámetro de plantilla rasgos. Ambos tipos se proporcionan para el conjunto y clases de conjunto múltiple, donde son idénticos para la compatibilidad con el mapa y clases multimap, donde son distintos.

Ejemplo

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

Un tipo que describe un objeto almacenado como un elemento de un conjunto en su capacidad como valor.

typedef Key value_type;  

Comentarios

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

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

Tenga en cuenta que ambos key_type y value_type son sinónimos para el parámetro de plantilla clave. Ambos tipos se proporcionan para el conjunto y clases de conjunto múltiple, donde son idénticos para la compatibilidad con el mapa y clases multimap, donde son distintos.

Ejemplo

// set_value_type.cpp  
// compile with: /EHsc  
#include <set>  
#include <iostream>  
  
int main( )  
{  
   using namespace std;  
   set <int> s1;  
   set <int>::iterator s1_Iter;  
  
   set <int>::value_type svt_Int;   // Declare value_type  
   svt_Int = 10;            // Initialize value_type  
  
   set <int> :: key_type skt_Int;   // Declare key_type  
   skt_Int = 20;             // Initialize key_type  
  
   s1.insert( svt_Int );         // Insert value into s1  
   s1.insert( skt_Int );         // Insert key into s1  
  
   // A set accepts key_types or value_types as elements  
   cout << "The set has elements:";  
   for ( s1_Iter = s1.begin( ) ; s1_Iter != s1.end( ); s1_Iter++)  
      cout << " " << *s1_Iter;  
   cout << "." << endl;  
}  

The set has elements: 10 20.  

<>>
Contenedores
Seguridad para subprocesos en la biblioteca estándar de C++
Biblioteca de plantillas estándar

Mostrar: