`set` (STL/CLR)

Artículo
04/03/2023

La clase de plantilla describe un objeto que controla una secuencia de longitud variable de elementos que tienen acceso bidireccional. El contenedor set se usa para administrar una secuencia de elementos como un árbol ordenado (casi) equilibrado de nodos, cada uno almacenando un elemento.

En la descripción siguiente, GValue es igual GKeyque , que a su vez es igual Key que a menos que este último sea un tipo ref, en cuyo caso es Key^.

Sintaxis

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

Parámetros

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

Requisitos

Encabezado:<cliext/set>

Espacio de nombres: cliext

Declaraciones

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

Función de miembro	Descripción
`set::begin`	Designa el principio de la secuencia controlada.
`set::clear`	Quita todos los elementos.
`set::count`	Cuenta los elementos que coinciden con una clave especificada.
`set::empty`	Comprueba si no hay ningún elemento presente.
`set::end`	Designa el final de la secuencia controlada.
`set::equal_range`	Busca el intervalo que coincide con una clave especificada.
`set::erase`	Quita los elementos de las posiciones especificadas.
`set::find`	Busca un elemento que coincide con una clave especificada.
`set::insert`	Agrega elementos.
`set::key_comp`	Copia el delegado de ordenación de dos claves.
`set::lower_bound`	Busca el principio del intervalo que coincide con una clave especificada.
`set::make_value`	Construye un objeto de valor.
`set::rbegin`	Designa el principio de la secuencia controlada inversa.
`set::rend`	Designa el final de la secuencia controlada inversa.
`set::set`	Construye un objeto contenedor.
`set::size`	Cuenta el número de elementos.
`set::swap`	Intercambia el contenido de dos contenedores.
`set::to_array`	Copia la secuencia controlada en una nueva matriz.
`set::upper_bound`	Busca el final del intervalo que coincide con una clave especificada.
`set::value_comp`	Copia el delegado de ordenación de dos valores de elementos.

Operator	Descripción
`set::operator=`	Reemplaza la secuencia controlada.
`operator!=` (set)	Determina si un `set` objeto no es igual a otro `set` objeto.
`operator<` (set)	Determina si un objeto `set` es menor que otro objeto `set`.
`operator<=` (set)	Determina si un objeto `set` es menor o igual que otro objeto `set`.
`operator==` (set)	Determina si un objeto `set` es igual que otro objeto `set`.
`operator>` (set)	Determina si un objeto `set` es mayor que otro objeto `set`.
`operator>=` (set)	Determina si un objeto `set` es mayor o igual que otro objeto `set`.

Interfaces

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

Comentarios

El objeto asigna y libera almacenamiento para la secuencia que controla como nodos individuales. Inserta elementos en un árbol (casi) equilibrado que mantiene ordenado al modificar los vínculos entre nodos sin copiar nunca el contenido de un nodo a otro. Esto significa que puede insertar y quitar elementos libremente sin alterar los elementos restantes.

El objeto ordena la secuencia que controla llamando a un objeto delegado almacenado de tipo set::key_compare. Puede especificar el objeto delegado almacenado al construir el objeto set; si no especifica ningún objeto delegado, el valor predeterminado es la comparación operator<(key_type, key_type). Para acceder a este objeto almacenado, llame a la función set::key_compmiembro .

Este objeto delegado debe imponer un orden débil estricto en las claves de tipo set::key_type. Esto significa que, para dos claves X y Y:

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

Si key_comp()(X, Y) es true, key_comp()(Y, X) debe ser false.

Si key_comp()(X, Y) es true, se dice que X se ordena antes de Y.

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

En cualquier elemento X que preceda a Y en la secuencia controlada, key_comp()(Y, X) es false. (Para el objeto delegado predeterminado, las claves nunca se reducen en el valor). A diferencia del conjunto de clases de plantilla, un objeto de clase set de plantilla no requiere que las claves de todos los elementos sean únicas. (Dos o más claves pueden tener una ordenación equivalente).

