Operators and

Expressions
Introduction

 C operators can be classified into a number of categories

1. Arithmetic (+, -, *, /, %)
2. Relational (<, <=, >, >=, ==, !=)
3. Logical (&&, ||, !)
4. Assignment (=, +=, -=, *=, /=, %=)
5. Increment(decrement) (++, --)
6. Conditional (? :)
7. Bitwise (&, |, ^, <<, >>)
8. Special (,,sizeof)
Arithmetic operators
 C provides all basic arithmetic operators
 The operators that are used to perform arithmetic operation such as addition,
subtraction, multiplication, division etc are called arithmetic operators.
 The operators are +, - ,* , / , %.
 Let a=10, b=5. Here, a and b are variables and are known as operands.

Operator Meaning
+ Addition or unary plus
- Subtraction or unary minus
* Multiplication
/ Division
% Modulo division (applied only to integers)
Relational operators

We often compare two quantities and depending on their relation, take certain
decisions.
Operator Meaning
< Is less than
<= Is less than or equal to
> Is greater than
>= Is greater than or equal
to
== Is equal to
!= Is not equal to

A simple relational expression contains only one relational operator:

arithm_expr1 relat_op arithm_expr2
4.5 <= 10 TRUE
4.5 < -10 FALSE
-35 >= 0 FALSE
10 < 7+5 TRUE
a + b == c + d TRUE // if a + b is equal to c + d
Relational operators: Complements
 Among the six relational operators, each is a complement of
another operator.
> is complement <=
of
< is complement >=
of
== is complement !=
of

 We can simplify an expression involving the not and the less than operator
using the complements as shown below:
Actual one Simplified one
!(x<y) x => y
!(x>y) x <= y
!(x!=y) x == y
!(x<=y) x>y
!(x>=y) x<y
!(x==y) x != y
Logical operators

 I an addition to the relational operators, C has the following three logical operators.

&& Meaning logical AND

|| Meaning logical OR
! Meaning logical NOT

• They are used when we need to test more than one conditions to
make decisions.
• An example is:
a > b && x == 10
The compound expression is true when a > b and x == 10 is true.
Logical operators

Value of the expression

op-1 op-2 op-1 && op- op-1 || op-2
2

Non-zero Non-zero 1 1

Non-zero 0 0 1
0 Non-zero 0 1
 0
Relative precedence of the0 relational and
0 logical operators
0 is as
follows
Highest priority !
> >= < <=
== !=
&&
Lowest priority ||
Assignment operators

 We have already applied the usual assignment operator. In addition, C has a set of
shorthand assignment operators of the form
v op= expr;
is equivalent to
v = v op (expr)

Statement with Statement with

simple assignment shorthand operator
operator
a=a+1 a += 1
a = a -1 a -= 1
a = a * (n+1) a =* (n+1)
a = a / (n+1) a =/ (n+1)
a=a%b a %= b
Assignment operators

The use of shorthand assignment operators has advantages:

 What appears on the left-hand side need not be repeated and therefore it
becomes easier to write.
 The statement is more concise and easier to read.
 The statement is more efficient.

value[5*j-2] = value[5*j-2] + delta; value[5*j-2]+= delta;

Increment and decrement operators

 C allows two very useful operators not generally found in other languages.
There are the increment and decrement operators:
++ and --
The operator ++ adds 1 to the operand, while -- subtracts 1.

++m; is equivalent to m = m + 1; (or m+= 1)

--m; is equivalent to m = m -1; (or m-= 1)

Prefix operator Postfix operator

m = 5; m = 5;
y = ++m; y = m++;
m is 6 and y is m is 6 and y is 6
5
• Example: m = n++ - j + 10; Old value of n is used in evaluation.
Conditional Operator

 A ternary operator pair “? :” is available in C to construct conditional

expressions of the form:
exp1 ? exp2 : exp3
where exp1, exp2, and exp3 are expressions.
exp1 is a condition and is evaluated first. If it is true, then the
expression exp2 is evaluated and becomes the value of expression. Otherwise
exp3 becomes the value of expression.
a = 10;
b = 15;
x = (a > b) ? a : b;
Bitwise operator
 Bitwise operators are used for testing the bits, or shifting them right or
left.
 Bitwise operators are not applied to float or double.

Operato Meaning inputs & inputs | inputs ^

