What is operator precedence in c programming?

Answer 1

Operator precedence is often associated with order of evaluation, however order of evaluation and operator precedence are actually undefined in C. Expressions may be evaluated in any order while operator precedence is derived from the language grammar. The concept of operator precedence merely simplifies our understanding.

When we think of operator precedence we can imagine a table with 15 rows. When parsing an expression, any operator on a given row takes precedence over those on lower rows. If we also number the rows in ascending order then we can associate each row with a precedence level, such that level 1 has the highest precedence and lower rows have lower precedence.

In addition to precedence, each row also has an associativity. Rows 2, 13 and 14 have right-to-left associativity while all others have left-to-right. For instance, the assignment operator appears on row 14 thus the expression a=b=c is evaluated as if it were actually written a=(b=c) rather than (a=b)=c.

Answer 2

By way of an example, consider the following compound expression:

5 + 4 * 3

Languages such as APL that have no operator precedence will evaluate this expression from right-to-left:

5 + 4 * 3 = 5 + 12 = 17

Conversely, other languages such as SmallTalk, which also has no operator precedence, will evaluate the expression from left-to-right:

5 + 4 * 3 = 9 * 3 = 27

If we reversed the original expression (3 * 4 + 5), these two languages would produce their opposing results (27 and 17, respectively). But in C++, which supports operator precedence, it makes no difference which expression is used:

5 + 4 * 3 = 17

3 * 4 + 5 = 17

This is because multiplication always takes precedence over addition.

The ellipses operator has a higher precedence than multiplication, so if we expect the evaluation to be 27 we can use ellipses to remove the ambiguity, regardless of which expression is used:

(5 + 4) * 3 = 27

3 * (4 + 5) = 27

Operator precedence in C++ (and most other languages based upon C) ensures consistent evaluation of compound expressions, and is largely consistent with the standard operator precedence used in mathematics.

The following list shows all the C++ operators and their relative precedence (1 being the highest precedence). Note that operators with equal precedence are evaluated from right-to-left.

1. Ellipses, element, indirection, member and scope: () [] -> . ::
2. NOT, complementary, unary minus, unary plus, pointer, addressof, sizeof, type, cast, increment and decrement: ! ~ - + * & sizeof type cast ++ --
3. Multiply, divide and modulo: * / %
4. Addition and subtraction: + -
5. Bitwise shift left and right: << >>
6. Comparison: < <= > >=
7. Equality: C)

   If there's ever any doubt, use ellipses to remove all ambiguity from compound expressions. Even if they're not actually required, your code will be that much easier to read.

   An even better solution is to break compound expressions down into a series of separate operations. This not only removes ambiguity, it also eliminates the need for automatic variables (a consequence of compound expressions), it also allows you to re-use the result of an expression without having to re-evaluate it.

   Thus:

   int x = 5, y = 10, z;

   z = 1 + x * y; // x * y creates an automatic variable which is then added to 1.

   Becomes:

   int x = 5, y = 10, z;

   z = x * y; // automatic variable eliminated by assignment

   ++z;

   Example of expression re-use:

   int x=3;

   int y = x * 2 + 5; // x * 2 creates an automatic variable which is then added to 5.

   int z = x * 2 + 6; // x * 2 creates another automatic variable which is then added to 6.

   Becomes:

   int x = 3;

   int t = x * 2; // eliminates automatic variables and permits re-use of result

   int y = t + 5;

   int z = t + 6;