 <p>I am not quite sure what your worry is (and maybe you should clarify your question if that answer isn't sufficient), but <code>m[10] += 1;</code> doesn't get translated to <code>m[10] = m[10] + 1;</code> because <code>m</code> is user defined class type and overloaded operators don't get translated by the compiler, ever. For <code>a</code> and <code>b</code> objects with a user defined class type:</p> <ul> <li><code>a+=b</code> doesn't mean <code>a = a + b</code> (unless you make it so) </li> <li><code>a!=b</code> doesn't mean <code>!(a==b)</code> (unless you make it so)</li> </ul> <p>Also, function calls are never duplicated.</p> <p>So <code>m[10] += 1;</code> means call overloaded <code>operator[]</code> once; return type is a reference, so the expression is a lvalue; then apply the builtin operator <code>+=</code> to the lvalue.</p> <p>There is no order of evaluation issue. There isn't even multiple possible orders of evaluation!</p> <p>Also, you need to remember that the <code>std::map&lt;&gt;::operator[]</code> doesn't behave like <code>std::vector&lt;&gt;::operator[]</code> (or <code>std::deque</code>'s), because the <code>map</code> is a completely different abstraction: <code>vector</code> and <code>deque</code> are implementations of the Sequence concept (where position matters), but <code>map</code> is an associative container (where "key" matters, not position): </p> <ul> <li><code>std::vector&lt;&gt;::operator[]</code> takes a numerical index, and doesn't make sense if such index doesn't refer to an element of the vector.</li> <li><code>std::map&lt;&gt;::operator[]</code> takes a key (which can be any type satisfying basic constraints) and <strong>will create a (key,value) pair if none exists</strong>.</li> </ul> <p>Note that for this reason, <strong><code>std::map&lt;&gt;::operator[]</code> is inherently a modifying operation and thus non const</strong>, while <code>std::vector&lt;&gt;::operator[]</code> isn't inherently modifying but can allow modification via the returned reference, and is thus "transitively" const: <code>v[i]</code> will be a modifiable lvalue if <code>v</code> is a non-const vector and a const lvalue if <code>v</code> is a const vector.</p> <p>So no worry, the code has perfectly well defined behavior.</p>