Cada elemento actúa como clave y como valor. La secuencia se representa de forma que permita la búsqueda, inserción y eliminación de un elemento arbitrario en tiempo logarítmico. Es decir, el número de operaciones es proporcional al logaritmo del número de elementos de la secuencia. Además, la inserción de un elemento no invalida ningún iterador, y al quitar un elemento solo se invalidan los iteradores que apuntan al elemento quitado.

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

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

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

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

Miembros

`set::begin`

Designa el principio de la secuencia controlada.

Sintaxis

iterator begin();

Comentarios

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

Ejemplo

// cliext_set_begin.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// inspect first two items
    Myset::iterator it = c1.begin();
    System::Console::WriteLine("*begin() = {0}", *it);
    System::Console::WriteLine("*++begin() = {0}", *++it);
    return (0);
    }

a b c
*begin() = a
*++begin() = b

`set::clear`

Quita todos los elementos.

Sintaxis

void clear();

Comentarios

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

Ejemplo

// cliext_set_clear.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

// add elements and clear again
    c1.insert(L'a');
    c1.insert(L'b');

    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

a b c
size() = 0
a b
size() = 0

`set::const_iterator`

El tipo de un iterador constante para la secuencia controlada.

Sintaxis

typedef T2 const_iterator;

Comentarios

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

Ejemplo

// cliext_set_const_iterator.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    Myset::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        System::Console::Write("{0} ", *cit);
    System::Console::WriteLine();
    return (0);
    }

a b c

`set::const_reference`

El tipo de una referencia constante a un elemento.

Sintaxis

typedef value_type% const_reference;

Comentarios

El tipo describe una referencia constante a un elemento.

Ejemplo

// cliext_set_const_reference.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    Myset::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        {   // get a const reference to an element
        Myset::const_reference cref = *cit;
        System::Console::Write("{0} ", cref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

`set::const_reverse_iterator`

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

Sintaxis

typedef T4 const_reverse_iterator;

Comentarios

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

Ejemplo

// cliext_set_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c" reversed
    Myset::const_reverse_iterator crit = c1.rbegin();
    for (; crit != c1.rend(); ++crit)
        System::Console::Write("{0} ", *crit);
    System::Console::WriteLine();
    return (0);
    }

c b a

`set::count`

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

Sintaxis

size_type count(key_type key);

Parámetros

key
Valor de clave que se va a buscar.

Comentarios

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

Ejemplo

// cliext_set_count.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

a b c
count(L'A') = 0
count(L'b') = 1
count(L'C') = 0

`set::difference_type`

Tipos de una distancia con signo entre dos elementos.

Sintaxis

typedef int difference_type;

Comentarios

El tipo describe un recuento de elementos posiblemente negativo.

Ejemplo

// cliext_set_difference_type.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

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

a b c
end()-begin() = 3
begin()-end() = -3

`set::empty`

Comprueba si no hay ningún elemento presente.

Sintaxis

bool empty();

Comentarios

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

Ejemplo

// cliext_set_empty.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());

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

a b c
size() = 3
empty() = False
size() = 0
empty() = True

`set::end`

Designa el final de la secuencia controlada.

Sintaxis

iterator end();

Comentarios

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

Ejemplo

// cliext_set_end.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// inspect last two items
    Myset::iterator it = c1.end();
    --it;
    System::Console::WriteLine("*-- --end() = {0}", *--it);
    System::Console::WriteLine("*--end() = {0}", *++it);
    return (0);
    }

a b c
*-- --end() = b
*--end() = c

`set::equal_range`

Busca el intervalo que coincide con una clave especificada.

Sintaxis

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

Parámetros

key
Valor de clave que se va a buscar.

Comentarios

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

Ejemplo

// cliext_set_equal_range.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
typedef Myset::pair_iter_iter Pairii;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

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

a b c
equal_range(L'x') empty = True
b

`set::erase`

Quita los elementos de las posiciones especificadas.

Sintaxis

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

Parámetros

first
Principio del intervalo que se va a borrar.

key
Valor de clave que se va a borrar.

last
Fin del intervalo que se va a borrar.

