Subtle And Quirky, But Still Lovable
I’m a long time C++ programmer who’s going to expose something embarrassing about myself. As a starting point, please take a look at the code below:
The first std::cout statement prints out the letter A and the second one prints out B. Here comes the embarrassing part… I erroneously thought that both the map::insert() and map::operator functions expressed the same semantics:
If the map object already contains an entry for the key being supplied by the user in the function call, the value supplied by the user will not be copied into the map.
Applied to the specific example above, before running the program I thought both std::cout statements would print the letter A.
Of course, as any experienced C++ programmer knows (or, in my case, should know), this behavior is only true for the map::insert() function. The map::operator function combined with the assignment operator will always copy the value into the map – regardless of whether or not an entry for the key is already present in the map. It makes sense that the two functions behave differently because sometimes you want an unconditional copy and sometimes you don’t.
The reason I wrote this post is because I very recently got burned by my incorrect assumption. To make a long story short, there was a bug in my large program that eventually was traced, with the help of the simple code example above, to the bad line of code that I wrote using map::operator. A simple change to map::insert() fixed the bug. It was critical to the application that an existing value in the map not be overwritten.
One of the dings against C++ is that it contains a lot of subtle, quirky semantics that are difficult for mere humans to remember. Despite agreeing with this, I still love the ole language that keeps on chugging forward like the little train that could (direct mapping to the hardware and zero overhead abstraction), despite the chagrin of many in the software industry: