Operators

Function
Algorithm
Flowchart

1
 Introduction
 An operator is a symbol that tells the computer to perform
certain mathematical or logical manipulations. Operators are
used in programs to manipulate data and variables.
 C operators can be classified into a number of categories.
 Arithmetic operators
 Relational operators
 Logical operators
 Assignment operators
 Increment and decrement operators
 Conditional operators
 Bitwise operators
 Special operators

2
 Relational Operators
• The relational operators in C are :
Used to compare values of two expressions
depending on their relations.
Operator Meaning
< less that
<= less than or equal to
> greater than
>= greater than or equal to
== equal to
!= not equal to

3
 Relational Operators

 A relational expression yields a value of 1 or 0.

 5 < 6 TRUE 1
 4.5<10 TRUE 1
 -34 + 8 > 23 - 5 FALSE 0
 4.5<-10 FALSE 0
 5==0 FALSE 0
 Arithmetic operators have higher priority over relational
operators.
 the associativity of relational operators is left  right

4
 Relational Operators

The relational operators >, >=, < and <=

have the same precedence. Just below them
in precedence are the equality operators: = =
and !=.
Relational operators have lower precedence
than arithmetic operators , so an expression
like i < lim-1 is taken as i < (lim-1).

3 >= 2 = = -4 < 0
5
 Operator
 An operator is a symbol that tells the computer to perform
certain mathematical or logical manipulations. Operators are
used in programs to manipulate data and variables.
 C operators can be classified into a number of categories.
 Arithmetic operators
 Relational operators
 Logical operators
 Assignment operators
 Increment and decrement operators
 Conditional operators
 Bitwise operators
 Special operators

6
 Logical operators
C has the following three logical operators
 && meaning logical AND ( binary operator )
 || meaning logical OR ( binary operator )
 ! meaning logical NOT( unary operator )

Expressions connected by && or || are evaluated

left to right, and evaluation stops as soon as the
truth or falsehood of the result is known.

7
 Logical operators
 The logical operators && and|| are used when we want
to test more than one condition and make decisions.
An example is ;
a>b && x==10

An expression of this kind, which combines two or more

relations expressions, is termed as a logical expression or
compound relational expression.
The logical expression given above is TRUE only if a>b
is true and x==10 is true. If either (or both) of them are
false, the expression is false.
8
 Logical operators

 The precedence of && is higher than that of

||, and both are lower than relational
operators, so

 3 < 5 && -3 < -5 || 3 > 2

 to decide whether a year is leap year,

 year% 4 ==0 && year % 100 != 0 || year % 400 = = 0

9
 Finding a Leap Year
There is a leap year every year whose number is
perfectly divisible by four - except for years
which are both divisible by 100 and not divisible
by 400. The second part of the rule effects
century years. For example; the century years
1600 and 2000 are leap years, but the century
years 1700, 1800, and 1900 are not.

to decide whether a year is leap year,

year% 4 ==0 && year % 100 != 0 || year % 400 = = 0

10
 Assignment operators
 Assignment operators are used to assign the result of an
expression to a variable.
 C has a set of ‘shorthand’ assignment operators of the form
 v op= exp;
 where v is a variable, exp is an expression and op is a C binary
arithmetic operator. The operator op= is known as the shorthand
assignment operator.
 The assignment statement v op= exp; is equivalent to v = v op
(exp) ;
 For example, x += y + 1; This is same as the statement x = x + ( y
+1);

11
 Assignment operators

Statement with simple Statement with shorthand

assignment 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

12
 Assignment operators
The use of shorthand assignment operators
has three advantages:

1. What appears on the left-hand side need not be

repeated and therefore it becomes easier to write.
2. The statement is more concise and easier to read.
3. The statement is more efficient.

13
 Increment and decrement operators
 C provides two unusual operators for incrementing
and decrementing variables.
 The increment operator ++ adds 1 to its operand,
while the decrement operator -- subtracts 1.
 The unusual aspect is that ++ and -- may be used
either as prefix operators (before the variable, as in +
+n), or postfix operators (after the variable: n++).
 In both cases, the effect is to increment n. But the
expression ++n increments n before its value is used,
while n++ increments n after its value has been used.

14
 Increment and decrement operators
 Prefix Increment/Decrement:
The statement y=++x means first increment the value of x by
1, then assign the value to y. this statement belongs to the
following two statement: x=x+1; x=x-1;
y=x; y=x;
#include<stdio.h> Output
main()
{
int x=8; x=8
printf(“x=%d\n”,x);
x=9
printf(“x=%d\n”,++x);
x=9
printf(“x=%d\n”,x);
printf(“x=%d\n”,--x);
x=8
printf(“x=%d”,x); x=8
}
15
 Increment and decrement operators
 Postfix Increment/Decrement:
The statement y=x++ means first the value of x is assign to
y and then x is incremented. this statement belongs to the
following two statement: y=x; y=x;
x=x+1; x=x-1;
#include<stdio.h> Output
main()
{
int x=8; x=8
printf(“x=%d\n”,x);
x=8
printf(“x=%d\n”,x++);
x=9
printf(“x=%d\n”,x);
printf(“x=%d\n”,x--);
x=9
printf(“x=%d”,x); x=8
}
16
 17

Mathematical functions
 Mathematical functions such as cos, sqrt, log, etc.
are frequently used in analysis of real-life
problems.

 We should include the line in the beginning of the

program.

#include<math.h>
18
19
20
21
22
 23

Mathematical functions
 for example
 the roots of ax2+bx+c =0 are

 b  b 2  4 ac
x 2a
 x1= ( -b + sqrt ( b*b - 4*a*c ) ) / ( 2 * a )
 x2= ( -b – sqrt ( b*b - 4*a*c ) ) / ( 2 * a )
 Solution of the quadratic equation
#include<stdio.h>
#include<math.h>
main()
{
float a,b,c,discriminant,root1,root2;
printf("Input values of a,b, and c\n");
scanf("%f %f %f",&a,&b,&c);
discriminant= b*b-4*a*c;
if(discriminant<0)
printf("\n\nRoots are imaginary\n");
else
{
root1=(-b+sqrt(discriminant))/(2.0*a);
root2=(-b-sqrt(discriminant))/(2*a);
printf("\n\nRoot1=%5.2f\n\nRoots=%5.2f\n",root1,root2);
}
}
24