Updating Values in a std::multimap in C++ - Codzify Topics

Article by: Manish Methani

Last Updated: September 7, 2021 at 2:04pm IST
7 min 45 sec

Table of Contents:

A std::multimap in C++ is an associative container that allows multiple values to be associated with the same key. However, there may be scenarios where you need to update the values associated with a particular key. In this guide, we'll explore how to update values in a std::multimap with step-by-step examples.

Step 1: Include Necessary Headers

Before we start, make sure to include the necessary C++ Standard Library headers:

#include <iostream>
#include <map>

Step 2: Create a std::multimap

Let's create a std::multimap with some initial key-value pairs:

std::multimap multiMap;

multiMap.insert(std::make_pair(1, "Apple"));
multiMap.insert(std::make_pair(2, "Banana"));
multiMap.insert(std::make_pair(2, "Cherry"));
multiMap.insert(std::make_pair(3, "Date"));

Step 3: Updating Values

To update values in the std::multimap, you need to iterate through the elements and use the equal_range function to locate the range of elements associated with a specific key. Then, you can update the values within that range. Here's how to do it:

int keyToUpdate = 2;  // The key for which we want to update values
std::string newValue = "Blueberry";  // The new value to update

auto range = multiMap.equal_range(keyToUpdate);

for (auto it = range.first; it != range.second; ++it) {
    it->second = newValue;
}

In this example, we're updating all values associated with the key 2 to "Blueberry."

Step 4: Display the Updated std::multimap

Now, let's iterate through the std::multimap and print the updated key-value pairs:

std::cout << "Updated std::multimap:" << std::endl;
for (const auto& pair : multiMap) {
    std::cout << "Key: " << pair.first << ", Value: " << pair.second << std::endl;
}

Step 5: Compile and Run

Compile your C++ code and run the program to see the updated std::multimap in action.

Full Example Code

#include <iostream>
#include <map>
#include <string>

int main() {
    // Create a multimap with string keys and int values
    std::multimap scores;

    // Insert some key-value pairs into the multimap
    scores.insert(std::make_pair("Alice", 95));
    scores.insert(std::make_pair("Bob", 85));
    scores.insert(std::make_pair("Alice", 92)); // Duplicate key

    // Display the original multimap
    std::cout << "Original Multimap:" << std::endl;
    for (const auto& pair : scores) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    // Update the values associated with a specific key
    std::string keyToUpdate = "Alice";
    int newValue = 98;

    // Use equal_range to find the range of elements with the key to update
    auto range = scores.equal_range(keyToUpdate);

    // Iterate through the range and update the values
    for (auto it = range.first; it != range.second; ++it) {
        it->second = newValue;
    }

    // Display the updated multimap
    std::cout << "
Updated Multimap:" << std::endl;
    for (const auto& pair : scores) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    return 0;
}

Output:

Original Multimap:
Alice: 95
Alice: 92
Bob: 85

Updated Multimap:
Alice: 98
Alice: 98
Bob: 85

Here's a step-by-step explanation of the code:

1. Include necessary libraries:

   • iostream: for input and output operations.
   • map: for using the std::multimap container.
   • string: for working with string data.

2. Create a std::multimap named scores that associates string keys with integer values.

3. Insert key-value pairs into the scores multimap using the insert method. In this example, "Alice" has two associated scores: 95 and 92. The key "Bob" has a score of 85.

4. Display the original multimap:

   • Loop through the scores multimap and print each key-value pair.

5. Update the values associated with a specific key, "Alice," to a new value, 98.

6. Use equal_range to find the range of elements with the key "Alice." This returns a pair of iterators (range.first and range.second) that define the range.

7. Iterate through the range and update the values to the new value (98) for the key "Alice."

8. Display the updated multimap:

   • Loop through the scores multimap again and print the modified key-value pairs.

In summary, this code showcases how to work with std::multimap in C++, insert data, find a specific range of elements with the same key using equal_range, and update their values. The final output demonstrates the changes made to the multimap.

Conclusion

Updating values in a std::multimap in C++ involves finding the range of elements associated with a specific key and modifying their values. This allows you to maintain the integrity of your data while accommodating changes in your program's requirements.

In this guide, we've shown you the step-by-step process for updating values in a std::multimap with a practical example. You can apply this knowledge to handle and manipulate data efficiently in C++ programs.

Now, you're equipped to work with std::multimap and efficiently update values associated with specific keys as needed. Happy coding!