In programming languages, expressions are evaluated based on precedence and associativity of the operators.

Precedence: If more than one operator is available in a single statement, order of evaluation depends on precedence of operators.  Precedence refers to rank of operators that follow order of evaluation.

Compiler follows order of evaluation as:

 Highest precedence operator is evaluated first before the lowest precedence operator.
 If two or more operators have same precedence, it follows associativity.

Example: X = 2;
Y = X + 10 * 2;

=   +   *

Y = X + 20

=   +

Y = 22


Associativity: Associativity refers to the direction of evaluations as from left to right or from right to left.
Left-to-Right associativity evaluates the expression by starting on the left and moving to the right.

Example: 3 * 8 / 4 % 4 * 5

* / % * L → R

24 / 4 % 4 * 5

/ % * L → R

6 % 4 * 5

% * L → R

2 * 5

*
10

Right-to-Left associativity evaluates the expression by starting on the right and moving to the left.

Example: Assume a = 8, b = 5 and c = 8

a += b *= c -= 5
+=    *=    -= R → L

a += b *= 3
*=    -= R → L

a += 15
+=

a = 23


Operator precedence & Associatity Table:


Solve the following expressions

1. Z = ++X + Y-- - ++Y - X-- - X-- - ++Y - X—
Where X = 7 and Y = -3

Solution: X = 5, Y = -2 and Z = -15

2. Z = X++ + ++Y - X-- + --Y
Where X = 7 and Y = 9

Solution: X = 7, Y = 9 and Z = 18

/* EXAMPLE PROGRAM */

#include<stdio.h>
#include<conio.h>
main()
{
int a=9,b=12,c=3,x;
clrscr();
x=a-b/3+c*2-1;
printf("\n X=%d",x);
getch();
}

C language supports some special operators such as unary operator, comma operator, sizeof operator, pointer operators (& and *) and member selection operators (. and ->).


a) Unary minus operator: Unary minus (-) operator changes sign of the given operand.  i.e., +ve sign is changed as –ve sign and –ve sign is changed as +ve sign.

Example: +10 → -10
-456 → +456

b) Comma Operator: Comma (,) operator is used to separate the operands from one to another.
Example: int x,y;

c) sizeof Operator: sizeof operator is a compile time operator used to return the number of bytes occupied by the given operand.  The general format of sizeof operator is:

Syntax: sizeof(Operand);
Here,
The operand may be a variable, a constant or a data type.

/* EXAMPLE PROGRAM FOR SIZEOF OPERATOR */

#include<stdio.h>
#include<conio.h>
main()
{
int i;
char ch;
float f;
double d;
clrscr();
printf("\n THE SIZEOF CH VARIABLE :%d BYTES",sizeof(ch));
printf("\n THE SIZEOF I VARIABLE :%d BYTES",sizeof(i));
printf("\n THE SIZEOF F VARIABLE :%d BYTES",sizeof(f));
printf("\n THE SIZEOF D VARIABLE :%d BYTES",sizeof(d));
printf("\n THE SIZEOF CHAR DATA TYPE :%d BYTES",sizeof(char));
printf("\n THE SIZEOF INT DATA TYPE:%d BYTES",sizeof(int));
printf("\n THE SIZEOF FLOAT DATA TYPE :%d BYTES",sizeof(float));
printf("\n THE SIZEOF DOUBLE DATA TYPE :%d BYTES",sizeof(double));
printf("\n THE SIZEOF CHAR CONSTANT VALUE :%d BYTES",sizeof('@'));
printf("\n THE SIZEOF INT CONSTANT VALUE :%d BYTES",sizeof(225));
printf("\n THE SIZEOF FLOAT CONSTANT VALUE:%d BYTES",sizeof(23.45f));
printf("\n THE SIZEOF DOUBLE CONSTANT VALUE :%d BYTES",sizeof(456.678));
}

Bit1	Bit2	Bit1 & Bit2	Bit1 | Bit2	Bit1 ^ Bit2
0	0	0	0	0
0	1	0	1	1
1	0	0	1	1
1	1	1	1	0