What You Will Learn

Prerequisites

Complete Lecture 1 on integer constants first, because we reuse the same compile-and-run workflow. You need gcc and a terminal. No maths beyond powers of ten is required.

What Counts as a Floating Point Constant in C?

A floating constant is a real number written in one of two shapes: with a decimal point (fixed notation), with an exponent (scientific notation), or both. The key point many tutorials miss is that a decimal point is not mandatory. 1e3 has no point at all, yet it is a floating constant equal to 1000.0 and has type double.

Rules the lexer enforces: no spaces or commas inside the constant, at least one digit in the number part, and an integer exponent (optionally signed) after e or E. So 1e, 1.2e3.4 and e5 are all invalid; the last one is just an identifier. As with integers, a leading minus is the negation operator, not part of the constant.

Exponential Notation for Floating Point Constants

Very large and very small numbers become unreadable in fixed notation, so scientific notation splits a value into a mantissa (also called the significand) and an exponent of ten. Think of the exponent as the number of places the decimal point moves: positive moves it right, negative moves it left.

Negative exponents move the point left: 7.6e-6 means 0.0000076.

Floating Point Constants in C: Types and Suffixes

Unlike integers, floating constants have a simple rule: with no suffix the type is double. Add f or F for float, or l or L for long double. As with integer constants, prefer the upper-case L.

Underneath, float and double follow the IEEE 754 binary format: one sign bit, a block of exponent bits, and a block of fraction bits. The more fraction bits, the more digits you can trust.

Fractions in base ten, like 0.1, usually have no exact binary form, which is why stored values are slightly off.

Hands-On: Four Programs on Floating Point Constants

Example 1: Reading exponent notation

Save this as float_forms.c:

#include <stdio.h>

int main(void)
{
    printf("1.8e6  as %%f : %f\n", 1.8e6);
    printf("7.6e-6 as %%f : %f\n", 7.6e-6);
    printf("7.6e-6 as %%e : %e\n", 7.6e-6);
    printf("-6.7E5 as %%.1f : %.1f\n", -6.7E5);
    printf("2.5e9  as %%g : %g\n", 2.5e9);
    printf("0.0073 as %%g : %g\n", 0.0073);
    printf("5. and .5 give %.1f and %.1f\n", 5., .5);
    return 0;
}

Build and run:

$ gcc -Wall -Wextra -std=c11 -o float_forms float_forms.c
$ ./float_forms

1.8e6  as %f : 1800000.000000
7.6e-6 as %f : 0.000008
7.6e-6 as %e : 7.600000e-06
-6.7E5 as %.1f : -670000.0
2.5e9  as %g : 2.5e+09
0.0073 as %g : 0.0073
5. and .5 give 5.0 and 0.5

• %f prints fixed notation with six decimals by default, so 7.6e-6 rounds to 0.000008. Use %e to see the exponent form.
• %g chooses the shorter of the two forms, which is handy for logging.
• The last line proves that 5. and .5 are legal, even though they look odd.

Example 2: Suffixes and hidden precision

Save this as float_types.c:

#include <stdio.h>

int main(void)
{
    printf("sizeof(3.52f) = %zu\n", sizeof(3.52f));
    printf("sizeof(3.52)  = %zu\n", sizeof(3.52));
    printf("sizeof(3.52L) = %zu\n", sizeof(3.52L));
    printf("0.1f stored as %.20f\n", 0.1f);
    printf("0.1  stored as %.20f\n", 0.1);
    return 0;
}

Build and run:

$ gcc -Wall -Wextra -std=c11 -o float_types float_types.c
$ ./float_types

sizeof(3.52f) = 4
sizeof(3.52)  = 8
sizeof(3.52L) = 16
0.1f stored as 0.10000000149011611938
0.1  stored as 0.10000000000000000555

The first three lines confirm the size table. The last two are the revealing ones: 0.1f is stored as 0.100000001490116…, while 0.1 as a double is 0.100000000000000005551…. Both are close, neither is exact, and the float error is about a billion times larger. When you need more than seven reliable digits, a float is simply the wrong tool.

Example 3: Never compare with ==

Save this as float_compare.c:

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

int main(void)
{
    double x = 0.1 + 0.2;

    printf("x == 0.3 ? %s\n", (x == 0.3) ? "yes" : "no");
    printf("x - 0.3  = %.17g\n", x - 0.3);

    if (fabs(x - 0.3) < 1e-9)
        printf("close enough: treated as equal\n");
    return 0;
}

