> gcc -Wall -Wextra -O2 program.c -o program
> ./program
> ```


---

**I**n general, we know that Operator is a person who operates equipment or a machine. for a programming language, Operator is a symbol that tails compiler or an interpreter to perform specific mathematical or logical / relational manipulation. Unlike others programming language C or C++ has a wide range of operator to perform the various operation. To facilitate better understanding about operator we classified the operator as:

 	
- Arithmetic Operators
 	
- Increment and Decrement Operators
 	
- Assignment Operators
 	
- Relational Operators
 	
- Logical Operators
 	
- Conditional (ternary)  Operators
 	
- Bitwise Operators
 	
- Special Operators

## C Arithmetic Operator:

 	
- Addition or Unary Plus (+),
 	
- Subtraction or Unary Minus (-),
 	
- Multiplication (*),
 	
- Division (/),
 	
- Modulus or reminder or a division (%)

Above all are categorized under C arithmetic Operators. It works with two Operand.  The operand is a variable or a constant for example *x=a+b* here *a* and* b* are the operand of the operator (+).

## 1

# Example Program  : Using Arithmetic Operators

**Output**

## Increment and decrement operators

 	
- Increment operator (++)
 	
- Decrement operator (- -)

In general C programming has increment ++ and decrement -- to step up  and step down the value of an operand (constant or variable) by 1.

Assume that you have a variable a holds value 5, then a++ step up the value by 1 after execution it will be 6. similarly, a-- step down the value of a by 1 after execution it will be 4.  Here another thing I want to highlight that the operator has two modes one is pre-increment and another is post-increment.

##  2

# Example Program: Let's focus on pre-increment bellow code block:

Output:

a=6, b=6, c=12

##  3

# Example Program: Now focus on post- increment bellow code block:

Output:

a=6, b=5, c=11

## C Assignment Operators

An assignment operator is used for assigning a value to a variable. The most common assignment operator is =

******Pictorial Representation :**

[![assignment](https://www.technhit.in/wp-content/uploads/2016/09/assignment.gif)](https://www.technhit.in/wp-content/uploads/2016/09/assignment.gif)

 

## **Shorthand technique of assignment operator:**

A shorthand operator is a shorter way to express an assignment expression.
<table border="1" summary="List of all assignment operators in C programming" width="403" cellspacing="1" cellpadding="1">
<thead>
<tr>
<th scope="col">Operator</th>
<th scope="col">Example</th>
<th scope="col">Same as</th>
</tr>
</thead>
<tbody>
<tr>
<td>=</td>
<td>a = b</td>
<td>a = b</td>
</tr>
<tr>
<td>+=</td>
<td>a += b</td>
<td>a = a+b</td>
</tr>
<tr>
<td>-=</td>
<td>a -= b</td>
<td>a = a-b</td>
</tr>
<tr>
<td>*=</td>
<td>a *= b</td>
<td>a = a*b</td>
</tr>
<tr>
<td>/=</td>
<td>a /= b</td>
<td>a = a/b</td>
</tr>
<tr>
<td>%=</td>
<td>a %= b</td>
<td>a = a%b</td>
</tr>
</tbody>
</table>

##  4

# Example Program: Using assignment operator

**Output**

## C Relational Operators

A relational operator find the relation between tow operand (Variable or Constant). If the relation is true, it returns 1; if the relation is false, it returns value 0. The Relational operators are mostly used in decision making and loops.

<table border="1" summary="List of all relational operators in C." cellspacing="1" cellpadding="1">
<thead>
<tr>
<th scope="col">Operator</th>
<th scope="col">Meaning of Operator</th>
<th scope="col">Example</th>
</tr>
</thead>
<tbody>
<tr>
<td>==</td>
<td>Equal to</td>
<td>7 == 2 returns 0</td>
</tr>
<tr>
<td>></td>
<td>Greater than</td>
<td>7 > 2 returns 1</td>
</tr>
<tr>
<td><</td>
<td>Less than</td>
<td>7 < 2 returns 0</td>
</tr>
<tr>
<td>!=</td>
<td>Not equal to</td>
<td>7 != 2 returns 1</td>
</tr>
<tr>
<td>>=</td>
<td>Greater than or equal to</td>
<td>7 >= 2 returns 1</td>
</tr>
<tr>
<td><=</td>
<td>Less than or equal to</td>
<td>7 <= 2 return 0</td>
</tr>
</tbody>
</table>

##  5

# Example Program:Using Relational Operator

**Output**

## C Logical Operators

These operators are used to perform logical operations on the given expressions. There are 3 logical operators in C language. They are, logical AND (&&), logical OR (||) and logical NOT (!).
<table border="1" summary="Logical Operators in C programming" cellspacing="1" cellpadding="1">
<thead>
<tr>
<th scope="col">Operator</th>
<th scope="col">Meaning of Operator</th>
<th scope="col">Example</th>
</tr>
</thead>
<tbody>
<tr>
<td>&&</td>
<td>Logial AND. True only if all operands are true</td>
<td>If c = 5 and d = 2 then, expression `((c == 5) && (d > 5))` equals to 0.</td>
</tr>
<tr>
<td>||</td>
<td>Logical OR. True only if either one operand is true</td>
<td>If c = 5 and d = 2 then, expression `((c == 5) || (d > 5))` equals to 1.</td>
</tr>
<tr>
<td>!</td>
<td>Logical NOT. True only if the operand is 0</td>
<td>If c = 5 then, expression `! (c == 5)` equals to 0.</td>
</tr>
</tbody>
</table>

### Circuit Diagram of And (&&) Operator

[![and-circuit](https://www.technhit.in/wp-content/uploads/2016/09/AND-circuit.gif)](https://www.technhit.in/wp-content/uploads/2016/09/AND-circuit.gif)

### Circuit Diagram of OR (||) Operator

[![or-circuit](https://www.technhit.in/wp-content/uploads/2016/09/Or-circuit.gif)](https://www.technhit.in/wp-content/uploads/2016/09/Or-circuit.gif)

### Circuit Diagram of OR (!) Operator

[![not-circuit](https://www.technhit.in/wp-content/uploads/2016/09/NOT-Circuit.gif)](https://www.technhit.in/wp-content/uploads/2016/09/NOT-Circuit.gif)

## 6

# Example Program:Using Logical Operator

**Output**

## Conditional (ternary)  Operators

The conditional (ternary) operator  is a shortcut of *If* statement in c. It operates three operands thus it called ternary operator. The basic syntax of a Conditional operator is   *condition* ? <em style="line-height: 1.5;">expression 1</em> : <em style="line-height: 1.5;">expression 2 </em>

[![ternary-operator](https://www.technhit.in/wp-content/uploads/2016/09/Ternary-Operator.png)](https://www.technhit.in/wp-content/uploads/2016/09/Ternary-Operator.png)

## 7

# Example Program:Using Conditional (Ternary ) Operator

Output:

Enter Your Age: 12

You are junior

## Bitwise Operators

As we discuss earlier post that, C is a middle-level language which has both high and low-level features. Here you can perform the bit-level operation using Bitwise operator.

C provides six operators for bit manipulation these are:

<table style="height: 200px;" width="416">
<tbody>
<tr>
<td>**Symbol**</td>
<td>**Operator**</td>
</tr>
<tr>
<td>&</td>
<td>bitwise AND</td>
</tr>
<tr>
<td>|</td>
<td>bitwise inclusive OR</td>
</tr>
<tr>
<td>^</td>
<td>bitwise XOR (eXclusive OR)</td>
</tr>
<tr>
<td><<</td>
<td>left shift</td>
</tr>
<tr>
<td>>></td>
<td>right shift</td>
</tr>
<tr>
<td>~</td>
<td>bitwise NOT (one's complement) (unary)</td>
</tr>
</tbody>
</table>

## 8

# Example Program:Using bitwise shift operator

The output of the above program will be

[mpaper title="Read more about Bitwise Operator" icon="fa-book"]

To better understand bitwise operator you have to learn boolean algebra and truth table of the gate.

### Bitwise AND

This makes more sense if we apply this to a specific operator. In C/C++/Java, the & operator is bitwise AND. The following is a chart that defines &<sup>1</sup>, defining AND on individual bits.

<table border="1" cellpadding="3">
<tbody>
<tr bgcolor="pink">
<td>  **x<sub>i</sub>**</td>
<td>  **y<sub>i</sub>**</td>
<td>**x<sub>i</sub> &<sup>1</sup> y<sub>i</sub>**</td>
</tr>
<tr align="center">
<td>0</td>
<td>0</td>
<td>0</td>
</tr>
<tr align="center">
<td>0</td>
<td>1</td>
<td>0</td>
</tr>
<tr align="center">
<td>1</td>
<td>0</td>
<td>0</td>
</tr>
<tr align="center">
<td>1</td>
<td>1</td>
<td>1</td>
</tr>
</tbody>
</table>
For instance, working with a byte (the char type):

We can do an example of bitwise &. It's easiest to do this on 4-bit numbers, however.
<table border="1" cellpadding="3">
<tbody>
<tr bgcolor="pink">
<td>Variable</td>
<td>**b<sub>3</sub>**</td>
<td>**b<sub>2</sub>**</td>
<td>**b<sub>1</sub>**</td>
<td>**b<sub>0</sub>**</td>
</tr>
<tr align="center">
<td bgcolor="#aaffaa">**x**</td>
<td>1</td>
<td>1</td>
<td>0</td>
<td>0</td>
</tr>
<tr align="center">
<td bgcolor="#aaffaa">**y**</td>
<td>1</td>
<td>0</td>
<td>1</td>
<td>0</td>
</tr>
<tr align="center">
<td bgcolor="#aabbff">**z = x & y**</td>
<td>1</td>
<td>0</td>
<td>0</td>
<td>0</td>
</tr>
</tbody>
</table>

### Bitwise OR

The | operator is bitwise OR (it's a single vertical bar). The following is a chart that defines |<sup>1</sup>, defining OR on individual bits.

<table border="1" cellpadding="3">
<tbody>
<tr bgcolor="pink">
<td>  **x<sub>i</sub>**</td>
<td>  **y<sub>i</sub>**</td>
<td>**x<sub>i</sub> |<sup>1</sup> y<sub>i</sub>**</td>
</tr>
<tr align="center">
<td>0</td>
<td>0</td>
<td>0</td>
</tr>
<tr align="center">
<td>0</td>
<td>1</td>
<td>1</td>
</tr>
<tr align="center">
<td>1</td>
<td>0</td>
<td>1</td>
</tr>
<tr align="center">
<td>1</td>
<td>1</td>
<td>1</td>
</tr>
</tbody>
</table>
Similar to bitwise AND, bitwise OR only operates at the bit level. Its result is a 1 if one of the either bits is 1 and zero only when both bits are 0. Its symbol is '|' which can be called a **pipe**.

We can do an example of bitwise |. It's easiest to do this on 4-bit numbers, however.
<table border="1" cellpadding="3">
<tbody>
<tr bgcolor="pink">
<td>Variable</td>
<td>**b<sub>3</sub>**</td>
<td>**b<sub>2</sub>**</td>
<td>**b<sub>1</sub>**</td>
<td>**b<sub>0</sub>**</td>
</tr>
<tr align="center">
<td bgcolor="#aaffaa">**x**</td>
<td>1</td>
<td>1</td>
<td>0</td>
<td>0</td>
</tr>
<tr align="center">
<td bgcolor="#aaffaa">**y**</td>
<td>1</td>
<td>0</td>
<td>1</td>
<td>0</td>
</tr>
<tr align="center">
<td bgcolor="#aabbff">**z = x | y**</td>
<td>1</td>
<td>1</td>
<td>1</td>
<td>0</td>
</tr>
</tbody>
</table>

### Bitwise XOR

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. The XOR operation is quite interesting, but we defer talking about the interesting things you can do with XOR until the next set of notes.

The following is a chart that defines ^<sup>1</sup>, defining XOR on individual bits.

 
<table border="1" cellpadding="3">
<tbody>
<tr bgcolor="pink">
<td>  **x<sub>i</sub>**</td>
<td>  **y<sub>i</sub>**</td>
<td>**x<sub>i</sub> ^<sup>1</sup> y<sub>i</sub>**</td>
</tr>
<tr align="center">
<td>0</td>
<td>0</td>
<td>0</td>
</tr>
<tr align="center">
<td>0</td>
<td>1</td>
<td>1</td>
</tr>
<tr align="center">
<td>1</td>
<td>0</td>
<td>1</td>
</tr>
<tr align="center">
<td>1</td>
<td>1</td>
<td>0</td>
</tr>
</tbody>
</table>
We can do an example of bitwise ^. It's easiest to do this on 4-bit numbers, however.
<table border="1" cellpadding="3">
<tbody>
<tr bgcolor="pink">
<td>Variable</td>
<td>**b<sub>3</sub>**</td>
<td>**b<sub>2</sub>**</td>
<td>**b<sub>1</sub>**</td>
<td>**b<sub>0</sub>**</td>
</tr>
<tr align="center">
<td bgcolor="#aaffaa">**x**</td>
<td>1</td>
<td>1</td>
<td>0</td>
<td>0</td>
</tr>
<tr align="center">
<td bgcolor="#aaffaa">**y**</td>
<td>1</td>
<td>0</td>
<td>1</td>
<td>0</td>
</tr>
<tr align="center">
<td bgcolor="#aabbff">**z = x ^ y**</td>
<td>0</td>
<td>1</td>
<td>1</td>
<td>0</td>
</tr>
</tbody>
</table>

### Bitwise NOT

There's only one unary bitwise operator, and that's bitwise NOT. Bitwise NOT flips all of the bits. There's not that much to say about it, other than it's not the same operation as the unary minus.The following is a chart that defines ~<sup>1</sup>, defining NOT on an individual bit.

<table border="1" cellpadding="3">
<tbody>
<tr bgcolor="pink">
<td>  **x<sub>i</sub>**</td>
<td>**~<sup>1</sup> x<sub>i</sub>**</td>
</tr>
<tr align="center">
<td>0</td>
<td>1</td>
</tr>
<tr align="center">
<td>1</td>
<td>0</td>
</tr>
</tbody>
</table>

We can do an example of bitwise ~. It's easiest to do this on 4 bit numbers (although only 2 bits are necessary to show the concept).

<table border="1" cellpadding="3">
<tbody>
<tr bgcolor="pink">
<td>Variable</td>
<td>**b<sub>3</sub>**</td>
<td>**b<sub>2</sub>**</td>
<td>**b<sub>1</sub>**</td>
<td>**b<sub>0</sub>**</td>
</tr>
<tr align="center">
<td bgcolor="#aaffaa">**x**</td>
<td>1</td>
<td>1</td>
<td>0</td>
<td>0</td>
</tr>
<tr align="center">
<td bgcolor="#aabbff">**z = ~x**</td>
<td>0</td>
<td>0</td>
<td>1</td>
<td>1</td>
</tr>
</tbody>
</table>

### Right shift >>

The symbol of right shift operator is >>. For its operation, it requires two operands. It shifts each bit in its left operand to the right. The number following the operator decides the number of places the bits are shifted (i.e. the right operand). Thus by doing ch >> 3 all the bits will be shifted to the right by three places and so on.

Example:

If the variable ch contains the bit pattern 11100101, then ch >> 1 will produce the result 01110010, and ch >> 2 will produce 00111001.
Here blank spaces are generated simultaneously on the left when the bits are shifted to the right. When performed on an unsigned type, the operation performed is a logical shift, causing the blanks to be filled by 0s (zeros). When performed on a signed type, the result is technically undefined and compiler dependent, however most compilers will perform an arithmetic shift, causing the blank to be filled with the sign bit of the left operand.

Right shift can be used to divide a bit pattern by 2 as shown:

i = 14; // Bit pattern 1110
j = i >> 1; // here we have the bit pattern shifted by 1 thus we get 111 = 7 which is 14/2

### Left shift <<

The symbol of left shift operator is <<. It shifts each bit in its left-hand operand to the left by the number of positions indicated by the right-hand operand. It works opposite to that of right shift operator. Thus by doing ch << 1 in the above example we have 11001010. Blank spaces generated are filled up by zeroes as above.

Left shift can be used to multiply an integer in multiples of 2 as in

int i = 4; /* bit pattern equivalent is 100 */
int j = i << 2; /* makes it 10000, which multiplies the original number by 4 i.e. 16 */

### Bitwise assignment operators

C provides a compound assignment operator for each binary arithmetic and bitwise operation (i.e. each operation which accepts two operands). Each of the compound bitwise assignment operators performs the appropriate binary operation and store the result in the left operand.

The bitwise assignment operators are as follows:
<table class="wikitable sortable jquery-tablesorter">
<thead>
<tr>
<th class="headerSort" tabindex="0" title="Sort ascending">Symbol</th>
<th class="headerSort" tabindex="0" title="Sort ascending">Operator</th>
</tr>
</thead>
<tbody>
<tr>
<td>`&=`</td>
<td>bitwise AND assignment</td>
</tr>
<tr>
<td>`|=`</td>
<td>bitwise inclusive OR assignment</td>
</tr>
<tr>
<td>`^=`</td>
<td>bitwise exclusive OR assignment</td>
</tr>
<tr>
<td>`<<=`</td>
<td>left shift assignment</td>
</tr>
<tr>
<td>`>>=`</td>
<td>right shift assignment</td>
</tr>
</tbody>
</table>

### Uses of Bitwise Operations

Occasionally, you may want to implement a large number of Boolean variables, without using a lot of space.

A 32-bit int can be used to stored 32 Boolean variables. Normally, the minimum size for one Boolean variable is one byte. All types in C must have sizes that are multiples of bytes. However, only one bit is necessary to represent a Boolean value.

You can also use bits to represent elements of a (small) set. If a bit is 1, then element **i** is in the set, otherwise it's not.You can use bitwise AND to implement set intersection, bitwise OR to implement set union.

### **Facts About Bitwise Operators**

Consider the expression **x + y**. Do either **x** or **y** get modified? The answer is no.

Most built-in binary operators do not modify the values of the arguments. This applies to logical operators too. They don't modify their arguments.

There are operators that do assignment such as +=, -=, *=, and so on. They apply to logical operators too. For example, |=, &=, ^=. Nearly all binary operators have a version with = after it.

### Summary

Bitwise operators only work on limited types: **int** and **char** (and variations of int). You can, with some casting, make it work on other types. These operators, in conjunction with bitshift operators, allow you to access and modify bits.

[/mpaper]

## Special Operators

Pointer(*), sizeof, comma(,) following you can categorise under special operator.

**Sizeof Operator**

The `sizeof` is an unary operator which returns the size of data (constant, variables, array, structure etc). it is widely used when you have to dynamic allocation of memory in your program.

**Output**

#include <stdio.h>
#include <stdlib.h>
int main(){
 int n,i,*ptr,sum=0;
 printf("Enter number of elements: ");
 scanf("%d",&n);
 ptr=(int*)malloc(n*sizeof(int)); //memory allocated using malloc
 if(ptr==NULL) 
 {
 printf("Error! memory not allocated.");
 exit(0);
 }
 printf("Enter elements of array: ");
 for(i=0;i<n;++i)
 {
 scanf("%d",ptr+i);
 sum+=*(ptr+i);
 }
 printf("Sum=%d",sum);
 free(ptr);
 return 0;
}