«

Hello,

I find myself writing a lot of code like the one below where I find
something out of a map and then use a reference to second to
interrogate the mapped object:

#include <iostream>
#include <map>

class Expensive { /* lots of stuff here... */ };

int main()
{
std::map<int,Expensive> m;
m.insert(std::make_pair(1,Expensive(3)));

// and then later
std::map<int,Expensive>::const_iterator it = m.find(1);
const Expensive& expensive = (*it).second;
// use expensive here - is this safe?
}

Is this practice safe? I've just determined on VC9 compiler that the
find doesn't do any copies, but wondered if the standard mandates
this?

Thanks,

Pete

PeteUK wrote:

> Hello,
>
> I find myself writing a lot of code like the one below where I find
> something out of a map and then use a reference to second to
> interrogate the mapped object:
>
> #include <iostream>
> #include <map>
>
> class Expensive { /* lots of stuff here... */ };
>
> int main()
> {
> std::map<int,Expensive> m;
> m.insert(std::make_pair(1,Expensive(3)));
>
> // and then later
> std::map<int,Expensive>::const_iterator it = m.find(1);
> const Expensive& expensive = (*it).second;
> // use expensive here - is this safe?
> }
>
> Is this practice safe?

Operations on map don't invalidate references unless they erase the element
referred to. The same guarantee applies to iterators and pointers into the
map.

> I've just determined on VC9 compiler that the
> find doesn't do any copies, but wondered if the standard mandates
> this?

Yes: [23.1/11] and [23.1.2/8] and the absence of invalidate-clauses in the
section about std::map.


Best

Kai-Uwe Bux

On 2 Sep, 11:13, Kai-Uwe Bux <jkherci...@gmx.net> wrote:
> PeteUK wrote:
> > Hello,
>
> > I find myself writing a lot of code like the one below where I find
> > something out of a map and then use a reference to second to
> > interrogate the mapped object:
>
> > #include <iostream>
> > #include <map>
>
> > class Expensive { /* lots of stuff here... */ };
>
> > int main()
> > {
> > std::map<int,Expensive> m;
> > m.insert(std::make_pair(1,Expensive(3)));
>
> > * * * * // and then later
> > std::map<int,Expensive>::const_iterator it = m.find(1);
> > const Expensive& expensive = (*it).second;
> > // use expensive here - is this safe?
> > }
>
> > Is this practice safe?
>
> Operations on map don't invalidate references unless they erase the element
> referred to. The same guarantee applies to iterators and pointers into the
> map.
>
> > I've just determined on VC9 compiler that the
> > find doesn't do any copies, but wondered if the standard mandates
> > this?
>
> Yes: [23.1/11] and [23.1.2/8] and the absence of invalidate-clauses in the
> section about std::map.
>
> Best
>
> Kai-Uwe Bux

Kai-Uwe Bux,

I appreciate your clarification of this.

Pete

On 2 sep, 12:03, PeteUK <newbar...@gmail.com> wrote:
> * * * * std::map<int,Expensive> m;
> * * * * m.insert(std::make_pair(1,Expensive(3)));

As a side note, you may want to avoid this syntax, as it may cause
more copies than needed. Replacing std::make_pair with
std::map<...>::value_type saves one copy in libstdc++ (or 2 in C++0x
mode, because make_pair becomes horrible). std::make_pair(1,3) works
too.

(Yes, I know that most of those copies are actually moves in C++0x)