1

KATHMANDU UNIVERSITY SCHOOL OF

MANAGEMENT
Civil 1st year 1st semester
COM 102 : 3 Credit Hours

4. Operators in C
 2
Outline

4.1 Arithmetic Operators

4.2 Assignment Operators
4.3 Logical Operators
4.4 Bitwise Operators
4.5 Unary Operator
4.6 Conditional Operator
 3
Operators

 An operator is a symbol that tells the compiler to perform specific mathematical or logical
functions.
 These C operators join individual constants and variables to form expressions.
 C language is rich in built-in operators and provides the following types of operators:
 Arithmetic Operators
 Increment and Decrement Operators
 Assignment Operators
 Logical Operators
 Relational Operators
 Conditional Operator
 Bitwise Operators
 Special Operators
 4
Arithmetic Operators

 Arithmetic Operators are used to performing mathematical calculations like addition (+),
subtraction (-), multiplication (*), division (/) and modulus (%).
Arithmetic Operators: Example
#include<stdio.h>
5
int main(){

int a = 40, b = 20;

int add,sub,mul,div,mod;
add = a+b;
sub = a-b;
mul = a*b;
div = a/b;
mod = a%b;
printf("Addition of a, b is : %d\n", add);
printf("Subtraction of a, b is : %d\n", sub);
printf("Multiplication of a, b is : %d\n", mul);
printf("Division of a, b is : %d\n", div);
printf("Modulus of a, b is : %d\n", mod);
return 0;
}
 Format specifier
6
• The format specifiers are used in C for input
and output purposes.
• Using this concept the compiler can Integer overflows occur when the result of an arithmetic
understand that what type of data is in a operation is a value, that is too large to fit in the available
variable during taking input using the storage space.
scanf() function and printing using printf()
function.
• Here is a list of format specifiers.
#include <stdio.h>
main() {
char ch = 'B';
printf("%c\n", ch); //printing character data
//print decimal or integer data with d and I

int x = 45, y = 90;

printf("%d\n", x);
printf("%i\n", y);

float f = 12.67;
printf("%f\n", f); //print float value
printf("%e\n", f); //print in scientific notation

int a = 67;
printf("%o\n", a); //print in octal format
printf("%x\n", a); //print in hex format

char str[] = "Hello World";

printf("%s\n", str);
printf("%20s\n", str); //shift to the right 20 characters including the string
printf("%-20s\n", str); //left align
printf("%20.5s\n", str); //shift to the right 20 characters including the string, and print string up to 5 character
printf("%-20.5s\n", str); //left align and print string up to 5 character
}
 8
Increment and Decrement Operators

 Increment and Decrement Operators are useful operators generally used to minimize the
calculation.
 Increment ++ increases the value by 1 whereas decrement -- decreases the value by 1.
 These two operators are unary operators, meaning they only operate on a single operand.
 ○ ++x is same as x = x + 1 or x += 1
 ○ --x is same as x = x - 1 or x -= 1
 Increment and decrement operators can be used only with variables. They can't be used
with constants or expressions.
int x = 1, y = 1;
 ++x; // valid
 ++5; // invalid - increment operator operating on a constant value
 ++(x+y); // invalid - increment operating on an expression
 9
Prefix and Postfix Increment and Decrement

Increment/Decrement operators are of two #include<stdio.h>

types:
int main() {
1. Prefix increment/decrement operator.
int var1 = 5, var2 = 5;
2. Postfix increment/decrement operator.
// 5 is displayed
// Then, var1 is increased to 6.
printf("%d\n", var1++);
// var2 is increased to 6
// Then, it is displayed.
printf("%d\n", ++var2);
return 0;
}
 10
…
 11
Prefix increment/decrement

The prefix increment/decrement operator immediately increases or decreases

the current value of the variable. This value is then used in the expression. Let's
take an example:
y = ++x;
Here first, the current value of x is incremented by 1. The new value of x is then
assigned to y.
Similarly, in the statement:
y = --x;
the current value of x is decremented by 1. The new value of x is then assigned to
y.
The following program demonstrates prefix increment/decrement operator in
action:
 12
…

#include<stdio.h>
int main()
{
int x = 12, y = 1;
printf("Initial value of x = %d\n", x); // print the initial value of x
printf("Initial value of y = %d\n\n", y); // print the initial value of y

y = ++x; // increment the value of x by 1 then assign this new value to y

printf("After incrementing by 1: x = %d\n", x);
printf("y = %d\n\n", y);

y = --x; // decrement the value of x by 1 then assign this new value to y

printf("After decrementing by 1: x = %d\n", x);
printf("y = %d\n\n", y);

// Signal to operating system everything works fine

return 0;
}
 13
