std::map operator [] -- undefined behaviour?

Question

I've just stuck myself with the following question: should this cause undefined behaviour or not and why?

std::map<int, int> m;
m[10] += 1;

It compiles and runs perfectly but it doesn't prove anything. It resembles a common UB example i = ++i + i++; since operator[] does have side effects but on the other hand assuming any order of evaluation (left to right and right to left) brings me to the same final state of the map

P.S. possibly related: http://en.cppreference.com/w/cpp/language/eval_order

edit

Sorry guys I should have written

 m[10] = m[10] + 1;

Answer 1

There is nothing undefined about this. The operator[] returns an lvalue reference to the map entry (which it creates if necessary). You are then merely incrementing this lvalue expression, i.e. the underlying entry.

The rules for evaluation order state that for a modifying assign operation, the side effect is sequenced strictly after the evaluation of both the left (i.e. lvalue reference to the map entry) and right (i.e. the constant 1) operands. There is no ambiguity at all in this example.

UPDATE: In your updated example nothing changes. Again the side effect of modifying m[10] is sequenced strictly after the other operations (i.e. evaluating as an lvalue on the right, evaluating it on the right, and performing the addition).

The relevant sequencing rule, from cppreference:

8) The side effect (modification of the left argument) of the built-in assignment operator and of all built-in compound assignment operators is sequenced after the value computation (but not the side effects) of both left and right arguments, and is sequenced before the value computation of the assignment expression (that is, before returning the reference to the modified object)