What Is Float in C

Example

Here is a simple program demonstrating the use of float:

#include <stdio.h>

int main() {
    float num1 = 5.23;
    float num2 = 3.14;
    float sum = num1 + num2;
    
    printf("Number 1: %f\n", num1);
    printf("Number 2: %f\n", num2);
    printf("Sum: %f\n", sum);
    
    return 0;
}

You can also try this code with Online C Compiler

Run Code

Output:

Number 1: 5.230000
Number 2: 3.140000
Sum: 8.370000

By default, float values are printed with six decimal places. To control the precision, you can use %.2f to display only two decimal places:

printf("Sum: %.2f\n", sum);

Examples of Float in C  

A `float` variable is used to store decimal numbers, & it occupies 4 bytes of memory. Let’s take a simple example to show how it works:  

include <stdio.h>

int main() {
    // Declare a float variable
    float temperature = 36.5;

    // Print the value of the float variable
    printf("The temperature is: %f\n", temperature);

    return 0;
}

You can also try this code with Online C Compiler

Run Code

In this example, we declared a `float` variable named `temperature` & assigned it the value `36.5`. The `%f` format specifier in the `printf` function is used to print the value of the `float` variable. When you run this program, it will output:  

The temperature is: 36.500000

Notice that the output shows six decimal places by default. This is because `float` in C provides precision up to six decimal digits.  

Now, let’s look at another example where we perform arithmetic operations using `float` variables:  

include <stdio.h>

int main() {
    // Declare two float variables
    float num1 = 10.5;
    float num2 = 3.2;

    // Perform arithmetic operations
    float sum = num1 + num2;
    float difference = num1 - num2;
    float product = num1  num2;
    float quotient = num1 / num2;

    // Print the results
    printf("Sum: %f\n", sum);
    printf("Difference: %f\n", difference);
    printf("Product: %f\n", product);
    printf("Quotient: %f\n", quotient);

    return 0;
} 

You can also try this code with Online C Compiler

Run Code

In this program, we declared two `float` variables, `num1` & `num2`, & performed addition, subtraction, multiplication, & division operations on them. The results are stored in new `float` variables & printed using `printf`. The output will be:  

Sum: 13.700000
Difference: 7.300000
Product: 33.599998
Quotient: 3.281250

This example shows how `float` variables can be used for mathematical calculations involving decimal numbers.  

How float and double are stored?

float and double are stored in memory using IEEE 754 standard representation. A float takes 4 bytes (32 bits), while a double takes 8 bytes (64 bits).

IEEE 754 Format for Float

• 1 bit for the sign (0 for positive, 1 for negative)
   
• 8 bits for the exponent
   
• 23 bits for the mantissa (fractional part)

IEEE 754 Format for Double

• 1 bit for the sign
   
• 11 bits for the exponent
   
• 52 bits for the mantissa

A double provides higher precision compared to float due to more bits allocated for the mantissa.

C Float Memory Representation

In C, the float type occupies 4 bytes of memory. The storage pattern follows the IEEE 754 standard. Let’s see an example of how we can check the memory size of float in C:

#include <stdio.h>

int main() {
    printf("Size of float: %lu bytes\n", sizeof(float));
    return 0;
}

You can also try this code with Online C Compiler

Run Code

Output

Size of float: 4 bytes

Each float variable is stored in binary form in memory, representing its sign, exponent, and mantissa.

Uses of Float in C  

The `float` data type is widely used in C programming for various applications where decimal precision is required. Let’s explore some common uses of `float` in real-world programming scenarios.  

1. Scientific Calculations  

In scientific applications, precise calculations involving decimal numbers are essential. For example, calculating the area of a circle or performing physics-related computations often requires the use of `float`.  

include <stdio.h>
include <math.h>

int main() {
    // Declare a float variable for radius
    float radius = 5.7;

    // Calculate the area of the circle
    float area = 3.14159  pow(radius, 2);

    // Print the result
    printf("The area of the circle is: %f\n", area);

    return 0;
}

You can also try this code with Online C Compiler

Run Code

In this example, we calculate the area of a circle using the formula `π  r²`. The `pow` function from the `math.h` library is used to square the radius. The output will be:  

The area of the circle is: 102.070007

2. Financial Computations  

In financial applications, `float` is used to handle monetary values, such as calculating interest, taxes, or discounts.  

include <stdio.h>

int main() {
    // Declare float variables for principal, rate, and time
    float principal = 1000.0;
    float rate = 5.0; // 5% interest rate
    float time = 2.0; // 2 years

    // Calculate simple interest
    float interest = (principal  rate  time) / 100;

    // Print the result
    printf("The simple interest is: %f\n", interest);

    return 0;
}

You can also try this code with Online C Compiler

Run Code

This program calculates simple interest using the formula `(P  R  T) / 100`. The output will be:  

The simple interest is: 100.000000

3. Graphics & Game Development  

In graphics & game development, `float` is used to represent coordinates, velocities, & other physical properties that require decimal precision.  

include <stdio.h>

int main() {
    // Declare float variables for coordinates
    float x = 10.5;
    float y = 20.3;

    // Move the point by adding some value
    x += 5.2;
    y += 3.7;

    // Print the new coordinates
    printf("New coordinates: (%f, %f)\n", x, y);

    return 0;
}

You can also try this code with Online C Compiler

Run Code

This example simulates moving a point in a 2D space by updating its coordinates. The output will be:  

New coordinates: (15.700000, 24.000000)

4. Data Analysis  

In data analysis, `float` is used to handle datasets with decimal values, such as temperature readings, sensor data, or statistical measurements.  

include <stdio.h>

int main() {
    // Declare an array of float values
    float temperatures[] = {22.5, 23.7, 24.8, 25.3, 26.1};

    // Calculate the average temperature
    float sum = 0.0;
    for (int i = 0; i < 5; i++) {
        sum += temperatures[i];
    }
    float average = sum / 5;

    // Print the average temperature
    printf("The average temperature is: %f\n", average);

    return 0;
}

You can also try this code with Online C Compiler

Run Code

This program calculates the average temperature from an array of `float` values. The output will be:  

The average temperature is: 24.480000

These examples show how versatile the `float` data type is in C programming. It is essential for tasks that require precision & handling of decimal numbers.  

Differences between float and double

Example Demonstrating Precision Difference

#include <stdio.h>

int main() {
    float f = 3.1415926535;
    double d = 3.1415926535;
    
    printf("Float value: %.10f\n", f);
    printf("Double value: %.10lf\n", d);
    
    return 0;
}

You can also try this code with Online C Compiler

Run Code

Output:

Float value: 3.1415927410
Double value: 3.1415926535

As we can see, the float value loses precision after a few decimal places, while double retains more precision.

Frequently Asked Questions

Why use float instead of double in C?

Float uses less memory (4 bytes) than double (8 bytes), making it suitable for applications where memory optimization is necessary.

What is the difference between float and double in terms of accuracy?

A float typically provides precision up to 6-7 decimal places, while a double can provide precision up to 15-16 decimal places.

How do I print a float value with specific decimal places?

Use %.2f inside the printf function to print up to two decimal places. 

Conclusion

In this article, we discussed float in C, a data type used to store decimal (floating-point) numbers with single precision. It occupies 4 bytes of memory and is useful for handling real numbers in calculations. The float type provides a balance between memory usage and precision. Understanding float in C helps in performing accurate mathematical computations efficiently.