Diferentes formas de inicializar un mapa en C++

Map es un contenedor asociativo disponible en la Biblioteca de plantillas estándar (STL) de C++ que se utiliza para almacenar pares clave-valor. Veamos las diferentes formas de inicializar un mapa en C++ .

1. Inicialización mediante asignación y operador de subíndice
2. Inicialización usando una lista de inicializadores
3. Inicialización usando una array de pares
4. Inicialización desde otro mapa usando el método map.insert()
5. Inicialización desde otro mapa usando el constructor de copia
6. 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 es usar los operadores de asignación (=) y subíndice ([]) como se muestra a continuación:

Sintaxis:

mapa<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++ program to implement the 
// above approach
#include <iostream>
#include <map>
using namespace std;
  
// Driver code
int main() 
{
   // Initialize map using 
   // default constructor
   map<string, string>New_Map;
   
   // Keep on adding key-value pairs 
   // using subscript([]) and 
   // assignment(=) operators
   New_Map["Ground"] = "Grass";
   New_Map["Floor"] = "Cement";
   New_Map["Table"] = "Wood";
   
   // Traverse through the map
   for(auto x: New_Map)
   {
      cout << x.first << "->" << 
              x.second <<endl;
   }
   return 0;
}

Floor->Cement
Ground->Grass
Table->Wood

2. Inicialización utilizando una lista de inicializadores

Otra forma de inicializar un mapa es utilizar una lista predefinida de pares clave-valor.

Sintaxis:

map<string, string>New_Map = {{clave1, valor1}, 
                                                    {clave2, valor2}, 
                                                    {clave3, valor3}}; 

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

// C++ program to implement 
// the above approach
#include <iostream>
#include <map>
using namespace std;
  
// Driver code
int main() 
{
   // Initialize map using 
   // default constructor
   map<string, string>New_Map;
   
   // Adding key-value pairs 
   // using Initializer list
   New_Map = {{"Ground", "Grass"}, 
              {"Floor", "Cement"}, 
              {"Table", "Wood"}};
     
   // Traverse through the map
   for(auto x: New_Map)
   {
      cout << x.first << "->" << 
              x.second <<endl;
   }
   return 0;
}

Floor->Cement
Ground->Grass
Table->Wood

3. Inicialización usando una array de pares

El mapa almacena pares clave-valor, uno puede almacenar los valores clave utilizando la array de pares del mismo tipo.

Sintaxis:

mapa<string, string>Nuevo_mapa(antiguo_arr, antiguo_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, se pueden usar los iteradores incorporados para copiar contenidos del vector de pares en el nuevo mapa.

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++ 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]));
   
   // Add these key-value pairs using 
   // the pairs stored in the array of pairs   
   map<string, string>New_Map(old_arr, 
                              old_arr + n);
   
   // Traverse through the map
   for(auto x: New_Map)
   {
      cout << x.first << "->" << 
              x.second <<endl;
   }   
   return 0;
}

Floor->Cement
Ground->Grass
Table->Wood

4. Inicialización desde otro mapa usando el método map.insert()

Una forma estándar de copiar elementos de un mapa a un mapa antiguo existente en C++ es usar la función de miembro map .insert .

Sintaxis:

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++ program to implement 
// the above approach
#include <iostream>
#include <map>
using namespace std;
  
// Driver code
int main() 
{
   // Initialize an map using 
   // default constructor
   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   
   map<string, string>New_Map;
   New_Map.insert(old_map.begin(),
                  old_map.end());
   
   // Traverse through the map
   for(auto x: New_Map)
   {
      cout << x.first << "->" << 
              x.second <<endl;
   }
}

Floor->Cement
Ground->Grass
Table->Wood

5. Inicialización desde otro mapa utilizando un constructor de copias 

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

Sintaxis:

mapa<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++ program to implement 
// the above approach
#include <iostream>
#include <map>
using namespace std;
  
// Driver code
int main() 
{
   // Initialize a map using 
   // default constructor
   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   
   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;
}

Floor->Cement
Ground->Grass
Table->Wood

6. Inicialización a través de un rango

Otra forma de inicializar un mapa es inicializarlo a través de un rango de pares clave-valor.

Sintaxis:

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++ program to implement 
// the above approach
#include <iostream>
#include <map>
using namespace std;
  
// Driver code
int main() 
{
   // Initialize a map using 
   // default constructor
   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
   map<string, string>New_Map(old_map.begin(), 
                              old_map.end());
   
   // Traverse through the map
   for(auto x: New_Map)
   {
      cout << x.first << "->" << 
              x.second <<endl;
   }
   return 0;
}

Floor->Cement
Ground->Grass
Table->Wood