where
Elemento que se va a borrar.

Comentarios

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

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

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

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

Ejemplo

// cliext_set_erase.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// erase an element and reinspect
    System::Console::WriteLine("erase(begin()) = {0}",
        *c1.erase(c1.begin()));

// add elements and display " b c d e"
    c1.insert(L'd');
    c1.insert(L'e');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// erase all but end
    Myset::iterator it = c1.end();
    System::Console::WriteLine("erase(begin(), end()-1) = {0}",
        *c1.erase(c1.begin(), --it));
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

a b c
erase(begin()) = b
b c d e
erase(begin(), end()-1) = e
size() = 1

`set::find`

Busca un elemento que coincide con una clave especificada.

Sintaxis

iterator find(key_type key);

Parámetros

key
Valor de clave que se va a buscar.

Comentarios

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

Ejemplo

// cliext_set_find.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

a b c
find A = False
find b = b
find C = False

`set::generic_container`

Tipo de la interfaz genérica para el contenedor.

Sintaxis

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

Comentarios

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

Ejemplo

// cliext_set_generic_container.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct a generic container
    Myset::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// modify generic and display original
    gc1->insert(L'd');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// modify original and display generic
    c1.insert(L'e');
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a b c d
a b c d e

`set::generic_iterator`

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

Sintaxis

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

Comentarios

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

Ejemplo

// cliext_set_generic_iterator.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct a generic container
    Myset::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

a b c
a b c
a

`set::generic_reverse_iterator`

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

Sintaxis

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

Comentarios

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

Ejemplo

// cliext_set_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct a generic container
    Myset::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

a b c
a b c
c

`set::generic_value`

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

Sintaxis

typedef GValue generic_value;

Comentarios

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

Ejemplo

// cliext_set_generic_value.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct a generic container
    Myset::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

a b c
a b c
a

`set::insert`

Agrega elementos.

Sintaxis

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

Parámetros

first
Principio del intervalo que se va a insertar.

last
Fin del intervalo que se va a insertar.

right
Enumeración que se va a insertar.

val
Valor de clave que se va a insertar.

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

Comentarios

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

La primera función miembro intenta insertar un elemento con el valor val y devuelve un par de valores X. Si X.second es true, X.first designa el elemento que se acaba de insertar; de lo contrario, X.first designa un elemento con una ordenación equivalente que ya existe y no se inserta ningún elemento nuevo. Se usa para insertar un solo elemento.

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

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

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

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

Ejemplo

// cliext_set_insert.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
typedef Myset::pair_iter_bool Pairib;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// insert a single value, unique and duplicate
    Pairib pair1 = c1.insert(L'x');
    System::Console::WriteLine("insert(L'x') = [{0} {1}]",
        *pair1.first, pair1.second);

    pair1 = c1.insert(L'b');
    System::Console::WriteLine("insert(L'b') = [{0} {1}]",
        *pair1.first, pair1.second);

    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// insert a single value with hint
    System::Console::WriteLine("insert(begin(), L'y') = {0}",
        *c1.insert(c1.begin(), L'y'));
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// insert an iterator range
    Myset c2;
    Myset::iterator it = c1.end();
    c2.insert(c1.begin(), --it);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// insert an enumeration
    Myset c3;
    c3.insert(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
insert(L'x') = [x True]
insert(L'b') = [b False]
a b c x
insert(begin(), L'y') = y
a b c x y
a b c x
a b c x y

`set::iterator`

El tipo de un iterador para la secuencia controlada.

Sintaxis

typedef T1 iterator;

Comentarios

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

Ejemplo

// cliext_set_iterator.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    Myset::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        System::Console::Write("{0} ", *it);
    System::Console::WriteLine();
    return (0);
    }

a b c

`set::key_comp`

Copia el delegado de ordenación de dos claves.

Sintaxis

key_compare^key_comp();

Comentarios

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

Ejemplo

// cliext_set_key_comp.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    Myset::key_compare^ kcomp = c1.key_comp();

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

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

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

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

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

`set::key_compare`

