unordered_map es un contenedor asociado disponible en la Biblioteca de plantillas estándar (STL) de C++ que se utiliza para almacenar pares clave-valor. Utiliza internamente el principio de funcionamiento de un hashmap para almacenar pares clave-valor.
Diferentes formas de inicializar un mapa_desordenado en C++ :
- Inicialización mediante asignación y operador de subíndice
- Inicialización usando una lista de inicializadores
- Inicialización usando una array de pares
- Inicialización desde otro mapa usando el método unordered_map.insert()
- Inicialización desde otro mapa usando el constructor de copia
- Inicialización a través de un rango
1. Inicialización mediante el operador de asignación y subíndice
Una de las formas más simples de inicializar un mapa_desordenado es usar los operadores de asignación(=) y subíndice([]) como se muestra a continuación:
Sintaxis:
mapa_desordenado<string,string>Nuevo_mapa;
Nuevo_mapa[“5”] = “6”;
Aquí,
- [] es el operador de subíndice
- = es el operador de asignación
A continuación se muestra el programa C++ para implementar el enfoque anterior:
C++
// C++ program to implement
// the above approach
#include <iostream>
#include <unordered_map>
using namespace std;
// Driver code
int main()
{
// Initialize unordered_map
// using default constructor
unordered_map<string,string>New_map;
// Adding key-value pairs using
// subscript([]) and assignment(=)
// operators
New_map["Ground"] = "Grass";
New_map["Floor"] = "Cement";
New_map["Table"] = "Wood";
// Traverse through the unordered_map
for(auto x: New_map)
{
cout << x.first << "->" <<
x.second <<endl;
}
return 0;
}
Table->Wood Ground->Grass Floor->Cement
2. Inicialización usando una lista de inicializadores
Otra forma de inicializar un mapa_desordenado es usar una lista predefinida de pares clave-valor.
Sintaxis:
mapa_desordenado<string,string>Nuevo_mapa = {{clave1, valor1}, {clave2, valor2}, {clave3, valor3}};
A continuación se muestra el programa C++ para implementar el enfoque anterior:
C++
// C++ program to implement
// the above approach
#include <iostream>
#include <unordered_map>
using namespace std;
// Driver code
int main()
{
// Initialize unordered_map using
// default constructor
unordered_map<string, string>New_map;
// Adding key-value pairs using
// Initializer list
New_map = {{"Ground", "Grass"},
{"Floor", "Cement"},
{"Table", "Wood"}};
// Traverse through the unordered_map
for(auto x: New_map)
{
cout << x.first << "->" <<
x.second <<endl;
}
return 0;
}
Table->Wood Floor->Cement Ground->Grass
3. Inicialización usando una array de pares
Como unordered_map almacena pares clave-valor, uno puede almacenar los valores clave utilizando la array de pares del mismo tipo.
Sintaxis:
mapa_desordenado<string, string>Nuevo_mapa(antigua_arr, antigua_arr + n);
Aquí, old_arr es la array de pares desde la que se copiarán los contenidos en new_map.
En el caso del vector de pares, utilice los iteradores incorporados para copiar contenidos del vector de pares en el nuevo mapa_desordenado.
unordered_map<int, int>New_map(old_vector.begin(), old_vector.end());
Aquí, old_vector es el vector de pares desde el cual se copiarán los contenidos en new_map.
A continuación se muestra el programa C++ para implementar el enfoque anterior:
C++
// 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
pair<string,string>old_arr[] =
{
make_pair("Ground", "Grass"),
make_pair("Floor", "Cement"),
make_pair("Table", "Wood")
};
int n = (sizeof(old_arr) /
sizeof(old_arr[0]));
// Adding these key-value pairs using
// the pairs stored in the array of pairs
unordered_map<string,
string>New_map(old_arr,
old_arr + n);
// Traverse through the unordered_map
for(auto x: New_map)
{
cout << x.first << "->" <<
x.second <<endl;
}
return 0;
}
Table->Wood Floor->Cement Ground->Grass
4. Inicialización desde otro mapa usando el método unordered_map.insert()
Una forma estándar de copiar elementos de un mapa a un mapa antiguo existente en C++ es usar unordered_map. inserte la función miembro como se muestra a continuación:
Sintaxis:
unordered_map<string, string> New_map;
New_map.insert(old_map.begin(), old_map.end());
Aquí, old_map es el mapa desde el cual se copiarán los contenidos en new_map.
A continuación se muestra el programa C++ para implementar el enfoque anterior:
C++
// C++ program to implement
// the above approach
#include <iostream>
#include <unordered_map>
using namespace std;
// Driver code
int main()
{
// Initialize an unordered_map using
// default constructor
unordered_map<string,string>old_map;
// Adding key-value pairs using
// subscript([]) and assignment(=)
// operators
old_map["Ground"] = "Grass";
old_map["Floor"] = "Cement";
old_map["Table"] = "Wood";
// Create a new_map where contents
// of the previous map will be copied
// using copy constructor and iterator
// provided by the map
unordered_map<string, string>New_map;
New_map.insert(old_map.begin(),
old_map.end());
// Traverse through the unordered_map
for(auto x: New_map)
{
cout << x.first << "->" <<
x.second <<endl;
}
return 0;
}
Floor->Cement Ground->Grass Table->Wood
5. Inicialización desde otro mapa usando el constructor de copias
Una forma de inicializar un mapa_desordenado es copiar los contenidos de otro mapa uno tras otro usando el constructor de copias.
Sintaxis:
mapa_desordenado<string, string>Nuevo_mapa(antiguo_mapa);
Aquí, old_map es el mapa desde el cual se copiarán los contenidos en new_map.
A continuación se muestra el programa C++ para implementar el enfoque anterior:
C++
// C++ program to implement
// the above approach
#include <iostream>
#include <unordered_map>
using namespace std;
// Driver code
int main()
{
// Initialize an unordered_map
// using default constructor
unordered_map<string,string>old_map;
// Adding key-value pairs using
// subscript([]) and assignment(=)
// operators
old_map["Ground"] = "Grass";
old_map["Floor"] = "Cement";
old_map["Table"] = "Wood";
// Create a new_map where contents of
// the previous map will be copied using
// copy constructor
unordered_map<string, string>New_map(old_map);
// Traverse through the unordered_map
for(auto x: New_map)
{
cout << x.first << "->" <<
x.second <<endl;
}
return 0;
}
Table->Wood Ground->Grass Floor->Cement
6. Inicialización a través de un rango
Otra forma de inicializar un mapa_desordenado es inicializarlo a través de un rango de pares clave-valor.
Sintaxis:
unordered_map<string,string>New_map(old_map.begin(),old_map.end());
Aquí, en lugar de usar otro mapa, almacenamos cualquier rango de pares clave-valor.
A continuación se muestra el programa C++ para implementar el enfoque anterior:
C++
// C++ program to implement
// the above approach
#include <iostream>
#include <unordered_map>
using namespace std;
// Driver code
int main()
{
// Initialize an unordered_map
// using default constructor
unordered_map<string, string>old_map;
// Adding key-value pairs using subscript([])
// and assignment(=) operators
old_map["Ground"] = "Grass";
old_map["Floor"] = "Cement";
old_map["Table"] = "Wood";
// Create a new_map where a range of
// key-value pairs are stored from
// old_map
unordered_map<string,
string>New_map(old_map.begin(),
old_map.end());
// Traverse through the unordered_map
for(auto x: New_map)
{
cout << x.first << "->" <<
x.second <<endl;
}
return 0;
}
Floor->Cement Ground->Grass Table->Wood
Publicación traducida automáticamente
Artículo escrito por shinjanpatra y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA