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?
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::pairs. 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.
operator[] has to return a specific type but first and second can have different types. On the other hand, std::tuple has a special helper function std::get for accessing its elements by index.
key and val or even k and v which is far more logical and easy to deduce rather than something as esoteric as first and second?
The type of the elements of an std::map (which is also the type of an expression obtained by dereferencing an iterator of that map) whose key is K and value is V is std::pair<const K, V> - the key is const to prevent you from interfering with the internal sorting of map values.
std::pair<> has two members named first and second (see here), with quite an intuitive meaning. Thus, given an iterator i to a certain map, the expression:
i->first
Which is equivalent to:
(*i).first
Refers to the first (const) element of the pair object pointed to by the iterator - i.e. it refers to a key in the map. Instead, the expression:
i->second
Which is equivalent to:
(*i).second
Refers to the second element of the pair - i.e. to the corresponding value in the map.
#include<bits/stdc++.h>
#define long long int
using namespace std;
int32_t main(){
map<int,int> m;
m.insert({1,2});
m.insert({2,4});
for(auto i:m){
cout<<"key - "<<i.first<<" "<<" Value - "<<i.second<<endl;
}
}
std::mapstores a key and a value.map::iterator.secondrefers to the value.