r 0&0 0 0&0 0 0&0 0
& Bitwise AND 0&1 0 0&1 1 0&1 1
| Bitwise OR 1&0 0 1&0 1 1&0 1
^ Bitwise exclusive OR 1&1 1 1&1 1 1&1 0
<< Shift left
>> Shift right
Special operators

 C supports some special operators of interest such as

 comma operator :
 value = (x = 10, y = 5, x + y);
 while (c = getchar(), c != ‘10’)
 t = x, x =y, y = t;
 sizeof operator:
 m = sizeof(sum);
 n = (long int);
 K = sizeof(235L)
 pointer operators (& and *) and
 member selection operators (. and ->)
Arithmetic expressions

 An arithmetic expression is a combination of variables, constants and

operators arranged as per syntax of the language.
 C does not have an operator for exponentiation. y = x*x

Algebraic expression C expression

a·b-c a*b-c
(m+n) ·(x+y) (m+n) * (x+y)
(ab/c) a*b/c
3x2+2x+1 3*x*x + 2 * x + 1
(x/y)+c x/y + c
 Precedence of arithmetic operators

 An arithmetic expression without parentheses will be evaluated from left to right

using the rules of precedence of operators. There are two priority levels:
 High priority * / %
 Low priority + -
 The basic evaluation procedure includes ‘two’ left-to-right passes.
x = a – b/3 + 2*c – 1,
when a = 9, b = 12, and c =3,
x = 9 – 12/3 + 3*2 - 1

• First pass • Second pass

1. x = 9 – 4 + 3 * 2 -1 1. x = 5 + 6 - 1
2. x = 9 – 4 + 6 - 1 2. x = 11 – 1
3. x = 10
 Precedence of arithmetic
operators
9 – 12/3 + 3*2 - 1

(1) (2)
4
(3) 6
5
(4)

11

(5
)
10

Plot similar diagram for 9 - 12/(3 + 3)*(2-1). Consider that ( ) has the highest
priority!
Some computational problems

 Computers give approximate values for real numbers and the error due to such
approximations may lead to serious problems:
a = 1.0/3.0;
b = a * 3.0;
 We know that (1.0/3.0) * 3.0 is equal to 1. But there is not guarantee that the value of b
computed in a program will equal 1.
 Division by zero. Any attempt to divide a number by zero will result in abnormal
termination of the program. (We should avoid it)
 Overflow and underflow errors. It is our responsibility to guarantee that
operands are of the correct type and range.
 Type conversions in expressions

 C permits mixing of constants and variables of different types in an expression.

 C automatically converts any intermediate values to the proper type so that the
expression can be evaluated without loosing any significance (implicit type
conversion).

int i,x; In an expression with mixed type

float f; the result will be converted to
double d; the type that represents wider
long int l; All shortrange;
and char are automatically converted to
x = 1 / I int; + i * f - d
int long int

long float

float

int double
Type conversions in expressions

long double
double
Conversion
hierarchy float
unsigned long
int
long int
unsigned int
int
short char
Type conversions in expressions

 Sometimes we want to force a type conversion in a way that is

different from the automatic conversion.
 Example:
float ratio;
int females_number = 7;
int males_number = 5;
ratio = females_number / males_number; // the ratio will be 1
ratio = (float ) females_number / males_number; // the ratio is 1.

The operator (float) converts the females_number to floating point for the purpose of
evaluation of the expression.
The general form of a cast (explicit conversion) is
(type-name)expression
Type conversions in expressions

 Casting can be used to round-off a given value. Consider the

following statement:
x = (int) (y + 0.5);
If y is 27.6, y+0.5 is 28.1 and on casting, the result becomes 28, the
value that is assigned to x.

Example Action
x = (int) 7.5 7.5 is converted to integer by truncation.
a = (int) 21.3 / (int) Evaluated as 21/4 and result would be 5.
4.5
b = (double) sum/n Division is done in floating mode.
y = (int) (a + b) The result of a + b is converted to integer
z = (int) a + b a is converted to integer and the added to b
p = cos((double) x) Converts x to double before using it.
Operator precedence and associativity

 Operator precedence determines the grouping of terms in an expression.

This affects how an expression is evaluated. Certain operators have
higher precedence than others;

Category Operator Associativity

Postfix () [] -> . ++ - - Left to right
Unary + - ! ~ ++ - - (type) * & sizeof Right to left
Multiplicative */% Left to right
Additive +- Left to right
Shift << >> Left to right
Relational < <= > >= Left to right
Equality == != Left to right
Bitwise AND & Left to right
Bitwise XOR ^ Left to right
Bitwise OR | Left to right
Logical AND && Left to right
Logical OR || Left to right
Conditional ?: Right to left
Assignment = += -= *= /= %=>> = <<= &= ^= |= Right to left
Comma , Left to right