在 C++ 中初始化映射的不同方法

Map是 C++ 标准模板库 (STL) 中可用的关联容器，用于存储键值对。让我们看看在 C++ 中初始化映射的不同方法。

使用赋值和下标运算符初始化
使用初始化列表进行初始化
使用对数组进行初始化
使用 map.insert() 方法从另一个地图初始化
使用复制构造函数从另一个映射初始化
通过范围初始化

1. 使用赋值和下标运算符初始化

初始化映射的最简单方法之一是使用赋值（=）和下标（[]）运算符，如下所示：

句法：

mapNew_Map;

New_Map[“5”] = “6”;

编程需要懂一点英语

这里

[] 是下标运算符
= 是赋值运算符

下面是实现上述方法的 C++ 程序：

C++

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


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

C++
// C++ program to implement
// the above approach
#include 
using namespace std;
  
// Driver code
int main() 
{
   // Initialize an array of pair 
   // of strings
   pairold_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   
   mapNew_Map(old_arr, 
                              old_arr + n);
   
   // Traverse through the map
   for(auto x: New_Map)
   {
      cout << x.first << "->" << 
              x.second <

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

C++
// C++ program to implement 
// the above approach
#include 
#include 
using namespace std;
  
// Driver code
int main() 
{
   // Initialize a map using 
   // default constructor
   mapold_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   
   mapNew_Map(old_map);
   
   // Traverse through the unordered_map
   for(auto x: New_Map)
   {
      cout << x.first << "->" << 
              x.second <

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

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

`2. 使用初始化列表进行初始化`

初始化映射的另一种方法是使用预定义的键值对列表。

句法：

mapNew_Map = {{key1, value1}, {key2, value2}, {key3, value3}};


         编程需要懂一点英语

下面是实现上述方法的 C++ 程序：

`C++`

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

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

`3. 使用一对数组进行初始化`

映射存储键值对，可以使用相同类型的对数组存储键值。

句法：

mapNew_map(old_arr, old_arr + n);


         编程需要懂一点英语

这里，old_arr 是将内容复制到 new_map 的对数组。

在对向量的情况下，可以使用内置的迭代器将内容从对向量复制到新映射中。

mapNew_Map(old_vector.begin(), old_vector.end());


        编程需要懂一点英语

这里，old_vector 是将内容复制到 new_map 的对向量。

下面是实现上述方法的 C++ 程序：

`C++`

// C++ program to implement
// the above approach
#include 
using namespace std;
  
// Driver code
int main() 
{
   // Initialize an array of pair 
   // of strings
   pairold_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   
   mapNew_Map(old_arr, 
                              old_arr + n);
   
   // Traverse through the map
   for(auto x: New_Map)
   {
      cout << x.first << "->" << 
              x.second <

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

`4. 使用 map.insert() 方法从另一个地图初始化`

在 C++ 中将元素从地图复制到现有旧地图的标准方法是使用 map .insert成员函数。

句法：

map New_Map; New_Map.insert(old_map.begin(), old_map.end());


         编程需要懂一点英语

这里，old_map 是将内容复制到 new_map 的地图。

下面是实现上述方法的 C++ 程序：

`C++`

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

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

`5. 使用复制构造函数从另一个地图初始化`

初始化映射的一种方法是使用复制构造函数一个接一个地从另一个映射复制内容。

句法：

mapNew_Map(old_map);


         编程需要懂一点英语

这里，old_map 是将内容复制到 new_map 的地图。

下面是实现上述方法的 C++ 程序：

`C++`

// C++ program to implement 
// the above approach
#include 
#include 
using namespace std;
  
// Driver code
int main() 
{
   // Initialize a map using 
   // default constructor
   mapold_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   
   mapNew_Map(old_map);
   
   // Traverse through the unordered_map
   for(auto x: New_Map)
   {
      cout << x.first << "->" << 
              x.second <

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

`6. 通过范围初始化`

初始化映射的另一种方法是通过一系列键值对对其进行初始化。

句法：

mapNew_Map(old_map.begin(), old_map.end());


         编程需要懂一点英语

在这里，我们不使用另一个映射，而是存储任意范围的键值对。

下面是实现上述方法的 C++ 程序：

`C++`

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

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