An arithmetic operator performs mathematical operations, the ones we learn in elementary school.

: addition`+`

: subtraction`-`

: multiplication`*`

: division`/`

: modulus, remainder after division`%`

: increment, increases the value by one`++`

: decrement, decreases the value by one`--`

Let’s look at a coding example!

```
#include <stdio.h>
int main(void)
{
int a = 11,b = 3, c;
("If a = %d and b = %d, then: \n", a,b);
printf= a+b;
c ("a+b = %d \n",c);
printf= a-b;
c ("a-b = %d \n",c);
printf= a*b;
c ("a*b = %d \n",c);
printf= a/b;
c ("a/b = %d \n",c);
printf= a%b;
c ("Remainder when a is divided by b = %d \n",c);
printf
return 0;
}
```

The output of this program will be:

```
If a = 11 and b = 3, then:
a+b = 14
a-b = 8
a*b = 33
a/b = 3
Remainder when a is divided by b = 2
```

Note: if you divide 11 by 3 on a calculator, the result will be 3.6666, but since we are working with integers, only 3 is printed.

Let’s look at an increment example separately as it can be a little tricky.

```
#include <stdio.h>
int main(void)
{
int a = 5;
("a = %d \n", a);
printfint b = ++a; // first 'a' becomes 6 and then stored in 'b';
("b = %d \n", b);
printfint c = a++; // first 'a' i.e. 6 is stored in 'c' then 'a' becomes 7.
("c = %d \n", c);
printfint d = a; // a is now 7 in memory slot d.
("d = %d \n", d);
printf("a = %d \n", a);
printf
return 0;
}
```

The output will be:

```
a = 5
b = 6
c = 6
d = 7
a = 7
```

An assignment operator will assign (shocking! I know) a value to a variable.

: simply assign. B = A`=`

: adds and assigns. B += A is the same as B = B+A`+=`

: subtracts and assigns. B -= A is the same as B = B - A`-=`

: multiplies and assigns. B`*=`

*= A is the same as B = B*A: divides and assigns. B /= A is the same as B = B / A`/=`

: takes the modulus and assigns. B %= A is the same as B = B % A`%=`

Let’s look at an example!

```
#include <stdio.h>
int main(void)
{
int a = 5, c;
= a; // c is 5
c ("c = %d\n", c);
printf+= a; // c is 10
c ("c = %d\n", c);
printf-= a; // c is 5
c ("c = %d\n", c);
printf*= a; // c is 25
c ("c = %d\n", c);
printf/= a; // c is 5
c ("c = %d\n", c);
printf%= a; // c = 0
c ("c = %d\n", c);
printf
return 0;
}
```

The output will be:

```
c = 5
c = 10
c = 5
c = 25
c = 5
c = 0
```

A relational operator will check the relationship of two values. If the relation is true, it returns 1; if the relation is false, it returns value 0.

: equal to. If the values are equal, it returns 1.`==`

: not equal to. If the values are NOT equal, it returns 1.`!=`

: greater than. If the left value is greater than the right value, it returns 1.`>`

: less than. If the left value is less than the right value, it returns 1.`<`

: greater than or equal to. If the left value is greater than or equal to the right value, it returns 1.`>=`

: less than or equal to. If the left value is less than or equal to the right value, it returns 1.`<=`

Let’s take a look at a coding example:

```
#include <stdio.h>
int main(void)
{
int a = 3, b = 3, c = 7;
("%d == %d is %d \n", a, b, a == b);
printf("%d == %d is %d \n", a, c, a == c);
printf("%d != %d is %d \n", a, b, a != b);
printf("%d != %d is %d \n", a, c, a != c);
printf("%d > %d is %d \n", a, b, a > b);
printf("%d > %d is %d \n", a, c, a > c);
printf("%d < %d is %d \n", a, b, a < b);
printf("%d < %d is %d \n", a, c, a < c);
printf("%d >= %d is %d \n", a, b, a >= b);
printf("%d >= %d is %d \n", a, c, a >= c);
printf("%d <= %d is %d \n", a, b, a <= b);
printf("%d <= %d is %d \n", a, c, a <= c);
printf
return 0;
}
```

The output is:

```
3 == 3 is 1
3 == 7 is 0
3 != 3 is 0
3 != 7 is 1
3 > 3 is 0
3 > 7 is 0
3 < 3 is 0
3 < 7 is 1
3 >= 3 is 1
3 >= 7 is 0
3 <= 3 is 1
3 <= 7 is 1
```

Remember: 1 is true, 0 is false.

A logical operator connects two or more expressions and returns either 0 or 1 depending upon whether the compound expression results true or false.

: Logical AND, it is true only if all operands are true`&&`

: Logical OR, it is true if either one operand is true`||`

: Logical NOT, it is used to reverse the logical state. If a condition is true, then NOT will make it false.`!`

Let’s look at an example:

```
#include <stdio.h>
int main(void)
{
int a = 3, b = 3, c = 7, result;
= (a == b) && (c > b);
result ("(a == b) && (c > b) is %d \n", result);
printf
= (a == b) && (c < b);
result ("(a == b) && (c < b) is %d \n", result);
printf
= (a == b) || (c < b);
result ("(a == b) || (c < b) is %d \n", result);
printf
= (a != b) || (c < b);
result ("(a != b) || (c < b) is %d \n", result);
printf
= !(a != b);
result ("!(a != b) is %d \n", result);
printf
= !(a == b);
result ("!(a == b) is %d \n", result);
printf
return 0;
}
```