Postfix Increment/Decrement operator

The postfix increment/decrement operator causes the current value of the variable to be
used in the expression, then the value is incremented or decremented. For example:
y = x++;
Here first, the current value of x is assigned to y then x is incremented.
Similarly, in the statement:
y = x--;
the current value of x is assigned to y then x is decremented.
 14

#include<stdio.h>
int main()
{
int x = 12, y = 1;
printf("Initial value of x = %d\n", x); // print the initial value of x
printf("Initial value of y = %d\n\n", y); // print the initial value of y

y = x++; // use the current value of x then increment it by 1

printf("After incrementing by 1: x = %d\n", x);
printf("y = %d\n\n", y);

y = x--; // use the current value of x then decrement it by 1

printf("After decrementing by 1: x = %d\n", x);
printf("y = %d\n\n", y);

// Signal to operating system everything works fine

return 0;
}
 15
Assignment Operators

 An assignment operator is used for assigning a value to a variable. The most common
assignment operator is =
 16
Assignment operators: Example

#include <stdio.h>
int main()
{
int a = 5, c;
// Working of assignment operators
c = a; // c is 5
printf("c = %d\n", c);
c += a; // c is 10
printf("c = %d\n", c);
c -= a; // c is 5
printf("c = %d\n", c);
c *= a; // c is 25
printf("c = %d\n", c);
c /= a; // c is 5
printf("c = %d\n", c);
c %= a; // c = 0
printf("c = %d\n", c);
return 0;
}
 17
Relational Operators

 A relational operator checks the relationship between

two operands.
 If the relation is true, it returns1; if the relation is false, it
returns value 0.
 Relational operators are used in decision making and
loops.
 A = 5 , B = 6;
 A==B;
 A!=B;
 18
Relational Operators: Example

#include <stdio.h>
int main()
{
int m=40, n=20;
if (m == n)
{
printf("m and n are equal");
}
else
{
printf("m and n are not equal");
}
return 0;
}
 19