Delegado de ordenación para dos claves.

Sintaxis

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

Comentarios

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

Ejemplo

// cliext_set_key_compare.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    Myset::key_compare^ kcomp = c1.key_comp();

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

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

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

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

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

`set::key_type`

El tipo de una clave de ordenación.

Sintaxis

typedef Key key_type;

Comentarios

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

Ejemplo

// cliext_set_key_type.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c" using key_type
    for (Myset::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in key_type object
        Myset::key_type val = *it;

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

a b c

`set::lower_bound`

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

Sintaxis

iterator lower_bound(key_type key);

Parámetros

key
Valor de clave que se va a buscar.

Comentarios

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

Ejemplo

// cliext_set_lower_bound.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

    System::Console::WriteLine("*lower_bound(L'a') = {0}",
        *c1.lower_bound(L'a'));
    System::Console::WriteLine("*lower_bound(L'b') = {0}",
        *c1.lower_bound(L'b'));
    return (0);
    }

a b c
lower_bound(L'x')==end() = True
*lower_bound(L'a') = a
*lower_bound(L'b') = b

`set::make_value`

Construye un objeto de valor.

Sintaxis

static value_type make_value(key_type key);

Parámetros

key
Valor de clave que se va a usar.

Comentarios

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

Ejemplo

// cliext_set_make_value.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(Myset::make_value(L'a'));
    c1.insert(Myset::make_value(L'b'));
    c1.insert(Myset::make_value(L'c'));

// display contents " a b c"
    for each (Myset::value_type elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c

`set::operator=`

Reemplaza la secuencia controlada.

Sintaxis

set<Key>% operator=(set<Key>% right);

Parámetros

right
Contenedor que se va a copiar.

Comentarios

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

Ejemplo

// cliext_set_operator_as.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    for each (Myset::value_type elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// assign to a new container
    Myset c2;
    c2 = c1;
// display contents " a b c"
    for each (Myset::value_type elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c

`set::rbegin`

Designa el principio de la secuencia controlada inversa.

Sintaxis

reverse_iterator rbegin();

Comentarios

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

Ejemplo

// cliext_set_rbegin.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// inspect first two items in reversed sequence
    Myset::reverse_iterator rit = c1.rbegin();
    System::Console::WriteLine("*rbegin() = {0}", *rit);
    System::Console::WriteLine("*++rbegin() = {0}", *++rit);
    return (0);
    }

a b c
*rbegin() = c
*++rbegin() = b

`set::reference`

El tipo de una referencia a un elemento.

Sintaxis

typedef value_type% reference;

Comentarios

El tipo describe una referencia a un elemento.

Ejemplo

// cliext_set_reference.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    Myset::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        {   // get a reference to an element
        Myset::reference ref = *it;
        System::Console::Write("{0} ", ref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

`set::rend`

Designa el final de la secuencia controlada inversa.

Sintaxis

reverse_iterator rend();

Comentarios

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

Ejemplo

// cliext_set_rend.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// inspect first two items
    Myset::reverse_iterator rit = c1.rend();
    --rit;
    System::Console::WriteLine("*-- --rend() = {0}", *--rit);
    System::Console::WriteLine("*--rend() = {0}", *++rit);
    return (0);
    }

a b c
*-- --rend() = b
*--rend() = a

`set::reverse_iterator`

El tipo de un iterador invertido para la secuencia controlada.

Sintaxis

typedef T3 reverse_iterator;

Comentarios

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

Ejemplo

// cliext_set_reverse_iterator.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c" reversed
    Myset::reverse_iterator rit = c1.rbegin();
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("{0} ", *rit);
    System::Console::WriteLine();
    return (0);
    }

c b a

`set::set`

Construye un objeto contenedor.

Sintaxis

set();
explicit set(key_compare^ pred);
set(set<Key>% right);
set(set<Key>^ right);
template<typename InIter>
    setset(InIter first, InIter last);
template<typename InIter>
    set(InIter first, InIter last,
        key_compare^ pred);
