 # C programming operators

In this tutorial, you will learn about C programming operators and how they are used in programs alongside their functionalities. ## C programming operators

C programming operators are symbols that tell the compiler to perform certain mathematical or logical manipulation. In simple terms, we can say operators are used to manipulating data and variables.

For example: `+`, `-` are the operators used for mathematical calculation.

## List of C programming operators

### Operators in C programming

1: Arithmetic operator
2: Relational operator
3: Logical operator
4: Assignment operator
5: Increment/Decrement operator
6: Conditional operator
7: Bitwise operator
8: Special operator

The data items in which any operation is carried out are called operands.

``x + y``

Here `x` and `y` are operands and `+` is an operator and calculating sum is an operation.

Operators which require two operands are called binary operators and which takes single operand are called unary operators.

## Arithmetic operators in C

Operators used in the arithmetic operation like addition, subtraction, multiplication or division are called arithmetic operators.

### Meaning

Subtraction or unary minus
* Multiplication
/ Division
% Modulo division

## Relational Operator in C

Relational operators are used to compare two operators depending on their relation.

For example, for comparing the price of two things. The value of a relational operator is either `1` or `0`. If the specified relation is true then `1` else `0`.

``a > b``

Here, `>` is a relational operator and it will return `1` if `a` is greater than `b` else it will return `0`.

### 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
Common Programming Error
A syntax error will occur if the two symbols in any of the operators `==`, `>=`, `<=` and `!=` are separated by the space.

## Logical Operator in C

Logical operators are used when more than one condition is tested. They are used to combine more than one relational expressions.

For example:

``a > b && c == 1``

Here `&&` is relational operator used to combine two relational expressions `a > b` and `c == 1`.

&& logical AND
|| logical OR
! logical NOT

### Example: Logical AND (&&) operator

If we need to make sure that both conditions are true before performing a certain task. In this case, logical `AND &&` is used:

``````if ( gender == 1 && age <= 10 )
++childNumber;``````

In this case, `if` condition is true only when both of the conditions `gender == 1` and `age <= 10` are true.

Finally, if the combined condition is true, then only `childNumber` is increased by `1`.

### Example: Logical OR (||) operator

If we wish to ensure that either or both of two conditions are true then we use logical `OR (||)` operator.

``````if (mark < 40 || attendance < 15)
puts("Student is not qualified for exam");``````

In this case, if any of the conditions is true then `if` statement is also true and the message `Student is not qualified for exam` is printed.

## Assignment Operator in C

The assignment operator is used to assign a value or a result to a data item or a variable.

`=` is the assignment operator.

For example:

``a = 5``

Here, `=` is assignment operator which assigns value 5 to variable `a`.
Assume:

``int c = 2, d = 3, e = 4, f = 6, g = 8``
Assignment Operator Sample expression Explanation Assigns
+= c += 2 c = c + 2 4 to c
-= d -= 1 d = d – 1 1 to d
*= e *= 2 e = e * 2 8 to e
/= f /= 3 f = f / 3 2 to f
%= g %= 4 g = g % 4 2 to g

Note: Don’t get confused between equality operator `==` and assignment operator `=`.

## Bitwise Operator in C

Bitwise operators are used to manipulate data at a bit level. They are used for testing or shifting the bit.

### Meaning

& bitwise AND
| bitwise OR
^ bitwise exclusive OR
<< shift left
>> shift right

## Conditional operator in C

Conditional operator is a ternary operator that takes three operands.

Syntax

``x = exp1 ? a : b``

Here, if `exp1` is non zero i.e. `TRUE` then the value of `a` will be assigned to `x` and if `exp1` is zero i.e. `FALSE` then the value of `b` is assigned to `x`.

learn about  conditional operator (?:) in detail.

## Increment / Decrement operator in C

C provides an increment operator `++` and decrement operator `--`. The functionality of `++` is to add 1 unit to the operand and `--` is to subtract 1 from the operand.

For example

``````++ a;
-- b;``````

Here `++a` is equivalent to `a = a + 1` and `--b` is equivalent to `b = b - 1`.

There are two kinds of increment and decrement operator i.e prefix and postfix.

If the operator is used before the variable i.e `++a` then it is called prefix increment operator.

If the operator is used after variable i.e `a++` then it is called postfix increment operator.

In the prefix operator, first 1 is added and then the value is assigned to the variable.

In postfix operator, first the value is assigned then only 1 is added and the added value is assigned.

Operator Sample expression Explanation
++ ++x x is increased by 1, then use the value of `x`
++ x++ Use the current value of `x` and then increment `x` by 1
– – – -x `x` is decreased by 1, then use the value of `x`
– – x- – Use the current value of `x` and then decrement `x` by 1

### Working of post-increment and pre-increment operator

``````#include <stdio.h>

int main()
{
int i;

i = 4;

printf( "%d\n", i );
printf( "%d\n", i++ );   //post increment
printf( "%d\n\n", i );

i = 4;
printf( "%d\n", i );
printf( "%d\n", ++i );   //preincrement
printf( "%d\n", i );

return 0;
}``````

Output

```4
4
5

4
5
5```

## Special operators in C

Besides these fundamental operators, C provides some other special operators like `comma` operator and `sizeof` operator

## Comma operator in C

It is used to combine more than one expression. A comma linked list of expressions are evaluated left to right.

## sizeof operator in C

`sizeof` operator is an operator which when used with operand returns the number of bytes occupied by the operand.

For example

``x = sizeof( a );``

Here, the size occupied by variable a will be assigned to x.