Does std::map::iterator return a copy of value or a value itself?

I'm trying to create a map inside a map:

typedef map<float,mytype> inner_map;
typedef map<float,inner_map> outer_map;

Will I be able to put something inside inner map, or does iterator::second returns a copy?

stl_pair.h suggests the latter:

74: _T开发者_StackOverflow2 second;          ///< @c second is a copy of the second object

but my test program run fine with the code like this:

it = my_map.lower_bound(3.1415);
(*it).second.insert(inner_map::value_type(2.71828,"Hello world!");

So where is the truth? Is this a copy or not?

---

I want to add a follow up answer to this question for people using C++11 iterators...

The following code:

std::map<std::string, std::string> m({{"a","b"},{"c","d"}});
for (auto i : m)
{
    std::cout << i.first << ": " << i.second << std::endl;
}

does copy the key and value since "auto" is a value by default, not a const reference (at least that's how it behaves clang 3.1).

Additionally, the code:

std::map<std::string, std::string> m({{"a","b"},{"c","d"}});
for (const std::pair<std::string,std:string>& i : m)
{
    std::cout << i.first << ": " << i.second << std::endl;
}

also copies the key and value since the correct code should be:

std::map<std::string, std::string> m({{"a","b"},{"c","d"}});
for (const auto& i : m)
{
    std::cout << i.first << ": " << i.second << std::endl;
}

or

std::map<std::string, std::string> m({{"a","b"},{"c","d"}});
for (const std::pair<const std::string,std:string>& i : m)
{
    std::cout << i.first << ": " << i.second << std::endl;
}

---

The comment in stl_pair.h is misleading in this specific case.

There will be no copy, since the map::iterator actually refers to the original data inside the map (the value_type, which itself is a pair), it’s not a copy. Thus iterator::second also refers to the original data.

---

The value_type a map is a pair and therefore it has members first and second. As with all iterators, a map iterator is a pseudo-pointer, i.e. it points to data within a collection and not copies of that data.

It is almost certain internally to contain pointers rather than references due to the fact that iterators can be re-assigned (that is what you use them for) and you cannot reassign references to refer to other objects.

Even if you have a const_iterator and the type underneath is POD, it must have a pointer to it, in case someone does this:

map< int, int > m;
m.insert( make_pair( 1, 2 );
map<int,int>::const_iterator citer = m.begin();
map<int,int>::iterator iter = m.begin();
iter->second = 3;
std::cout << citer->second << '\n'; // should always print 3

The behaviour should be defined and should output 3, which would not happen if the const_iterator decided to "optimise" after all it's const and only int...

---

Iterators, when dereferenced, give you a reference.