Home
Beginner Tutorials
C Programming

Arithmetic Operators and Type Casting in C (Explained)

Master arithmetic operators (+, -, *, /, %) and type casting in C programming. Learn how to perform complex math and safely convert data types like a
Jayanta Mondal

Introduction

In our last chapter, we learned how to read data from a user using scanf. But raw data is useless unless we process it. If a user inputs their birth year, we need to subtract it from the current year to find their age. If they input their salary, we need to multiply it by a tax rate.

To perform these mathematical calculations, C provides a robust set of Arithmetic Operators. However, math in programming is slightly different from math in high school. The compiler follows very strict rules regarding data types. If you try to divide two integers, the computer might chop off your decimals entirely!

In this chapter, we will master the five core math operators, discover the secret of the Modulo operator, and learn how to force the compiler to behave using Type Casting.






The Basic Arithmetic Operators

C provides five fundamental arithmetic operators that form the basis of all mathematical software logic.

  • Addition (+): Adds two values together. (e.g., 5 + 2 results in 7)
  • Subtraction (-): Subtracts the second value from the first. (e.g., 5 - 2 results in 3)
  • Multiplication (*): Multiplies two values. Notice we use an asterisk, not an 'x'. (e.g., 5 * 2 results in 10)
  • Division (/): Divides the first value by the second. (e.g., 10 / 2 results in 5)
  • Modulo (%): Returns the remainder of a division. (e.g., 5 % 2 results in 1, because 5 divided by 2 is 4, with a remainder of 1).

The Integer Division Trap

In C, if you divide an integer by an integer, the result must be an integer. The compiler will simply chop off the decimal part (it does not round up). For example, 5 / 2 does not equal 2.5 in C. It equals 2. This behavior causes thousands of bugs for beginner programmers!



Understanding Type Casting

What if we actually want 5 / 2 to give us 2.5? We need at least one of the numbers to be a float. But what if our numbers are already stored inside integer variables? We use a technique called Type Casting to temporarily change the data type.



Implicit Type Casting (Automatic)

Sometimes, the compiler is smart enough to do this automatically. If you add an int and a double, the compiler will automatically "upgrade" the integer to a double to prevent data loss. This is called implicit casting.



Explicit Type Casting (Manual)

As a software engineer, you should never rely on the compiler guessing your intentions. You should explicitly tell it what to do by placing the new data type in parentheses () right in front of the variable.

int a = 5;
int b = 2;
float result = (float)a / (float)b;

Now, result will accurately store 2.5.



Code Examples: Temperature Converter

#include <stdio.h>

int main() {
    int fahrenheit;
    float celsius;

    printf("--- Temperature Converter ---\n");
    printf("Enter temperature in Fahrenheit: ");
    scanf("%d", &fahrenheit);

    // Using explicit type casting and arithmetic operators
    // Formula: (F - 32) * 5/9
    
    celsius = (fahrenheit - 32) * ((float)5 / 9);

    printf("\nProcessing...\n");
    printf("Temperature in Celsius: %.2f\n", celsius);

    return 0;
}

Code Output

--- Temperature Converter ---
Enter temperature in Fahrenheit: 98

Processing...
Temperature in Celsius: 36.67

Code Explanation

Look closely at this line: ((float)5 / 9). If we simply wrote (5 / 9), the compiler would see two integers. 5 divided by 9 is 0.55, but integer division chops off the decimal, resulting in 0. Our entire calculation would be ruined, and the temperature would always be zero! By explicitly casting the 5 to a (float), we force the compiler to calculate 5.0 / 9, which preserves the decimal precision we need for an accurate calculation.


Common Mistakes for Beginners

  • Modulo with Floats: You cannot use the modulo operator (%) on floating-point numbers. It is strictly designed for integers. Writing 5.5 % 2 will cause a compiler error.
  • Division by Zero: Writing int x = 10 / 0; will instantly crash your program. You must ensure your denominator is never zero, especially when taking user input.
  • Casting the Result Too Late: Writing float ans = (float)(5 / 2); will still give you 2.0. The integer division happens first, resulting in 2, and then the 2 is cast to a float. You must cast the operands before the division: (float)5 / 2.

Best Practices

  • Always use Explicit Casting: Never rely on implicit casting. If you want a float, write (float). It makes your code self-documenting and easier for other engineers to read.
  • Use Parentheses Generously: When chaining math operators, use parentheses to clarify the order of operations (BODMAS/PEMDAS). It prevents logic errors and improves readability.

Interview Questions

Q: What is the output of -5 % 2 in C?
Answer: The output is -1. In C, the sign of the result for the modulo operator takes the sign of the numerator (the first operand).

Q: What is the difference between implicit and explicit type casting?
Answer: Implicit casting is done automatically by the compiler to prevent data loss (e.g., promoting an int to a double). Explicit casting is forced by the programmer using the cast operator, e.g., (float)x.



MCQs

Q1. What is the value of the expression: 7 / 2 in C?
A) 3.5
B) 3 (Correct)
C) 4
D) 3.0

Q2. Which operator is used to find the remainder of a division?
A) /
B) &
C) % (Correct)
D) #


Practice Questions

  1. Write a program that takes a number of days (e.g., 400) and converts it into Years, Weeks, and Days (Hint: Use division and modulo!).
  2. Calculate the area of a circle (PI * radius * radius). Ask the user for an integer radius, but output the exact float area using type casting.

Mini Assignment

Build a Simple BMI (Body Mass Index) Calculator. Ask the user for their weight in kilograms (integer) and their height in meters (float). The formula is BMI = weight / (height * height). Ensure the math calculates correctly and print the final BMI to one decimal place.



Conclusion

You have just unlocked the true processing power of your computer. You now know how to perform calculations, find remainders using the modulo operator, and safely convert data types to avoid the dreaded integer division trap.

But software is not just about math; it is about making choices. If a user's BMI is over a certain number, how do we tell the program to print a specific message? In Chapter 12: Relational and Logical Operators, we will learn how to make the computer compare values and make decisions. Get ready to add logic to your code!



📚 Recommended Reading for Aspiring Developers

Mathematics is the universal language of software engineering. See how these core arithmetic concepts power advanced technologies across the NeoGyan platform:


About the author

Jayanta Mondal
Jayanta Mondal is a BCA student, web developer, and the founder of NeoGyan. He is passionate about simplifying complex tech concepts for beginners.

Post a Comment