Classroom Assignment

 WAP to find a larger number among two numbers input by the user (use
relational operator for the comparison).
 Hints:
 A =6
 B=7
 If (A>B) {
 Pri…. A is greater.

 }
 Else { b is greater
 20
Logical Operators

 C provides three logical operators when we test more than one condition to make
decisions.
 These are: && (meaning logical AND), || (meaning logical OR) and ! (meaning logical
NOT).

&& and | | are binary operators while ! is a unary

operator.

Binary operators act upon a two operands to

produce a new value.
 21
AND (&&) operator

 The logical AND operator (&&) returns the boolean value true if both operands are true and
returns false otherwise.
 Syntax: operand1 && operand2
 Truth table of AND operator is:
 22
OR (II) operator

 The logical OR operator (||) returns the boolean value true if either or both operands is true
and returns false otherwise.
 Syntax: operand1 || operand2
 Truth Table of OR operator is:
 23
NOT (!) operator

 The logical NOT operator(!) negates the value of the condition.

 If the value of the condition is false then it gives the result true. If the value of the
condition is true then it gives the result false.
 Syntax: !operand
 The truth table of logical NOT operator is:
 24
Logical Operator: Example

#include <stdio.h>
int main() {
int m=40,n=20;
int a=20,p=30;
if (m>n && m !=0) {
printf("&& Operator : Both conditions are true\n"); }
if (a>p || p!=20) {
printf("|| Operator : Only one condition is true\n"); }
if (!(m>n && m !=0)) {
printf("! Operator : Both conditions are true\n"); }
else {
printf("! Operator : Both conditions are true. " \
"But, status is inverted as false\n"); }
return 0;
}
 25
Conditional Operator

The Conditional Operator in C, also called a Ternary operator, is one of the

Operators, which used in the decision-making process.

#include <stdio.h>
int main()
{
int age; // variable declaration
printf("Enter your age");
scanf("%d",&age); // taking user input for age variable
(age>=18)? (printf("eligible for voting")) : (printf("not eligible for voting")); // conditional
operator
return 0;
}

Syntax:
(Text Expression)? statement1 : statement2;
 26
Bitwise Operators

 The bitwise operators are the operators used to perform the operations on the
data at the bit-level.
 When we perform the bitwise operations, then it is also known as bit-level
programming.
 It consists of two digits, either 0 or 1.
 It is mainly used in numerical computations to make the calculations faster.
 1
 0000 0000 0000 0001
 256 128 64 32 16 8 4 2 1

1/17/2022
 27
Bitwise Operators in C

Operator Meaning of Operator

& Bitwise AND Operator

| Bitwise OR Operator

^ Bitwise exclusive OR Operator

~ Bitwise NOT Operator (Unary Operator)

<< Left Shift Operator

>> Right Shift Operator

 28
Bitwise AND Operator

 Bitwise AND operator is denoted by the single ampersand sign (&). Two
integer operands are written on both sides of the (&) operator.
 If the corresponding bits of both the operands are 1, then the output of the
bitwise AND operation is 1; otherwise, the output would be 0.

x y x&y
0 0 0
0 1 0
1 0 0
1 1 1
 29
Bitwise AND Operator

We have two variables a and b.

Int a =6;
Int b=4;
The binary representation of the above two variables are given below:
………….8 4 2 1
a = 0110
b = 0100
--------------------
01 00
When we apply the bitwise AND operation in the above two variables,
i.e., a&b, the output would be:
Result = 0100
 30
Example:

Checking for Odd and Even Numbers using Bitwise AND (&) Checking if a number is a power of 2

#include <stdio.h>
#include <stdlib.h> #include <stdio.h>
#include <stdlib.h>

int main(){ int main(){

int x=3; int a=32;
if(a > 0 && (a & (a - 1)) == 0){
if(!(x&1)){ printf("%d is a power of 2", a);
printf("x is even"); }
} else { return EXIT_SUCCESS;
}
printf("x is odd!");
}
}
 31
Bitwise OR operator

 The bitwise OR operator is represented by a single vertical sign (|).

 Two integer operands are written on both sides of the (|) symbol. If the bit value of any of
the operand is 1, then the output would be 1, otherwise 0.

x y x|y
0 0 0
0 1 1
1 0 1
1 1 1
 32
Bitwise OR Operator

We consider two variables,

a = 23;
b = 10;
The binary representation of the above two variables would be:
a = 0001 0111
b = 0000 1010
When we apply the bitwise OR operator in the above two variables, i.e., a|b ,
then the
output would be:
Result = 0001 1111
 33
Bitwise exclusive OR operator

 The ^ operator is bitwise XOR. The usual bitwise OR operator is inclusive OR.
 XOR is true only if exactly one of the two bits is true.
 Two operands are written on both sides of the exclusive OR operator. If the corresponding
bit of any of the operand is 1 then the output would be 1, otherwise 0.

x y x^y
0 0 0
0 1 1
1 0 1
1 1 0
 34
Bitwise Exclusive OR

We consider two variables a and b,

a = 12;
b = 10;
The binary representation of the above two variables would be:
a = 0000 1100
b = 0000 1010
When we apply the bitwise exclusive OR operator in the above two variables
(a^b), then
the result would be:
Result = 0000 0110
 35
Example:

1. WAP to swap two numbers without using another variable.

// C code to swap using XOR

#include <stdio.h>
int main()
{
int x = 10, y = 5;

// Code to swap 'x' (1010) and 'y' (0101)

x = x ^ y; // x now becomes 15 (1111)
y = x ^ y; // y becomes 10 (1010)
x = x ^ y; // x becomes 5 (0101)

printf("After Swapping: x = %d, y = %d", x, y);

return 0;
}
 36
Complement(~), Left Shift (<<), Right
Shift (>>)

1. The << (left shift) in C or C++ takes two numbers, left shifts the bits of the first operand,
the second operand decides the number of places to shift.

2. The >> (right shift) in C or C++ takes two numbers, right shifts the bits of the first
operand, the second operand decides the number of places to shift.

3. The ~ (bitwise NOT) in C or C++ takes one number and inverts all bits of it.
 37
Complement(~), Left Shift (<<), Right
Shift (>>)

// C Program to demonstrate use of // The result is 00001100

bitwise operators printf("a^b = %d\n", a ^ b);
#include <stdio.h>
int main()
{ // The result is 11111010
// a = 5(00000101), b = 9(00001001) printf("~a = %d\n", a = ~a);
unsigned char a = 5, b = 9;
// The result is 00010010
// The result is 00000001 printf("b<<1 = %d\n", b << 1);
printf("a = %d, b = %d\n", a, b);
printf("a&b = %d\n", a & b); // The result is 00000100
printf("b>>1 = %d\n", b >> 1);
// The result is 00001101
printf("a|b = %d\n", a | b);
return 0;

}
 38
Special Operators
 39
Operators Precedence in C

 Operator precedence determines the grouping of terms in an expression and decides how an expression
is evaluated.
 Certain operators have higher precedence than others;
 for example, the multiplication operator has a higher precedence than the addition operator.
40
 41

Any queries???