Operators in C

Operators in C: Symbols which are used to perform both logical and mathematical operations in a C program are called Operators in C.



C language offers a different type of operators. They are as follows:

  • Arithmetic Operators
  • Assignment Operators
  • Relational Operators
  • Logical Operators
  • Bitwise Operators
  • Conditional Operators (ternary operators)
  • Increment/decrement operators
  • Special Operators
Operator Name Symbol Example
Addition + A+B=20
Subtraction A – B=10
Multiplication * A* B=200
Division / B/A=2
Modulus % B%A=0

Example: C program to add two numbers.

#include <stdio.h> 
void main() 
{  
  int i=3, j=7, k;  /* Variables Defining and Assign values */  
  k=i+j;  
  printf("sum of two numbers is %d\n", k); 
}

Output: sum of two numbers is 10

C Assignment Operators

These operators in C are used to assign the values for variables in the C program.

Operator Name Description Example
= Simple assignment operator, which assigns value form the right-side operands to left side operands C = A + B which will assign a value of A + B to C
+= And assignment adds the right operand to the left operand and assign the result to left C += A is equivalent to C = C + A
– = Subtract AND assignment operator. It subtracts the right operand from the left operand and assigns the result to the left operand. C -= A is equivalent to C = C – A
*= Multiply AND assignment operator. It multiplies the right operand with the left operand and assigns the result to the left operand. C *= A is equivalent to C = C * A
/= Divide AND assignment operator. It divides the left operand with the right operand and assigns the result to the left operand C /= A is equivalent to C = C / A
%= Modulus AND assignment operator. And It takes modulus using two operands and assigns the result to the left operand C %= A is equivalent to C = C % A
<<= Left shift AND assignment operator C <<= 2 is same as C = C << 2
>>= Right shift AND assignment operator. C >>= 2 is same as C = C >> 2
&= Bitwise AND assignment operator C &= 2 is same as C = C & 2
^= Bitwise exclusive OR and assignment operator. C ^= 2 is same as C = C ^ 2
|= Bitwise inclusive OR and assignment operator C |= 2 is same as C = C | 2

Example

# include <stdio.h>
int main() 
{ 
   int Total=0,
   i;                
   for(i=0;i<10;i++)             
   {                
     Total+=i; // This is same as Total = Total+i             
   }          
printf("Total = %d", Total);

Output: 45

Relational Operators in C

These operators in C are used to compare the value of two variables.

Operator Description Example
= = Checks if the values of two operands are equal or not. If yes, then the condition becomes true.     (A == B) is not true
!= Checks if the values of two operands are equal or not. If the values are not equal, then the condition becomes true (A!= B) is true
> Checks if the value of the left operand is greater than the value of the right operand. If yes, then the condition becomes true. (A > B) is not true
< Checks if the value of the left operand is less than the value of the right operand. If yes, then the condition becomes true (A < B) is true
>= Checks if the value of the left operand is greater than or equal to the value of the right operand. If yes, then the condition becomes true. (A >= B) is not true
< = Checks if the value of the left operand is less than or equal to the value of the right operand. If yes, then the condition becomes true. (A <= B) is true

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");          
}

Output: m and n are not equal

Logical Operators in C

Used to perform logical operations in C on the given two variables.

Operator Description Example
&& Called Logical AND operator. If both the operands are non-zero, then the condition becomes true (A && B) is false.
|| Called Logical OR Operator. If any of the two operands is non-zero, then the condition becomes true (A || B) is true
! Called Logical NOT Operator. And it is used to reverse the logical state of its operand. If a condition is true, then Logical NOT operator will make it false. !(A && B) is true

Example

#include <stdio.h>  
int main() 
{      
int m=40,n=20;                  
 int o=20,p=30;                   
  if (m>n && m!=0) {                   
 printf("&& Operator : Both conditions are true\n");            
  }                    
if(o>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");        
    
   }        
}

Output

&& Operator: Both conditions are true
|| Operator: Only one condition is true!
Operator: Both conditions are true. But, status is inverted as false