set(System::Collections::Generic::IEnumerable<GValue>^ right);
set(System::Collections::Generic::IEnumerable<GValue>^ right,
    key_compare^ pred);

Parámetros

first
Principio del intervalo que se va a insertar.

last
Fin del intervalo que se va a insertar.

pred
Predicado de ordenación de la secuencia controlada.

right
Objeto o intervalo que se va a insertar.

Comentarios

El constructor:

set();

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

El constructor:

explicit set(key_compare^ pred);

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

El constructor:

set(set<Key>% right);

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

El constructor:

set(set<Key>^ right);

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

El constructor:

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

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

El constructor:

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

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

El constructor:

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

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

El constructor:

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

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

Ejemplo

// cliext_set_construct.cpp
// compile with: /clr
#include <cliext/set>

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

    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

    c2.insert(c1.begin(), c1.end());
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct with an iterator range
    Myset c3(c1.begin(), c1.end());
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

// construct with an enumeration
    Myset c5(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c3);
    for each (wchar_t elem in c5)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

// construct from a generic container
    Myset c7(c4);
    for each (wchar_t elem in c7)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct by copying another container
    Myset c8(%c3);
    for each (wchar_t elem in c8)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

size() = 0
a b c
size() = 0
c b a
a b c
c b a
a b c
c b a
c b a
a b c

`set::size`

Cuenta el número de elementos.

Sintaxis

size_type size();

Comentarios

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

Ejemplo

// cliext_set_size.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0} starting with 3", c1.size());

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

// add elements and clear again
    c1.insert(L'a');
    c1.insert(L'b');
    System::Console::WriteLine("size() = {0} after adding 2", c1.size());
    return (0);
    }

a b c
size() = 3 starting with 3
size() = 0 after clearing
size() = 2 after adding 2

`set::size_type`

El tipo de una distancia con signo entre dos elementos.

Sintaxis

typedef int size_type;

Comentarios

El tipo describe un recuento de elementos no negativo.

Ejemplo

// cliext_set_size_type.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

a b c
end()-begin() = 3

`set::swap`

Intercambia el contenido de dos contenedores.

Sintaxis

void swap(set<Key>% right);

Parámetros

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

Comentarios

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

Ejemplo

// cliext_set_swap.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// construct another container with repetition of values
    Myset c2;
    c2.insert(L'd');
    c2.insert(L'e');
    c2.insert(L'f');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// swap and redisplay
    c1.swap(c2);
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
d e f
d e f
a b c

`set::to_array`

Copia la secuencia controlada en una nueva matriz.

Sintaxis

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

Comentarios

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

Ejemplo

// cliext_set_to_array.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

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

    c1.insert(L'd');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// display the earlier array copy
    for each (wchar_t elem in a1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c d
a b c

`set::upper_bound`

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

Sintaxis

iterator upper_bound(key_type key);

Parámetros

key
Valor de clave que se va a buscar.

Comentarios

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

Ejemplo

// cliext_set_upper_bound.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

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

    System::Console::WriteLine("*upper_bound(L'a') = {0}",
        *c1.upper_bound(L'a'));
    System::Console::WriteLine("*upper_bound(L'b') = {0}",
        *c1.upper_bound(L'b'));
    return (0);
    }

a b c
upper_bound(L'x')==end() = True
*upper_bound(L'a') = b
*upper_bound(L'b') = c

`set::value_comp`

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

Sintaxis

value_compare^ value_comp();

Comentarios

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

Ejemplo

// cliext_set_value_comp.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    Myset::value_compare^ kcomp = c1.value_comp();

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

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

`set::value_compare`

Delegado de ordenación de dos valores de elementos.

Sintaxis

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

Comentarios

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

Ejemplo

// cliext_set_value_compare.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    Myset::value_compare^ kcomp = c1.value_comp();

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

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

`set::value_type`

El tipo de un elemento.

Sintaxis

typedef generic_value value_type;

Comentarios

El tipo es un sinónimo de generic_value.

Ejemplo

