Formas de inicializar un conjunto de ETS en C ++

"rojo naranja amarillo verde azul índigo violeta"

Este es un ejemplo de un conjunto literal en matemáticas, así como en C++. También es una matriz literal. Es un conjunto de cuerdas. Conjuntos de enteros, flotadores, dobles, etc., también son posibles.

STD significa estándar. Este artículo está en formas de inicializar un conjunto como código. Hay una clase establecida en un módulo en la biblioteca estándar C ++. Inicialización aquí, significa dar valores al conjunto en el momento de la creación. Crear un conjunto es construir el conjunto.

Se puede construir un conjunto con los valores iniciales. Un conjunto también se puede construir vacío y luego los valores insertados después de la creación.

El módulo establecido (subcon biblioteca) debe incluirse en el programa antes de que se pueda crear un objeto establecido e inicializarlo al mismo tiempo. Un programa C ++ que involucra conjuntos debe comenzar de la siguiente manera:

#incluir
#incluir
usando el espacio de nombres STD;

La primera línea en este segmento de código incluye la biblioteca de iOStream (sub). Si la salida (y la entrada) es para el terminal (consola), entonces la biblioteca iostream debe incluirse. La segunda línea incluye la biblioteca Set (sub); es un requisito. La tercera línea no es una directiva; Es una declaración. Insiste en que cualquier nombre utilizado sin precedirlo con un nombre de espacio de nombres de usuarios es del espacio de nombres estándar de C ++.

El resto de este artículo explica diferentes formas de inicializar el conjunto durante la construcción con los diferentes métodos de construcción. Al final del artículo, se aborda los valores (insertar) al conjunto vacío.

set (Initializer_list, const compare & = compare (), const allocator & = allocator ()))

Este es un constructor para crear un conjunto. Su primer argumento es el set Initializer_list. El inicialyer_list es el set literal. Es lo mismo que el literal de la matriz. Si no se escriben el segundo y tercer argumentos, entonces se emplearán sus argumentos predeterminados. El siguiente programa muestra este constructor en acción con su inicialización:

#incluir
#incluir
#incluir
usando el espacio de nombres STD;
int main ()

establecer st ("rojo", "naranja", "amarillo", "verde", "azul", "índigo", "violeta");
para (set :: iterator iter = st.comenzar(); iter != ST.fin(); iter ++)
cout << *iter << ", ";
cout << endl;
regresar 0;

La salida es:

azul, verde, índigo, naranja, rojo, violeta, amarillo,

Observe que la salida se clasifica en orden ascendente, mientras que la entrada (primer argumento) no se ordenó.

También tenga en cuenta que para usar cadenas, la clase de cadena debe incluirse; De lo contrario, son los consejos de las cuerdas los que se clasificarán, y no los literales alfabéticos de cuerda mismos.

set & operator = (inicializer_list)

Este es el formulario de constructor de copia del constructor anterior. Todavía hace inicialización. El siguiente programa muestra este constructor en acción con su inicialización:

#incluir
#incluir
#incluir
usando el espacio de nombres STD;
int main ()

establecer st = "rojo", "naranja", "amarillo", "verde", "azul", "índigo", "violeta";
para (set :: iterator iter = st.comenzar(); iter != ST.fin(); iter ++)
cout << *iter << ", ";
cout << endl;
regresar 0;

La salida es:

azul, verde, índigo, naranja, rojo, violeta, amarillo,

Observe que la salida se clasifica en orden ascendente, mientras que la entrada (primer argumento) no se ordenó.

set (const set & x)

Este constructor crea un segundo conjunto utilizando el identificador de un conjunto anterior como argumento. Inmediatamente después de la creación, hay dos copias del mismo contenido. El siguiente programa muestra este constructor en acción con su inicialización:

#incluir
#incluir
#incluir
usando el espacio de nombres STD;
int main ()

establecer st = "rojo", "naranja", "amarillo", "verde", "azul", "índigo", "violeta";
establecer st2 (st); // Inicialización
para (set :: iterator iter = st2.comenzar(); iter != ST2.fin(); iter ++)
cout << *iter << ", ";
cout << endl;
regresar 0;

La salida es:

azul, verde, índigo, naranja, rojo, violeta, amarillo,

Observe que la salida se clasifica en orden ascendente, mientras que la entrada (primer argumento) no se ordenó.

set & operator = (const set & x)

Este es un constructor de copias real. Todavía hace inicialización. El siguiente programa muestra este constructor en acción con su inicialización:

#incluir
#incluir
#incluir
usando el espacio de nombres STD;
int main ()

establecer st = "rojo", "naranja", "amarillo", "verde", "azul", "índigo", "violeta";
establecer st2 = st; // Inicialización
para (set :: iterator iter = st2.comenzar(); iter != ST2.fin(); iter ++)
cout << *iter << ", ";
cout << endl;
regresar 0;

La salida es:

azul, verde, índigo, naranja, rojo, violeta, amarillo,

Observe que la salida se clasifica en orden ascendente, mientras que la entrada (primer argumento) no se ordenó.

Conjunto de plantilla (InputIterator First, Inputiterator Last, Const Compare & Comp = Compare (), Const Allocator & = Allocator ());

Este constructor creará un nuevo conjunto copiando un rango de valores de otro conjunto. El rango comienza desde el valor apuntado por primera. Si no se escriben los otros argumentos para el constructor, se emplearán sus argumentos predeterminados. El argumento de la plantilla es la clase de iterador. El siguiente programa muestra este constructor en acción con su inicialización:

#incluir
#incluir
#incluir
usando el espacio de nombres STD;
int main ()

establecer st = "rojo", "naranja", "amarillo", "verde", "azul", "índigo", "violeta";
set :: iterator iterf = st.comenzar(); iterf ++;
set :: iterator iterl = st.fin(); iterl--;
establecer st2 (iterf, iterl); // Inicialización
para (set :: iterator iter = st2.comenzar(); iter != ST2.fin(); iter ++)
cout << *iter << ", ";
cout << endl;
regresar 0;

La salida es:

verde, índigo, naranja, rojo, violeta,

que no es exactamente lo que podría haber sido esperado. La razon es la siguiente:

La entrada es:

"rojo naranja amarillo verde azul índigo violeta"

Por lo tanto, podría haberse esperado que se omitan "Red" y "Violeta". En cambio, fue "azul" y "amarillo" los que se omitieron. Ahora, cuando un conjunto no ordenado se ingresa en un conjunto, se clasifica. De la lista ordenada, se omitieron los valores en los extremos extremos.

Set e insert () vacío ()

El siguiente programa crea un conjunto vacío antes de insertar los valores:

#incluir
#incluir
#incluir
usando el espacio de nombres STD;
int main ()

establecer st;
calle.insertar ("rojo"); calle.insertar ("naranja"); calle.insertar ("amarillo"); calle.insertar ("verde");
calle.insertar ("azul"); calle.insertar ("índigo"); calle.insertar ("violeta");
para (set :: iterator iter = st.comenzar(); iter != ST.fin(); iter ++)
cout << *iter << ", ";
cout << endl;
regresar 0;

La salida es:

azul, verde, índigo, naranja, rojo, violeta, amarillo,

Observe que la salida se clasifica en orden ascendente, mientras que la entrada (primer argumento) no se ordenó.

Conclusión

La inicialización es cuando se agregan valores a medida que se crea el conjunto. Después de esta fase, los valores se clasifican ascendiendo con la configuración predeterminada. Las formas comunes de inicializar un conjunto en C ++ implican construcción convencional de construcción y copia. Se han explicado arriba.

Chrys