Who defines C operator precedence and associativity?

by

Operator precedence is defined in the appropriate standard. The standards for C and C++ are the One True Definition of what exactly C and C++ are. So if you look closely, the details are there. In fact, the details are in the grammar of the language. For example, take a look at the grammar production rule for + and - in C++ (collectively, additive-expressions):

additive-expression:
  multiplicative-expression
  additive-expression + multiplicative-expression
  additive-expression - multiplicative-expression

As you can see, a multiplicative-expression is a subrule of an additive-expression. This means that if you have something like x + y * z, the y * z expression is a subexpression of x + y * z. This defines the precedence between these two operators.

We can also see that the left operand of an additive-expression expands to another additive-expression, which means that with x + y + z, x + y is a subexpression of it. This defines the associativity.

Associativity determines how adjacent uses of the same operator will be grouped. For example, + is left-to-right associative, which means that x + y + z will be grouped like so: (x + y) + z.

Don’t mistake this for order of evaluation. There is absolutely no reason why the value of z could not be computed before x + y is. What matters is that it is x + y that is computed and not y + z.

For the function call operator, left-to-right associativity means that f()() (which could happen if f returned a function pointer, for example) is grouped like so: (f())() (of course, the other direction wouldn’t make any sense).

Now let’s consider the example you were looking at:

f1() + f2() * f3()

The * operator has higher precedence than the + operator, so the expressions are grouped like so:

f1() + (f2() * f3())

We don’t even have to consider associativity here, because we don’t have any of the same operator adjacent to each other.

Evaluation of the functions call expressions is, however, completely unsequenced. There’s no reason f3 couldn’t be called first, then f1, and then f2. The only requirement in this case is that operands of an operator are evaluated before the operator is. So that would mean f2 and f3 have to be called before the * is evaluated and the * must be evaluated and f1 must be called before the + is evaluated.

Some operators do, however, impose a sequencing on the evaluation of their operands. For example, in x || y, x is always evaluated before y. This allows for short-circuiting, where y does not need to be evaluated if x is known already to be true.

The order of evaluation was previously defined in C and C++ with the use of sequence points, and both have changed terminology to define things in terms of a sequenced before relationship. For more information, see Undefined Behaviour and Sequence Points.

More Related Contents:

  1. Is short-circuiting logical operators mandated? And evaluation order?
  2. What are the evaluation order guarantees introduced by C++17?
  3. Compilers and argument order of evaluation in C++
  4. How to convert an enum type variable to a string?
  5. Post-increment and pre-increment within a ‘for’ loop produce same output [duplicate]
  6. Operator Precedence vs Order of Evaluation
  7. Is floating-point addition and multiplication associative?
  8. Enforcing statement order in C++
  9. order of evaluation of operands
  10. Unexpected order of evaluation (compiler bug?) [duplicate]
  11. C# conditional AND (&&) OR (||) precedence
  12. Order of evaluation of elements in list-initialization
  13. Order of evaluation of assignment statement in C++
  14. Multiple preincrement operations on a variable in C++(C ?)
  15. Order of execution in constructor initialization list
  16. How do we explain the result of the expression (++x)+(++x)+(++x)?
  17. “IF” argument evaluation order?
  18. Why does the expression a = a + b – ( b = a ) give a sequence point warning in c++?
  19. Ternary conditional and assignment operator precedence
  20. Does this code from “The C++ Programming Language” 4th edition section 36.3.6 have well-defined behavior?
  21. Logical AND, OR: Is left-to-right evaluation guaranteed?
  22. What’s the precedence of comma operator inside conditional operator in C++?
  23. The output of cout
  24. How is “std::cin>>value” evaluated in a while loop?
  25. order of evaluation of function parameters
  26. How to call erase with a reverse iterator
  27. How do you determine the size of an object in C++?
  28. Get a file name from a path
  29. How to enable visual styles without a manifest
  30. LRU implementation in production code

Leave a Comment