// cliext_set_value_type.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c" using value_type
    for (Myset::iterator it = c1.begin(); it != c1.end(); ++it)
        {   // store element in value_type object
        Myset::value_type val = *it;

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

a b c

`operator!=` (conjunto)

La lista no es igual a la comparación.

Sintaxis

template<typename Key>
    bool operator!=(set<Key>% left,
        set<Key>% right);

Parámetros

left
Contenedor izquierdo que se va a comparar.

right
Contenedor derecho que se va a comparar.

Comentarios

La función de operador devuelve !(left == right). Se usa para probar si left no se ordena igual que right cuando los dos conjuntos se comparan elemento por elemento.

Ejemplo

// cliext_set_operator_ne.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// assign to a new container
    Myset c2;
    c2.insert(L'a');
    c2.insert(L'b');
    c2.insert(L'd');

// display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] != [a b c] is {0}",
        c1 != c1);
    System::Console::WriteLine("[a b c] != [a b d] is {0}",
        c1 != c2);
    return (0);
    }

a b c
a b d
[a b c] != [a b c] is False
[a b c] != [a b d] is True

`operator<` (conjunto)

La lista es menor que la comparación.

Sintaxis

template<typename Key>
    bool operator<(set<Key>% left,
        set<Key>% right);

Parámetros

left
Contenedor izquierdo que se va a comparar.

right
Contenedor derecho que se va a comparar.

Comentarios

La función de operador devuelve true si, para la posición i más baja para la que !(right[i] < left[i]) también es true que left[i] < right[i]. De lo contrario, devuelve left->size() < right->size(). Se usa para probar si left se ordena antes right de cuando los dos conjuntos se comparan elemento por elemento.

Ejemplo

// cliext_set_operator_lt.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// assign to a new container
    Myset c2;
    c2.insert(L'a');
    c2.insert(L'b');
    c2.insert(L'd');

// display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] < [a b c] is {0}",
        c1 < c1);
    System::Console::WriteLine("[a b c] < [a b d] is {0}",
        c1 < c2);
    return (0);
    }

a b c
a b d
[a b c] < [a b c] is False
[a b c] < [a b d] is True

`operator<=` (conjunto)

Lista menor o igual a la comparación.

Sintaxis

template<typename Key>
    bool operator<=(set<Key>% left,
        set<Key>% right);

Parámetros

left
Contenedor izquierdo que se va a comparar.

right
Contenedor derecho que se va a comparar.

Comentarios

La función de operador devuelve !(right < left). Se usa para probar si left no se ordena después right de cuando los dos conjuntos se comparan elemento por elemento.

Ejemplo

// cliext_set_operator_le.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// assign to a new container
    Myset c2;
    c2.insert(L'a');
    c2.insert(L'b');
    c2.insert(L'd');

// display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] <= [a b c] is {0}",
        c1 <= c1);
    System::Console::WriteLine("[a b d] <= [a b c] is {0}",
        c2 <= c1);
    return (0);
    }

a b c
a b d
[a b c] <= [a b c] is True
[a b d] <= [a b c] is False

`operator==` (conjunto)

La lista es igual a la comparación.

Sintaxis

template<typename Key>
    bool operator==(set<Key>% left,
        set<Key>% right);

Parámetros

left
Contenedor izquierdo que se va a comparar.

right
Contenedor derecho que se va a comparar.

Comentarios

La función de operador devuelve true solo si las secuencias controladas por left y right tienen la misma longitud y, para cada posición i, left[i] == right[i]. Se usa para probar si left se ordena igual que right cuando los dos conjuntos se comparan elemento por elemento.

Ejemplo

// cliext_set_operator_eq.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// assign to a new container
    Myset c2;
    c2.insert(L'a');
    c2.insert(L'b');
    c2.insert(L'd');

// display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] == [a b c] is {0}",
        c1 == c1);
    System::Console::WriteLine("[a b c] == [a b d] is {0}",
        c1 == c2);
    return (0);
    }

a b c
a b d
[a b c] == [a b c] is True
[a b c] == [a b d] is False

`operator>` (conjunto)

La lista es mayor que la comparación.

Sintaxis

