What does the following code print to the console?
map<int,int> m; m = m.size(); printf("%d", m);
- The behavior of the code is not defined since it is not defined which statement
m.size()is being executed first by the compiler. So it could print
1as well as
- It prints
0because the right hand side of the assignment operator is executed first.
operatorhas the highest priority of the complete statement
m = m.size(). Because of this the following sequence of events occurs:
mcreates a new element in the map
m.size()gets called which is now
mgets assigned the previously returned (by m.size())
The real answer?, which is unknown to me^^
Thx in advance for your answers...
I believe it's unspecified whether 0 or 1 is stored in
m, but it's not undefined behavior.
The LHS and the RHS can occur in either order, but they're both function calls, so they both have a sequence point at the start and end. There's no danger of the two of them, collectively, accessing the same object without an intervening sequence point.
The assignment is actual int assignment, not a function call with associated sequence points, since
T&. That's briefly worrying, but it's not modifying an object that is accessed anywhere else in this statement, so that's safe too. It's accessed within
operator, of course, where it is initialized, but that occurs before the sequence point on return from
operator, so that's OK. If it wasn't,
m = 0; would be undefined too!
However, the order of evaluation of the operands of
operator= is not specified by the standard, so the actual result of the call to
size() might be 0 or 1 depending which order occurs.
The following would be undefined behavior, though. It doesn't make function calls and so there's nothing to prevent
size being accessed (on the RHS) and modified (on the LHS) without an intervening sequence point:
int values; int size = 0; (++size, values = 0) = size; /* fake m */ /* fake m.size() */