Bit-Wise Operators in C

Used to perform the bit operations in C on given two variables. Assume A =60 and B=13 in binary format.
A = 0011  1100
B =0000  1101

———————–

A & B = 0000 1100
A | B =  0011   1101
A ^ B = 0011  0001
~A   = 1100   0011

P q p & q p | q p^q
0 0 0 0 0
0 1 0 1 1
1 1 1 1 0
1 0 0 1 1
Operator Description Example
& Binary AND Operator copies a bit to the result if it exists in both operands. (A & B) = 12, i.e., 0000 1100
| Binary OR Operator copies a bit if it exists in either operand. (A | B) = 61, i.e., 0011 1101
^ Binary XOR Operator copies the bit if it is set in one operand but not both. (A ^ B) = 49, i.e., 0011 0001
~  Binary One’s Complement Operator is unary and has the effect of ‘flipping’ bits. (~A) = ~(60), i.e. -0111101
<< Binary Left Shift Operator. The left operands value is moved left by the number of bits specified by the right operand. A << 2 = 240 i.e., 1111 0000
>> Binary Right Shift Operator. The left operands value is moved right by the number of bits specified by the right operand. A >> 2 = 15 i.e., 0000 1111

Example

#include <stdio.h>                       
int main()    
{                      
     
int m = 40,n = 80,
 AND_opr,OR_opr,XOR_opr,NOT_opr ;                  
     AND_opr = (m&n);                       
OR_opr = (m|n);                      
NOT_opr = (~m);                       
XOR_opr = (m^n);                     
printf("AND_opr value = %d\n",AND_opr );                 
printf("OR_opr value = %d\n",OR_opr );               
printf("NOT_opr value = %d\n",NOT_opr );                 
printf("XOR_opr value = %d\n",XOR_opr );                
printf("left_shift value = %d\n", m << 1);              
printf("right_shift value = %d\n", m >> 1);       
}

Output

AND_opr value = 0
OR_opr value = 120
NOT_opr value = -41
XOR_opr value = 120
left_shift value = 80
right_shift value = 20

Conditional Operators in C

returns one value if the condition is true, and produces another value if the condition is false. It is also known as a “ternary operator”.

Operator Description
? Conditional expression

Example

#include <stdio.h>                    
int main()     
{                     
int x=1, y;                   
y = (x ==1 ? 2: 0);                    
printf("x value is %d\n", x);                    
printf("y value is %d", y);               
}

Output
x value is 1
Y value is 2

Increment-decrement Operators in C

Increment operators are used for increasing the value of a variable by one. And decrement operators are used for decreasing the value by one.

Syntax

Increment operator: ++var_name; (or) var_name++;
Decrement operator: var_name; (or) var_name ; 

Example

#include <stdio.h>                   
int main( )  
{                    
int i=1;                  
while(i<10)  {                       
printf("%d ",i);                       
i++;                 
 }      
}

Output: 1 2 3 4 5 6 7 8 9

Example 2

#include <stdio.h>                   
int main( ) {                         
int i=10;                      
while(i-- > 5) {                          
printf("%d ",i);                   
}                       
return 0; }

Output: 9 8 7 6 5

Special Operators in C

Operator Description
& t is used to get the address of the variable
 * Used as a pointer to the variable
sizeof( ) Gives size of the variable

Example

#include <stdio.h>                 
#include <limits.h>                
int main()   
{                 
   int a;               
   char b;                  
   float c;                  
   double d;                 
   printf("Storage size for int data type:%d \n",sizeof(a));          
   printf("Storage size for char data type:%d \n",sizeof(b));          
   printf("Storage size for float data type:%d \n",sizeof(c))          
   return 0;    
}

Output
Storage size for int data Storage size for char data type:1
Storage size for float data type:4

Example 2

#include <stdio.h>                 
int main( )   {                    
int *ptr, q;                     
q = 50; /* address of q is assigned to ptr */                   
ptr = &q;/* display q's value using ptr variable */              
printf("%d", *ptr);                
return 0;    
}

Output: 50