template<typename Key>
    bool operator>(set<Key>% left,
        set<Key>% right);

Parámetros

left
Contenedor izquierdo que se va a comparar.

right
Contenedor derecho que se va a comparar.

Comentarios

La función de operador devuelve right < left. Se usa para probar si left se ordena después right de cuando los dos conjuntos se comparan elemento por elemento.

Ejemplo

// cliext_set_operator_gt.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// assign to a new container
    Myset c2;
    c2.insert(L'a');
    c2.insert(L'b');
    c2.insert(L'd');

// display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] > [a b c] is {0}",
        c1 > c1);
    System::Console::WriteLine("[a b d] > [a b c] is {0}",
        c2 > c1);
    return (0);
    }

a b c
a b d
[a b c] > [a b c] is False
[a b d] > [a b c] is True

`operator>=` (conjunto)

La lista es mayor o igual que la comparación.

Sintaxis

template<typename Key>
    bool operator>=(set<Key>% left,
        set<Key>% right);

Parámetros

left
Contenedor izquierdo que se va a comparar.

right
Contenedor derecho que se va a comparar.

Comentarios

La función de operador devuelve !(left < right). Se usa para probar si left no se ordena antes right de que se comparen los dos conjuntos por elemento.

Ejemplo

// cliext_set_operator_ge.cpp
// compile with: /clr
#include <cliext/set>

typedef cliext::set<wchar_t> Myset;
int main()
    {
    Myset c1;
    c1.insert(L'a');
    c1.insert(L'b');
    c1.insert(L'c');

// display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

// assign to a new container
    Myset c2;
    c2.insert(L'a');
    c2.insert(L'b');
    c2.insert(L'd');

// display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] >= [a b c] is {0}",
        c1 >= c1);
    System::Console::WriteLine("[a b c] >= [a b d] is {0}",
        c1 >= c2);
    return (0);
    }

a b c
a b d
[a b c] >= [a b c] is True
[a b c] >= [a b d] is False

Compartir a través de

set (STL/CLR)

Sintaxis

Parámetros

Requisitos

Declaraciones

Interfaces

Comentarios

Miembros

set::begin

Sintaxis

Comentarios

Ejemplo

set::clear

Sintaxis

Comentarios

Ejemplo

set::const_iterator

Sintaxis

Comentarios

Ejemplo

set::const_reference

Sintaxis

Comentarios

Ejemplo

set::const_reverse_iterator

Sintaxis

Comentarios

Ejemplo

set::count

Sintaxis

Parámetros

Comentarios

Ejemplo

set::difference_type

Sintaxis

Comentarios

Ejemplo

set::empty

Sintaxis

Comentarios

Ejemplo

set::end

Sintaxis

Comentarios

Ejemplo

set::equal_range

Sintaxis

Parámetros

Comentarios

Ejemplo

set::erase

Sintaxis

Parámetros

Comentarios

Ejemplo

set::find

Sintaxis

Parámetros

Comentarios

Ejemplo

set::generic_container

Sintaxis

Comentarios

Ejemplo

set::generic_iterator

Sintaxis

Comentarios

Ejemplo

set::generic_reverse_iterator

Sintaxis

Comentarios

Ejemplo

set::generic_value

Sintaxis

Comentarios

Ejemplo

set::insert

Sintaxis

Parámetros

`set` (STL/CLR)

`set::begin`

`set::clear`

`set::const_iterator`

`set::const_reference`

`set::const_reverse_iterator`

`set::count`

`set::difference_type`

`set::empty`

`set::end`

`set::equal_range`

`set::erase`

`set::find`

`set::generic_container`

`set::generic_iterator`

`set::generic_reverse_iterator`

`set::generic_value`

`set::insert`

`set::iterator`

`set::key_comp`

`set::key_compare`

`set::key_type`

`set::lower_bound`

`set::make_value`

`set::operator=`

`set::rbegin`

`set::reference`

`set::rend`

`set::reverse_iterator`

`set::set`

`set::size`

`set::size_type`

`set::swap`

`set::to_array`