How to implement map in C++

Part of the C++ STL is maps (Standard Template Library). Maps are associative containers that hold sorted key-value pairs, where each key is distinct and may only be added or removed. Key values can have their related values modified.

Several fundamental Map operations include

begin(): The first element of the map container is indicated by an iterator returned by the begin() function. The begin() function returns an iterator that moves back and forth between the container's first and second elements.

end(): The end() function returns an iterator pointing past the map container's final element. It cannot be de-referenced since it does not refer to a legitimate element; instead, the end() function produces a bidirectional iterator.

size(): To determine how many elements are present in the map, use the size() function.

max_size(): The maximum number of elements the map can hold is returned.

empty(): The map container's empty status is checked using the empty() function.s

pair insert(key-value, map value): The insert() built-in method in the C++ STL is used to add elements to the map container that match a specific key.

erase(iterator position): When an element needs to be removed from a container, the built-in C++ STL method erase() is utilised. Keys, items at any certain place, or a specific range can all be erased using this method.

clear(): The map container's size becomes 0 when all the items are removed using the clear() function.

Let us try to implement this map using a C++ program.

Implementation of the map

// Using the CPP Program, Map will show how it has been implemented.

#include <iostream>
#include <iterator>
#include <map>
using namespace std;
int main()
{
	// empty map container
	map<int, int> cmptn1;
	// Incorporate elements in a random order.
	cmptn1.insert(pair<int, int>(6, 50));
	cmptn1.insert(pair<int, int>(5, 60));
	cmptn1.insert(pair<int, int>(4, 30));
	cmptn1.insert(pair<int, int>(3, 20));
	cmptn1.insert(pair<int, int>(2, 40));
	cmptn1.insert(pair<int, int>(1, 40));
	cmptn1[7]=10;	// A different approach of adding values to maps
	// cmptn1 map printing
	map<int, int>::iterator itr;
	cout << "\n The cmptn1 map is: \n";
	cout << "\tKEY\tELEMENT\n";
	for (itr = cmptn1.begin(); itr != cmptn1.end(); ++itr) {
		cout << '\t' << itr->first << '\t' << itr->second
			<< '\n';
	}
	cout << endl;
	// Going to transfer the components from cmptn1 to cmptn2.
	map<int, int> cmptn2(cmptn1.begin(), cmptn1.end());
	// Print every element of the map gquiz2.
	cout << "\nThe cmptn2 map after"
		<< " assign from the cmptn1 is : \n";
	cout << "\tKEY\tELEMENT\n";
	for (itr = cmptn2.begin(); itr != cmptn2.end(); ++itr) {
		cout << '\t' << itr->first << '\t' << itr->second
			<< '\n';
	}
	cout << endl;
	// eliminate every element up to
	// element in cmptn2 with key=3
	cout << "\ncmptn2 after the removal of"
			" the elements less than the key=3 : \n";
	cout << "\tKEY\tELEMENT\n";
	cmptn2.erase(cmptn2.begin(), cmptn2.find(3));
	for (itr = cmptn2.begin(); itr != cmptn2.end(); ++itr) {
		cout << '\t' << itr->first << '\t' << itr->second
			<< '\n';
	}
	// with key = 4, eliminate all entries
	int num;
	num = cmptn2.erase(4);
	cout << "\ncmptn2.erase(4) : ";
	cout << num << " removed \n";
	cout << "\tKEY\tELEMENT\n";
	for (itr = cmptn2.begin(); itr != cmptn2.end(); ++itr) {
		cout << '\t' << itr->first << '\t' << itr->second
			<< '\n';
	}
	cout << endl;


	// the lower and higher bounds for the map cmptn1 key = 5
	cout << "cmptn1.lower_bound(5) : "
		<< "\tKEY = ";
	cout << cmptn1.lower_bound(5)->first << '\t';
	cout << "\tELEMENT = " << cmptn1.lower_bound(5)->second
		<< endl;
	cout << "cmptn1.upper_bound(5) : "
		<< "\tKEY = ";
	cout << cmptn1.upper_bound(5)->first << '\t';
	cout << "\tELEMENT = " << cmptn1.upper_bound(5)->second
		<< endl;
	return 0;
}

Output

Other lists of map functions used for the implementation of map

map equal_range(): A pair of iterators are returned by the map::equal range() built-in function in the C++ STL. The pair designates the boundaries of a set that contains all the elements in the container with keys equal to k. The first iterator in the pair returned points to the element because the map container only includes unique keys, and the second iterator in the pair points to the key that follows after key K because the map container only contains unique keys. The range returned is of length 1, with both iterators pointing to an element that has a key designating the size of the map and elements as 0, and if there are no matches with key K and key K is greater than the largest key, the range returned is of length 1.

map rend(): provides a reverse iterator that leads to the hypothetical element that comes before the map's initial key-value pair.

map find(): If an iterator for the element in the map with the key-value pair "g" is found, it returns it; otherwise, it returns an iterator to the end.

map operator=: assigns a container's contents to another container, replacing the one it now has.