Map & Multimap

In the world of programming, managing data efficiently is crucial. C++ Standard Template Library (STL) provides several containers that help in organizing and manipulating data effectively. Two such powerful containers are std::map and std::multimap. These containers store elements as key-value pairs, where each key is unique for std::map, but can be duplicated in std::multimap.

Introduction

Maps are associative containers that store elements formed by a combination of a key value and a mapped value, following a specific order. The key serves as an index to access the corresponding mapped value. Maps automatically sort their elements based on the keys.

Multimaps, on the other hand, allow duplicate keys but maintain the same ordering criteria for the elements. This makes multimaps useful when you need to store multiple entries with the same key.

Understanding and effectively using std::map and std::multimap can significantly enhance your ability to manage data in C++ applications.

Core Content

Key-Value Pairs

Both std::map and std::multimap store elements as pairs of keys and values. The key is used for sorting and accessing the elements, while the value holds the actual data associated with that key.

Example: Basic Map Usage

1#include <iostream>
2#include <map>
3 
4int main() {
5  std::map<int, std::string> myMap;
6  myMap[1] = "One";
7  myMap[2] = "Two";
8  myMap[3] = "Three";
9 
10  for (const auto& pair : myMap) {
11      std::cout << pair.first << ": " << pair.second << std::endl;
12  }
13 
14  return 0;
15}

Retrieval

To retrieve an element from a map, you can use the find() method or directly access it using the key.

Example: Using find()

1#include <iostream>
2#include <map>
3 
4int main() {
5  std::map<int, std::string> myMap;
6  myMap[1] = "One";
7  myMap[2] = "Two";
8  myMap[3] = "Three";
9 
10  auto search = myMap.find(2);
11  if (search != myMap.end()) {
12      std::cout << "Found: " << search->first << ": " << search->second << std::endl;
13  } else {
14      std::cout << "Not found" << std::endl;
15  }
16 
17  return 0;
18}

Iterating

Maps provide iterators to traverse the elements in a sorted order.

Example: Iterating Over a Map

1#include <iostream>
2#include <map>
3 
4int main() {
5  std::map<int, std::string> myMap;
6  myMap[1] = "One";
7  myMap[2] = "Two";
8  myMap[3] = "Three";
9 
10  for (auto it = myMap.begin(); it != myMap.end(); ++it) {
11      std::cout << it->first << ": " << it->second << std::endl;
12  }
13 
14  return 0;
15}

Operator[]

The operator[] can be used to access and modify the value associated with a key. If the key does not exist, it is inserted with a default-constructed value.

Example: Using operator[]

1#include <iostream>
2#include <map>
3 
4int main() {
5  std::map<int, std::string> myMap;
6  myMap[1] = "One";
7  myMap[2] = "Two";
8  myMap[3] = "Three";
9 
10  std::cout << "Element at key 2: " << myMap[2] << std::endl;
11 
12  // Accessing a non-existent key
13  std::cout << "Element at key 4 (default constructed): " << myMap[4] << std::endl;
14  std::cout << "Size after accessing key 4: " << myMap.size() << std::endl;
15 
16  return 0;
17}

Summary

What's Next?

In the next section, we will explore std::set and std::multiset, which are containers that store unique elements in sorted order. These containers are useful when you need to manage collections of items without duplicates and require efficient search operations.

Stay tuned for more insights into C++ STL!