Re: Overhead of subscript operator for STL maps
On Oct 16, 8:32 am, Ian Collins <ian-n...@hotmail.com> wrote:
C++Liliput wrote:
I have a custom String class that contains an embedded char* member.
The copy constructor, assignment operator etc. are all correctly
defined. I need to create a map of my string (say a class called
MyString) and an integer i.e. std::map<MyString, int>. Whenever I
insert the elements in the map using the subscript [] operator, I
noticed that the copy constructor for MyString is invoked more number
of times than if I do it using the insert() operation. For e.g. for 3
strings, when I insert them into the map using subscript operator, the
copy constructor is invoked 6 times whereas in the case of insert(),
the copy constructor is only invoked 3 times. Can someone please
explain me the reason why this is so?
The subscript operator creates a default constructed object then copies
the passed object to it. So you will see a copy for the operator call
and one for the copy in.
The subscript operator creates a default constructed object only for
the *value*, but not for the key of std::map<>.
In fact, std::map<Key, Value> internally stores std::pair<Key, Value>.
When std::map<>::operator[] is called and there has been no such key,
it creates a temporary std::pair<Key, Value> (where Value is default
initialised) and then copies that temporary std::pair<Key, Value> into
the newly created (tree) node, thus 2 calls to the copy constructor of
Key. std::map::insert(), on the other hand, accepts std::pair<Key,
Value>, which is used to initialise the node's copy of it, thus 1 copy
constructor call.
--
Max