The output is

```
(a == b) && (c > b) is 1 // both expressions are true, so the compound expression is true
(a == b) && (c < b) is 0 // the first expression is true but the second is not, so the compound expression is false
(a == b) || (c < b) is 1 // the first expression is true, so the compound expression is true
(a != b) || (c < b) is 0 // both expressions are false, so the compound expression is false
!(a != b) is 1 // a != b will return 0 but since we have the !, then !0 is 1
!(a == b) is 0 // a == b will return 1 but since we have the !, then !1 = 0
```

Bitwise operators perform bit-level operations. This is not used in intro to C, but it will be a good reference for the future.

: Bitwise AND; copies a bit to the result if it exists in both operands`&`

: Bitwise OR; copies a bit if it exists in either operand.`|`

: Bitwise XOR; short for “e`^`

**x**clusive**or**”, copies the bit if it is set in one operand but not both.: Bitwise NOT; inverts all the bits from one operand.`~`

: Bitwise shift left; takes two numbers, left shifts the bits of the first operand, the second operand decides the number of places to shift.`<<`

: Bitwise shift right; takes two numbers, right shifts the bits of the first operand, the second operand decides the number of places to shift.`>>`

So to understand this example, I recommend you have a binary converter opened, such as this one!

Let’s suppose we have two numbers, a which is equal to 60 and b which is equal to 13. If we convert them to binary, we have that:

```
a = 0011 1100
b = 0000 1101
```

So what these bitwise operators will do is analyze each bit, return 0 or 1 and by doing that to all the 8 bits, we will have a new binary number.

For example:

`a&b`

```
a = 0011 1100
b = 0000 1101
---------------
a&b = 0000 1100
```

For `a&b`

, a AND b must be 1 to return 1, if not it
returns 0. Let’s expand this bit by bit to further understand.

```
a's first bit = 0
b's first bit = 0
a&b's first bit = ?
```

Both are 0, so the first bit of `a&b`

will be
`0`

. Onto the next bit:

```
a's second bit = 0
b's second bit = 0
a&b's second bit = ?
```

Again both are 0, so the second bit of `a&b`

will be
`0`

.

```
a's third bit = 1
b's third bit = 0
a&b's third bit = ?
```

In this case, a is 1 and b is 0. The third bit of
`a&b`

will still be `0`

.

```
a's forth bit = 1
b's forth bit = 0
a&b's forth bit = ?
```

Again, a is 1 and b is 0. The forth bit of `a&b`

will
still be `0`

. Therefore, so far for `a&b`

we
have:

`a&b = 0000`

Now let’s move to the fifth bit

```
a's fifth bit = 1
b's fifth bit = 1
a&b's fifth bit = ?
```

Yay! a and b are finally both 1! So for the fifth bit of
`a&b`

we will have a `1`

!

```
a's sixth bit = 1
b's sixth bit = 1
a&b's sixth bit = ?
```

And we have another `1`

for `a&b`

since a
and b are 1’s. We are almost there!

```
a's seventh bit = 0
b's seventh bit = 0
a&b's seventh bit = ?
```

Both are 0, so the seventh bit of `a&b`

will be
`0`

. Last move to the last bit:

```
a's eighth bit = 0
b's eighth bit = 1
a&b's eighth bit = ?
```

Here a is 0 and b is 1, so the last bit of `a&b`

will
be a `0`

.

And our final result is:

`a&b = 0000 1100`

If we convert `a&b`

to decimal, we will have 12, which
it might be odd if you just look at it as decimals, that is why you need
to convert to binary.

`a|b`

```
a = 0011 1100
b = 0000 1101
---------------
a|b = 0011 1101 // a OR b must be 1 to return 1, if not it returns 0
```

Converting that will return 61.

`a^b`

```
a = 0011 1100
b = 0000 1101
---------------
a^b = 0011 0001 // only a OR b must be 1 to return 1. if both are true/false, then it returns 0
```

Converting to decimal will return 49.

`~a`

```
a = 0011 1100
---------------
~a = 1100 0011 // inverts the bits
```

Converting to decimal will return -61 because the first bit is 1, so the number is negative.

`a << 2`

```
a = 0011 1100
------------------
a << 2 = 1111 0000 // moved the 2 first bits to the end
```

Converting to decimal will return 240.

`a << 2`

```
a = 0011 1100
------------------
a << 2 = 0000 1111 // moved the 2 last bits to the front
```

Converting to decimal will return 15.

And here’s in code:

```
#include <stdio.h>
int main(void)
{
int a = 60, b = 13;
("%d \n", a&b);
printf("%d \n", a|b);
printf("%d \n", a^b);
printf("%d \n", ~a);
printf("%d \n", a << 2);
printf("%d \n", a >> 2);
printfreturn 0;
}
```

The output is:

```
12
61
49
-61
240
15
```

The compiler will not show the binaries, it will return the decimal value.