Build and run:

$ gcc -Wall -Wextra -std=c11 -o float_compare float_compare.c
$ ./float_compare

x == 0.3 ? no
x - 0.3  = 5.5511151231257827e-17
close enough: treated as equal

The two stored errors add up to a tiny difference of about 5.55e-17, enough to make == fail. The remedy is to ask “are they close enough?” with fabs(a - b) < tolerance. Pick a tolerance that matches your data: 1e-9 is fine for values near 1, but for large magnitudes use a relative tolerance such as DBL_EPSILON scaled by the values.

Example 4: Integer versus real division

Save this as mixed_math.c:

#include <stdio.h>

int main(void)
{
    printf("5 / 2        = %d\n", 5 / 2);
    printf("5 / 2.0      = %f\n", 5 / 2.0);
    printf("5.0f / 2     = %f\n", 5.0f / 2);
    printf("7 / 2 * 2.0  = %f\n", 7 / 2 * 2.0);
    printf("7 / 2.0 * 2  = %f\n", 7 / 2.0 * 2);
    return 0;
}

Build and run:

$ gcc -Wall -Wextra -std=c11 -o mixed_math mixed_math.c
$ ./mixed_math

5 / 2        = 2
5 / 2.0      = 2.500000
5.0f / 2     = 2.500000
7 / 2 * 2.0  = 6.000000
7 / 2.0 * 2  = 7.000000

• 5 / 2 has two integer operands, so the division is done on integers and the fraction is thrown away: 2.
• As soon as one operand is floating, the other is converted and you get 2.5.
• 7 / 2 * 2.0 evaluates left to right: 7/2 is 3 (integer), then 3 * 2.0 is 6.0. Reordering to 7 / 2.0 * 2 gives 7.0.
• Interview tip: always trace the type of each sub-expression, not just the final result.

Floating Point Constants in Embedded Systems

This is where theory meets product code. Many microcontrollers have no floating point unit at all, and popular ones such as the Cortex-M4F have a unit that handles only single precision. Because an unsuffixed constant is a double, an expression like speed * 1.5 forces the float variable to be promoted to double, the multiplication to run in double, and the result to be converted back. On a part with only a single-precision FPU, that double arithmetic is done by slow software routines and pulls extra library code into flash.

On the Linux kernel side the rule is even stricter: kernel code must not use floating point at all, because the kernel does not save and restore FPU registers on every entry. Drivers that need fractions use scaled integers, for example storing millivolts in an integer instead of volts in a float.

Common Mistakes and Troubleshooting

Best Practices, Performance and Security

• Default to double on desktops and Linux, float on small MCUs. Choose deliberately and suffix every constant to match.
• Prefer scaled integers for sensor maths in tiny or real-time systems; they are exact and fast.
• Never use floats for money. Use integer cents so that sums are exact.
• Performance: constant expressions such as 3.14159f / 180.0f are evaluated at compile time, so keep them readable instead of pre-computing digits by hand.
• Security and safety: NaN and infinity from divide-by-zero or overflow can propagate silently through control loops. Validate sensor inputs and check with isfinite() before using a result.

Quiz: Floating Point Constants in C

Try each question on paper first. Click a question to reveal the answer.

Interview Questions: Floating Point Constants in C

These come up in embedded and product-company interviews. Answer out loud, then click.

Summary and Key Takeaways

• Floating point constants in C have a point, an exponent, or both; a point is not required if an exponent is present.
• No suffix means double, f means float, L means long double.
• The exponent after e or E must be an integer and moves the decimal point.
• Floating values are approximations; never test them with ==.
• Integer division discards the fraction, so check operand types in mixed expressions.
• On small embedded targets, suffix every float constant with f to avoid costly double promotion.

Conclusion

Floating point constants in C are easy to type and surprisingly easy to misuse. You now know the legal forms, how mantissa and exponent work, what each suffix does, and why stored values are approximations. You also saw the practical side: a missing f can cost real performance in firmware, and comparing with == will eventually fail a test.

Next up are character and string constants, where a quoted letter turns out to be an integer and a quoted word hides an invisible terminator. Experiment first: try %.10f with other fractions like 0.7 and 0.25 and notice which ones are exact.

Frequently Asked Questions