An array is a collection of items stored at contiguous memory locations. The idea is to store multiple items of the same type together. This makes it easier to calculate the position of each element by simply adding an offset to a base value, i.e., the memory location of the first element of the array (generally denoted by the name of the array).
The diagrammatic representation of the Array is given below:
Program 1:
Below is an illustration of a 1D array:
- C++
// C++ program to illustrate 1D array
#include <bits/stdc++.h>
**using** **namespace** std;
// Driver Code
**int** main()
{
// Given array
**int** arr[] = { 6, 10, 5, 0 };
// Print the array elements
**for** (``**int** i = 0; i < 4; i++) {
cout << arr[i] << " "``;
}
**return** 0;
}
Output:
6 10 5 0
Program 2:
Below is an illustration of a 2D array:
// C++ program to illustrate 1D array
#include <bits/stdc++.h>
**using** **namespace** std;
// Driver Code
**int** main()
{
// A 2D array with 3 rows and
// 2 columns
**int** x[3][2] = { { 0, 1 }, { 2, 3 }, { 4, 5 } };
// Print each array element value
// Traverse row
**for** (``**int** i = 0; i < 3; i++) {
// Traverse column
**for** (``**int** j = 0; j < 2; j++) {
// Print element
cout << "Element at x[" << i
<< "][" << j
<< "]: "``;
cout << x[i][j] << endl;
}
}
**return** 0;
}
Output:
Element at x[0][0]: 0
Element at x[0][1]: 1
Element at x[1][0]: 2
Element at x[1][1]: 3
Element at x[2][0]: 4
Element at x[2][1]: 5
Map:
A map is an associative container that stores elements in a mapped fashion. Each element has a key value and a mapped value. No two mapped values can have equal key values.
The diagrammatic representation of Map is given below:
Program 1:
Below is an illustration of a map:
// C++ program to illustrate Map
#include <bits/stdc++.h>
**using** **namespace** std;
// Driver Code
**int** main()
{
// Empty map container
map<``**int**``, **int**``> gquiz1;
// Insert elements in Map
gquiz1.insert(pair<``**int**``, **int**``>(1, 40));
gquiz1.insert(pair<``**int**``, **int**``>(2, 30));
gquiz1.insert(pair<``**int**``, **int**``>(3, 60));
// Iterator to iterate Map
map<``**int**``, **int**``>::iterator itr;
cout << "\nThe map gquiz1 is : \n"``;
cout << "\tKEY\tELEMENT\n"``;
// Print map gquiz1
**for** (itr = gquiz1.begin();
itr != gquiz1.end(); ++itr) {
cout << '\t' << itr->first
<< '\t' << itr->second
<< '\n'``;
}
**return** 0;
}
Output:
The map gquiz1 is :
KEY ELEMENT
1 40
2 30
3 60
Program 2:
Below is an illustration of an unordered map:
// C++ program to illustrate Map
#include <bits/stdc++.h>
**using** **namespace** std;
// Driver Code
**int** main()
{
// Declaring umap of <string, int>
// type key will be of string and
// mapped value will be of doubl
unordered_map<string, **int**``> umap;
// Insert values by using [] operator
umap[``"GeeksforGeeks"``] = 10;
umap[``"Practice"``] = 20;
umap[``"Contribute"``] = 30;
// Traversing an unordered map
// and print the key-value pairs
**for** (``**auto** x : umap)
cout << x.first << " "
<< x.second << endl;
**return** 0;
}
Output:
Contribute 30
GeeksforGeeks 10
Practice 20
Program 3:
Below is an illustration of a multimap:
// C++ program to illustrate Multimap
#include <bits/stdc++.h>
**using** **namespace** std;
// Driver Code
**int** main()
{
// Empty multimap container
multimap<``**int**``, **int**``> gquiz1;
// Insert elements
gquiz1.insert(pair<``**int**``, **int**``>(1, 40));
gquiz1.insert(pair<``**int**``, **int**``>(2, 30));
// Iterator
multimap<``**int**``, **int**``>::iterator itr;
cout << "\nThe multimap gquiz1 is : \n"``;
cout << "\tKEY\tELEMENT\n"``;
// Print multimap gquiz1
**for** (itr = gquiz1.begin();
itr != gquiz1.end(); ++itr) {
cout << '\t' << itr->first
<< '\t' << itr->second
<< '\n'``;
}
**return** 0;
}
Output:
The multimap gquiz1 is :
KEY ELEMENT
1 40
2 30
Program 4:
Below is an illustration of an unordered multimap:
// C++ program to illustrate
// unordered multimap
#include <bits/stdc++.h>
**using** **namespace** std;
// Driver Code
**int** main()
{
// Empty initialization
unordered_multimap<string, **int**``> umm1;
// Initialization by intializer list
unordered_multimap<string, **int**``> umm2(
{ { "apple"``, 1 },
{ "ball"``, 2 },
{ "apple"``, 10 },
{ "cat"``, 7 },
{ "dog"``, 9 },
{ "cat"``, 6 },
{ "apple"``, 1 } });
// Traversing an unordered_multimap
// and print the elements stored
**for** (``**auto** x : umm2) {
cout << x.first << " "
<< x.second << endl;
}
**return** 0;
}
Output:
dog 9
cat 6
cat 7
ball 2
apple 1
apple 10
apple 1
#arrays #data structures #difference between #cpp-array #cpp-map #cpp-multimap #cpp-unordered_map #cpp-unordered_multimap
