Arithmetic Operators in C

1. Addition Operator: +

The addition operator causes the two values flanking on either side of it to be added together. For example:

    printf("%d", 5 + 20); 
 
    /* printf() statement causes 25 to be printed & not the exp. 5 + 20 */

The operands to be added can be variables, constants or other expressions or sub-expression as well. For Example:

    income = salary + bribes; 
 
    /*
     * statement causes the computer to look up the values of the two 
     * variables on the right, add them up, and then assign this total 
     * to the variable income.
     */

2. Subtraction Operator: –

The subtraction operator causes the number after the – sign to be subtracted from the number before the sign. For Example:

    takehome = 200.00 – 100.00; 
 
    /* The statement assigns the value 100.00 to takehome. */

Sign Operators: – and +

The minus sign can also be used to indicate or to change the algebraic sign of a value. For instance:

    rocky = –12;        /* assigns -12 to rocky */
    smokey = –rocky;    /* gives smokey the value 12 */

When the minus sign is used in this way, it is called a unary operator, meaning that it takes just one operand. The C90 standard adds a unary + operator to C. It doesn’t alter the value or sign of its operand; it just enables us to use statements, for example, like,

count = +12;

without getting a compiler complaint.

3. Multiplication Operator: *

Multiplication is indicated by the * symbol. For example:

    cm = 2.54 * inch; 
    /* statement multiplies variable inch by 2.54 & assigns product to cm */

Well! If you want a table of squares? C doesn’t have a squaring function, but, we can use multiplication to calculate squares. For example:

/* squares.c -- produces a table of first 25 squares */
#include <stdio.h>
int main(void)
{
    int num = 1;
 
    while (num <= 25) {
        printf("%4d %6d\n", num, num * num);
        num = num + 1;
    }
    return 0;
}

4. Division Operator: /

C uses the / symbol to represent division. The value to the left of the / is divided by the value to the right. For example,

    val = 15 / 3;
 
    /* statement gives variable val the value of 5 */

Division works differently for integer types than it does for floating types. Floating-type division gives a floating-point answer, but integer division yields an integer answer. An integer can’t have a fractional part, which makes dividing 10 by 3 awkward, because the answer does have a fractional part. In C, any fraction resulting from integer division is discarded. This process is called truncation.

We consider an example to see how truncation works and how integer division differs from floating-point division. For example,

/* division.c -- integer, floating-pt and mix divisions */
#include <stdio.h>
int main(void)
{
    printf("integer division:  10 / 4   is %d \n", 10 / 4);
    printf("integer division:  12 / 3   is %d \n", 12 / 3);
    printf("integer division:  9 / 4   is %d \n", 9 / 4);
    printf("floating division: 9. / 4. is %1.2f \n", 9. / 4.);
    printf("mixed division:    9. / 4  is %1.2f \n", 9. / 4);
 
    return 0;
 
    /*
     * Last printf() call includes a case of "mixed types" by having a 
     * floating-point value divided by an integer. Normally we should 
     * avoid mixing types.
     */
}

Sample Run of the above program:

integer division: 10 / 4 is 2
integer division: 12 / 3 is 4
integer division: 9 / 4 is 2
floating division: 9. / 4. is 2.25
mixed division: 9. / 4 is 2.25

Notice how integer division does not round to the nearest integer, but always truncates (that is, discards the entire fractional part). When we mixed integers with floating point, the answer came out the same as floating point. Actually, the computer is not really capable of dividing a floating-point type by an integer type, so the compiler converts both operands to a single type. In this case, the integer is converted to floating point before division.

Now, let’s see how integer division with negative numbers work. One could take the view that the rounding procedure consists of finding the largest integer smaller than or equal to the floating-point number. Certainly, 3 fits that description when compared to 3.9. But what about –3.9? The largest integer method would suggest rounding to –4 because –4 is less than –3.8. But another way of looking at the rounding process is that it just dumps the fractional part; that interpretation, called truncating toward zero, suggests converting –3.9 to –3. C99 standard says just truncate the fractional part.

5. Arithmetic Operators in C: Modulus Operator (%)

Modulus Operator (%) yields the remainder when the value at its left is divided by the value to its right (integers only).
For example,

#include <stdio.h>
int main()
{
    int a = 3;
    int b = a % 2;
    printf("%d\n", b);
}

Program Output:
1