# Arithmetic Operators in C Tutorial

• Post author:
• Post category:C

In this section, we will learn what the arithmetic operators are and how to use them in C.

## What is Arithmetic Operator in C?

Arithmetic operators are those that we use for basic mathematical operations like addition, subtraction and others that you can see in the table below.

## Arithmetic operators list in C

This is the list of arithmetic operations in C:

 Operator Symbol Addition Operator + Subtraction Operator – Multiplication Operator * Division Operator / Modulus Operator % Increment Operator ++ Decrement Operator —

Using this operator, we can add together two values (constants or variables) and get the result.

`LeftOperand + RightOperand;`

```#include <stdio.h>

int main() {

int age = 55;
int secondAge = 80;
int totalAge = age + secondAge;

return 0;
}
```

In this example, we have `age`, `secondAge` and `totalAge` variables.

The values of `age` and `secondAge` are constant, but the value of `totalAge` variable is the result of the addition operation on the values of `age` and `secondAge`.

Note: as mentioned in operator section, the values involved in the arithmetic operation are called `operand`. So `age` and `secondAge` are the operands of the addition operation.

## C Subtraction `-` Operator:

Using this operator, we can subtract two values (constants or variables) from each other and then return the result.

## Subtraction `-` Operator Syntax:

`LeftOperand - RightOperand;`

## Subtraction `-` Operator Example:

```#include <stdio.h>

int main() {

int age = 55;
int secondAge = 30;
int difference = age - secondAge;

return 0;
}
```

In the example above, we’ve subtracted the values assigned to `width` and `height` variables and then assigned the result of this subtraction to the `difference` variable.

## C Multiplication `*` operator:

Using this operator, we can multiply two values and return the result.

## Multiplication `*` operator Syntax:

`LeftOperand * RightOperand;`

## Multiplication `*` operator Example:

```#include <stdio.h>

int main() {

int width = 55;
int height = 30;
int result = width * height;

return 0;
}
```

In the example above, we’ve multiplied the values assigned to the `width` and `height` variables and then assigned the result of this multiplication operation to `result` variable.

## C Division `/` operator:

Using this operator, we can divide two values and return the result.

## Division `/` operator Syntax:

`LeftOperand / RightOperand;`

## Division `/` operator Example:

```#include <stdio.h>

int main() {

int width = 55;
int result = width / 2;

return 0;
}
```

In the example above, we’ve divided the value assigned to the `width` variable by constant 2 and then assigned the result of this multiplication to the `result` variable.

## C Modulus `%` Operator:

How many 5 are in 13? If you think about it, there are 2!

Because if we multiply 5 to 3 we get 15 and that is greater than the value 13. So there’re only 2 packs of 5 is in the value 13. Now 2*5 is 10 and if we subtract 13 from 10 we get 3 and that’s the remainder.

Modulus is all about finding that remainder.

## Modulus `%` Operator Syntax:

`LeftOperand % RightOperand;`

## Modulus `%` Operator Example:

```#include <stdio.h>

int main() {

int valueOne = 13;
int valueTwo = 5;
int result = valueOne % valueTwo;

printf("Result: %d", result);

return 0;
```

Output:

`Result: 3`

## C Increment `++` Operator:

This operator only applies to `variables` not constants, and it’ll increase the value assigned to a variable by one.

This operator can sit on the left as well as the right side of a variable.

## Increment `++` Operator Syntax:

```++variable;

Variable++;```

## Increment `++` Operator Example:

```#include <stdio.h>

int main() {

int valueRight = 13;
int valueLeft = 13;
int left = ++valueLeft;
int right = valueRight++;

printf("left-variable: %d , right-variable: %d, valueRight: %d\n",left, right, valueRight);

return 0;
}
```

Output:

`left-variable: 14 , right-variable: 13, valueRight: 14`

Difference: if the `++` operator appears on the left side of a variable, it means increase the value of the variable by 1 before doing anything else and then proceed to the rest of instructions.

In the example above, the value assigned to `left` variable will be 14 because we set `++` to the left side of the `valueLeft` variable and this increased the value of `valueLeft` by 1 so it became 14. Now the value of `valueLeft` variable, which is 14, will be assigned to the `left` variable.

On the other hand, if the `++` operator appeared to the right side of a variable, it is only guaranteed that the next time that variable is called, its value will be increased by one. This means, when we put the `++` operator on the right side of a variable, the value of that variable won’t increase right at that moment.

In the example above, the value assigned to `right` variable will not be 14 because we set `++` to the right side of the `valueRight` variable and this will not increase the value of `valueRight` right at that moment. That’s why we got the value 13 for the `right` variable.

But the next time we called the `valueRight` variable, the value of this variable turned into 14.

## C Decrement `–` Operator:

This operator only applies to `variables` and not constants, and it’ll decrease the value assigned to a variable by one.

This operator can sit on the left as well as the right side of a variable.

Note: the same rules that applied to `++` operator apply to `–` operator as well.

## Decrement `–` Operator Syntax:

```--variable;

variable--;```

## Decrement `–` Operator Example:

```#include <stdio.h>

int main() {

int valueRight = 13;
int valueLeft = 13;
int left = --valueLeft;
int right = valueRight--;

printf("left-variable: %d , right-variable: %d, valueRight: %d\n",left, right, valueRight);

return 0;
}
```

Output:

`left-variable: 12 , right-variable: 13, valueRight: 12`

Note: The basic arithmetic operations mentioned in this section apply to operands from left to right.

For example, if we have `int res = 10/2; ` the value 10 is divided by 2 and not vice versa!