What does iterator->second mean?
c++, iterator, stl
Solution
I'm sure you know that a `std::vector<X>` stores a whole bunch of `X` objects, right? But if you have a `std::map<X, Y>`, what it actually stores is a whole bunch of `std::pair<const X, Y>`s. That's exactly what a map is - it pairs together the keys and the associated values.
When you iterate over a `std::map`, you're iterating over all of these `std::pair`s. When you dereference one of these iterators, you get a `std::pair` containing the key and its associated value.
std::map<std::string, int> m = /* fill it */;
auto it = m.begin();
Here, if you now do `*it`, you will get the the `std::pair` for the first element in the map.
Now the type `std::pair` gives you access to its elements through two members: `first` and `second`. So if you have a `std::pair<X, Y>` called `p`, `p.first` is an `X` object and `p.second` is a `Y` object.
So now you know that dereferencing a `std::map` iterator gives you a `std::pair`, you can then access its elements with `first` and `second`. For example, `(*it).first` will give you the key and `(*it).second` will give you the value. These are equivalent to `it->first` and `it->second`.
Problem
In C++, what is the type of a `std::map<>::iterator`? We know that an object `it` of type `std::map<A,B>::iterator` has an overloaded `operator ->` which returns a `std::pair<A,B>*`, and that the `std::pair<>` has a `first` and `second` member. But, what do these two members correspond to, and why do we have to access the value stored in the map as `it->second`?