Diferentes formas de inicializar un conjunto desordenado en C++

Un conjunto unordered_set es un contenedor asociado disponible en la biblioteca de plantillas estándar (STL) de C++ que se utiliza para elementos únicos sin ningún orden específico. Utiliza internamente el principio de funcionamiento de una tabla hash para almacenar elementos.

Diferentes formas de inicializar un conjunto desordenado en C++

1. Inicialización usando el constructor por defecto
2. Inicialización usando una lista de inicializadores
3. Inicialización usando una array
4. Inicialización usando un vector
5. Inicialización desde otro conjunto usando el constructor de copia
6. Inicialización desde otra estructura de datos iterables usando el constructor de rango

Vamos a discutir cada uno de estos temas en detalle.

1. Inicialización utilizando el constructor predeterminado

Una forma estándar de inicializar un conjunto_desordenado es inicializar usando el constructor predeterminado, esto generará un conjunto_desordenado vacío. Podemos agregar más elementos usando unordered_set incorporado. Insertar() método. 

Sintaxis:

conjunto_desordenado<string>Nuevo_conjunto;
Nuevo_conjunto.insertar(elemento1)

Aquí, el método insert() se puede usar más para insertar elementos en unordered_set

A continuación se muestra el programa C++ para implementar el enfoque anterior:

// C++ program to implement
// the above approach
#include <iostream>
#include <unordered_set>
using namespace std;
 
// Driver code
int main()
{   
    // Initialize unordered_set
    // using default constructor
    unordered_set<string>New_set;
   
    // unordered_set.insert() method to
    // insert elements to the unordered_set
    New_set.insert("Ground");
    New_set.insert("Grass");
    New_set.insert("Floor");
    New_set.insert("Table");
    New_set.insert("Wood");
     
    // Traverse through the unordered_set
    for(auto x: New_set)
    {
       cout << x << endl;
    }
    return 0;
}

Wood
Table
Floor
Ground
Grass

2. Inicialización usando una lista de inicializadores

Otra forma de inicialización es pasar una lista predefinida de elementos (initializer_list) como argumento al constructor predeterminado de unordered_set.

Sintaxis:

conjunto_desordenado<string>Nuevo_conjunto({elemento1, elemento2, elemento3, elemento4}); 

A continuación se muestra el programa C++ para implementar el enfoque anterior:

// C++ program to implement
// the above approach
#include <iostream>
#include <unordered_set>
using namespace std;
 
// Driver code
int main()
{   
    // Initialize unordered_set passing
    // initializer list as an argument
    // to the default constructor
    unordered_set<string>New_set({"Ground",
                                  "Grass",
                                  "Floor",
                                  "Table" ,
                                  "Wood"});
     
    // Traverse through the unordered_set
    for(auto x: New_set)
    {
       cout << x << endl;
    }  
    return 0;
}

Wood
Table
Floor
Grass
Ground

3. Inicialización usando una array

Como unordered_set almacena elementos únicos, uno puede almacenar los elementos usando una array del mismo tipo de datos.

Sintaxis:

unordered_set<string>New_set(old_arr, old_arr + n); 

Aquí, old_arr es la array de strings desde las que se copiarán los contenidos en New_set.

A continuación se muestra el programa C++ para implementar el enfoque anterior:

// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Driver code
int main()
{
    // Initialize an array of pair
    // of strings
    string old_arr[] = {"Ground",
                        "Grass" ,
                        "Floor",
                        "Cement",
                        "Table"};
    int n = (sizeof(old_arr) /
             sizeof(old_arr[0]));
   
    // Adding these elements stored
    // in the array   
    unordered_set<string>New_set(old_arr,
                                 old_arr + n);
   
    // Traverse through the unordered_map
    for(auto x: New_set)
    {
       cout << x << endl;
    }
    return 0;
}

Table
Cement
Floor
Grass
Ground

4. Inicialización usando un Vector

Uno puede almacenar los elementos en unordered_set usando un vector del mismo tipo de datos.

Sintaxis:

unordered_set<string>New_set(old_vector.begin(), old_vector.end()); 

Aquí, old_vector es el vector de strings desde el cual se copiarán los contenidos en New_set.

A continuación se muestra el programa C++ para implementar el enfoque anterior:

// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Driver code
int main()
{
    // Initialize an array of pair
    // of strings
    vector<string>old_arr = {"Ground",
                             "Grass",
                             "Floor",
                             "Cement",
                             "Table"};
   
    // Adding these elements stored
    // in the vector   
    unordered_set<string>New_set(old_arr.begin(),
                                 old_arr.end());
   
    // Traverse through the unordered_map
    for(auto x: New_set)
    {
       cout << x << endl;
    }
    return 0;
}

Table
Cement
Floor
Grass
Ground

5. Inicialización desde otro conjunto utilizando el constructor de copias

Una forma de inicializar un conjunto_desordenado es copiar los contenidos de otro conjunto uno tras otro usando el constructor de copias.

Sintaxis:

conjunto_desordenado<string>Nuevo_conjunto(antiguo_conjunto);

Aquí, old_set es el conjunto desde el cual se copiarán los contenidos en el new_set.

A continuación se muestra el programa C++ para implementar el enfoque anterior:

// C++ program to implement
// the above approach
#include <iostream>
#include <unordered_set>
using namespace std;
 
// Driver code
int main()
{
    // Initialize an unordered_set
    // using default constructor
    unordered_set<string>old_set;
   
    // unordered_set.insert() method
    // to insert elements to the
     // unordered_set
    old_set.insert("Ground");
    old_set.insert("Grass");
    old_set.insert("Floor");
    old_set.insert("Table");
    old_set.insert("Wood");
   
   
    // Create a new_set where contents
    // of the previous set will be copied
    // using copy constructor   
    unordered_set<string>New_set(old_set);
   
    // Traverse through the unordered_map
    for(auto x: New_set)
    {
       cout << x <<endl;
    }   
    return 0;
}

Wood
Table
Floor
Ground
Grass

6. Inicialización desde otra estructura de datos iterables usando el constructor de rangos

Otra forma de inicializar un conjunto_desordenado es usar un constructor de rango para copiar elementos de una estructura de datos iterables (conjunto_desordenado en este ejemplo) al conjunto_desordenado recién inicializado. 

Sintaxis:

unordered_set<string>New_set(begin(old_set), end(old_set));

Aquí, old_set es el conjunto desde el cual se copiarán los contenidos en New_set.

A continuación se muestra el programa C++ para implementar el enfoque anterior:

// C++ program to implement
// the above approach
#include <iostream>
#include <unordered_set>
using namespace std;
 
// Driver code
int main()
{
    // Initialize an unordered_set using
    // default constructor
    unordered_set<string>old_set;
   
    // unordered_set.insert() method to
    // insert elements to the unordered_set
    old_set.insert("Ground");
    old_set.insert("Grass");
    old_set.insert("Floor");
    old_set.insert("Table");
    old_set.insert("Wood");
   
   
    // Create a new_set where contents of
    // the previous set will be copied using
    // range constructor   
    unordered_set<string>New_set(begin(old_set),
                                 end(old_set));
   
    // Traverse through the unordered_map
    for(auto x: New_set)
    {
       cout << x <<endl;
    }
    return 0;
}

Grass
Ground
Floor
Table
Wood