Array of unordered maps in C++ with Examples
Last Updated :
27 Dec, 2021
Improve
What is an array?
An array in any programming language is a data structure that is used to store elements or data items of similar data types at contiguous memory locations and elements can be accessed randomly using indices of an array. Arrays are efficient when we want to store a large number of elements that too of similar data types.
What is Unordered Map?
Unordered_map is an associated container that stores elements formed by the combination of key-value and a mapped value. The key value is used to uniquely identify the element and the mapped value is the content associated with the key. Both key and value can be of any type predefined or user-defined. Elements in an unordered map are not arranged in any particular order. Internally, an unordered map is implemented using a Hash Table.
Functions used with unordered map:
- at(): This function in C++ unordered_map returns the reference to the value with the element as key k.
- begin(): Returns an iterator pointing to the first element in the container in the unordered_map container
- end(): Returns an iterator pointing to the position past the last element in the container in the unordered_map container
This article focuses on how the array of unordered maps can be used in C++. An array of unordered maps can be quite useful while designing complex data structures.
Array of unordered maps
C++ allows us a facility to create an array of unordered maps. An array of unordered maps is an array in which each element is a map on its own.
Syntax:
unordered_map<<dataType1, dataType2>> myContainer[N];
Here,
N: The size of the array of unordered maps
dataType1: The dataType for the key
dataType2: The dataType for the value
Example 1: Below is the C++ program to implement the approach:
// C++ program to demonstrate the
// working of array of unordered maps in C++
#include <bits/stdc++.h>
using namespace std;
// Function to print unordered map elements
// specified at the index, "index"
void print(unordered_map<int, bool>& myMap,
int index)
{
cout << "The unordered map elements stored " <<
"at the index " << index << ": \n";
cout << "Key Value\n";
// Each element of the map is a pair on
// its own
for (auto pr : myMap)
{
// Each element of the map is a pair
// on its own
cout << pr.first << " " <<
pr.second << '\n';
}
cout << '\n';
}
// Function to iterate over all the array
void print(unordered_map<int,
bool>* myContainer, int n)
{
// Iterating over myContainer elements
// Each element is a map on its own
for (int i = 0; i < n; i++)
{
print(myContainer[i], i);
}
}
// Driver code
int main()
{
// Declaring an array of unordered maps
// In unordered map Key is of type int
// Value is of type bool
unordered_map<int, bool> myContainer[3];
// Mapping values to the unordered map
// stored at the index 0
myContainer[0][10] = true;
myContainer[0][15] = false;
myContainer[0][20] = true;
myContainer[0][25] = false;
// Mapping values to the unordered map
// stored at the index 1
myContainer[1][30] = true;
myContainer[1][35] = false;
myContainer[1][40] = true;
myContainer[1][45] = false;
// Mapping values to the unordered map
// stored at the index 2
myContainer[2][50] = true;
myContainer[2][55] = false;
myContainer[2][60] = true;
myContainer[2][65] = false;
// Calling print function to iterate
// over myContainer elements
print(myContainer, 3);
return 0;
}
73
1
// C++ program to demonstrate the2
// working of array of unordered maps in C++3
4
using namespace std;5
6
// Function to print unordered map elements7
// specified at the index, "index"8
void print(unordered_map<int, bool>& myMap,9
int index)10
{11
cout << "The unordered map elements stored " << 12
"at the index " << index << ": \n";13
cout << "Key Value\n";14
15
// Each element of the map is a pair on 16
// its own17
for (auto pr : myMap) 18
{19
// Each element of the map is a pair 20
// on its own21
cout << pr.first << " " << 22
pr.second << '\n';23
}24
cout << '\n';25
}26
27
// Function to iterate over all the array28
void print(unordered_map<int, 29
bool>* myContainer, int n)30
{31
// Iterating over myContainer elements32
// Each element is a map on its own33
for (int i = 0; i < n; i++) 34
{35
print(myContainer[i], i);36
}37
}38
39
// Driver code40
int main()41
{42
// Declaring an array of unordered maps43
// In unordered map Key is of type int44
// Value is of type bool45
unordered_map<int, bool> myContainer[3];46
47
// Mapping values to the unordered map 48
// stored at the index 049
myContainer[0][10] = true;50
myContainer[0][15] = false;51
myContainer[0][20] = true;52
myContainer[0][25] = false;53
54
// Mapping values to the unordered map 55
// stored at the index 156
myContainer[1][30] = true;57
myContainer[1][35] = false;58
myContainer[1][40] = true;59
myContainer[1][45] = false;60
61
// Mapping values to the unordered map 62
// stored at the index 263
myContainer[2][50] = true;64
myContainer[2][55] = false;65
myContainer[2][60] = true;66
myContainer[2][65] = false;67
68
// Calling print function to iterate69
// over myContainer elements70
print(myContainer, 3);71
72
return 0;73
}Output
The unordered map elements stored at the index 0: Key Value 25 0 20 1 10 1 15 0 The unordered map elements stored at the index 1: Key Value 45 0 40 1 30 1 35 0 The unordered map elements stored at the index 2: Key Value 65 0 60 1 50 1 55 0
Example 2: Below is the C++ program to implement the approach:
// C++ program to demonstrate the
// working of array of maps in C++
#include <bits/stdc++.h>
using namespace std;
// Function to print unordered map elements
// specified at the index, "index"
void print(unordered_map<string,
bool>& myMap, int index)
{
cout << "The unordered map elements stored " <<
"at the index " << index << ": \n";
cout << "Key Value\n";
// Each element of the unordered map is
// a pair on its own
for (auto pr : myMap)
{
cout << pr.first << " " <<
pr.second << '\n';
}
cout << '\n';
}
// Function to iterate over the unordered
// map corresponding to an index
void print(unordered_map<string,
bool>* myContainer, int n)
{
for (int i = 0; i < n; i++)
{
print(myContainer[i], i);
}
}
// Driver code
int main()
{
// Declaring an array of unordered maps
// In unordered map Key is of type string
// Value is of type bool
unordered_map<string, bool> myContainer[3];
// Mapping values to the unordered map
// stored at the index 0
myContainer[0]["Code"] = true;
myContainer[0]["HTML"] = false;
myContainer[0]["Java"] = true;
myContainer[0]["Solo"] = false;
// Mapping values to the unordered map
// stored at the index 1
myContainer[1]["PHP"] = true;
myContainer[1]["CSS"] = false;
myContainer[1]["C++"] = true;
myContainer[1]["Lab"] = false;
// Mapping values to the unordered map
// stored at the index 2
myContainer[2]["Swift"] = true;
myContainer[2]["Cobol"] = false;
myContainer[2]["Fizzy"] = true;
myContainer[2]["Pizza"] = false;
// Calling print function to print
// myContainer elements
print(myContainer, 3);
return 0;
}
70
1
// C++ program to demonstrate the2
// working of array of maps in C++3
4
using namespace std;5
6
// Function to print unordered map elements 7
// specified at the index, "index"8
void print(unordered_map<string, 9
bool>& myMap, int index)10
{11
cout << "The unordered map elements stored " << 12
"at the index " << index << ": \n";13
cout << "Key Value\n";14
15
// Each element of the unordered map is 16
// a pair on its own17
for (auto pr : myMap) 18
{19
cout << pr.first << " " << 20
pr.second << '\n';21
}22
cout << '\n';23
}24
25
// Function to iterate over the unordered 26
// map corresponding to an index27
void print(unordered_map<string, 28
bool>* myContainer, int n)29
{30
for (int i = 0; i < n; i++) 31
{32
print(myContainer[i], i);33
}34
}35
36
// Driver code37
int main()38
{39
// Declaring an array of unordered maps40
// In unordered map Key is of type string41
// Value is of type bool42
unordered_map<string, bool> myContainer[3];43
44
// Mapping values to the unordered map 45
// stored at the index 046
myContainer[0]["Code"] = true;47
myContainer[0]["HTML"] = false;48
myContainer[0]["Java"] = true;49
myContainer[0]["Solo"] = false;50
51
// Mapping values to the unordered map 52
// stored at the index 153
myContainer[1]["PHP"] = true;54
myContainer[1]["CSS"] = false;55
myContainer[1]["C++"] = true;56
myContainer[1]["Lab"] = false;57
58
// Mapping values to the unordered map 59
// stored at the index 260
myContainer[2]["Swift"] = true;61
myContainer[2]["Cobol"] = false;62
myContainer[2]["Fizzy"] = true;63
myContainer[2]["Pizza"] = false;64
65
// Calling print function to print 66
// myContainer elements67
print(myContainer, 3);68
69
return 0;70
}Output
The unordered map elements stored at the index 0: Key Value Solo 0 Java 1 Code 1 HTML 0 The unordered map elements stored at the index 1: Key Value Lab 0 C++ 1 PHP 1 CSS 0 The unordered map elements stored at the index 2: Key Value Fizzy 1 Pizza 0 Swift 1 Cobol 0
