Associativity of == operator in c++

Question

I have this snippet of code in c++:

std::vector<int> v1;
std::vector<int> v2;
...
if (v1.insert(v1.end(), v2.begin(), v2.end()) == v1.end())
{
    return 0;
}

Which expression will be evaluated first? When debugging, the right side of "==" operator is evaluated first, is this the right behaviour?

Does [this](http://en.cppreference.com/w/cpp/language/operator_precedence) help? — DeiDei, Mar 10 '17 at 15:30
It's undefined behavior. Order of evaluation of operands is not defined by the standard except for a few particular operators (&&, ||, comma, ?:). — Greg Kikola, Mar 10 '17 at 15:31
@πάνταῥεῖ: What is "undetermined behaviour"? (hint: there's no such thing) — Lightness Races in Orbit, Mar 10 '17 at 15:58
@Light I rather meant something like _undetermined order of execution_. It's not UB though. — πάντα ῥεῖ, Mar 10 '17 at 16:00
@πάνταῥεῖ: The word you're looking for is "unspecified" (not to be confused with "indeterminate values"). — Lightness Races in Orbit, Mar 10 '17 at 16:07

Angew is no longer proud of SO · Accepted Answer · 2017-03-15T07:09:11.793

This has nothing to do with associativity (that comes into play in expressions like a == b == c). What you're asking about is the order of evaluation of an operator's operands. With a few explicitly listed exceptions, this is intentionally unspecified in C++. This means there is no guarantee whether a or b will be evaluated first in a == b.

The exceptions (for which evaluation order is guaranteed), are:

All arguments to a function call are evaluated before the function call itself (but in an unspecified order).
The left-hand side of the built-in operators || and && is evaluated first (and the right-hand side is only evaluated if necessary).
The left-hand side of the built-in operator , is evaluated before the right-hand side.
The condition in operator ?: is evaluated before the consequent, and only one of the consequents is evaluated.

Notice that the special properties of &&, ||, and , cease to apply when these operators are overloaded. This is precisely the reason why it's a bad idea to overload these three operators.

it should be noted that those exceptions are important though, see https://en.wikipedia.org/wiki/Short-circuit_evaluation — B M, Mar 10 '17 at 15:34
@BM I was working on expanding the answer, I hope it's covered now. — Angew is no longer proud of SO, Mar 10 '17 at 15:34

score 4 · Answer 2 · answered Mar 10 '17 at 15:33

You are not asking for the associativity of operator ==, but about the order of evaluation. And the order of evaluation is unspecified for this operator, so you have to assume that the order is always that which does not work for you. Split your statement in two lines to be safe.

Associativity of == operator in c++

2 Answers2