In our daily programming, numerical calculations are commonplace, especially when it comes to decimals. However, have you ever encountered such a“supernatural event”: a simple floating-point operation yields unexpected deviations, such as missing 0.1 or having an extra 0.000001? This is not magic, but rather the “pitfalls” of floating-point precision loss in C language!

Today, Teacher Frank will take everyone on an in-depth exploration of this headache-inducing issue for countless beginners, revealing how to correctly understand and handle floating-point precision problems. He will also introduce the scientific notation and hexadecimal floating-point output methods introduced in the C99 standard, giving you a more comprehensive understanding of floating-point numbers!

01

Why Does Floating-Point Precision Loss Occur?

The “binary” world of computers

To understand floating-point precision loss, we must first grasp how computers store data. All data within a computer, whether integers, characters, or floating-point numbers, is ultimately converted into binary form for storage and processing. The binary system, which is base two, is fundamentally different from the decimal system we use daily.

The problem lies here: not all decimal fractions can be precisely converted into finite binary fractions.

Take the simplest example, the decimal 0.1. In decimal, it is a finite decimal. But if you try to convert it to binary, you will find it becomes an infinite repeating decimal! This is similar to how 1/3 in decimal equals 0.3333… (infinite repeating).

The “helplessness” of float single precision

When we assign a decimal infinite repeating decimal (like 0.1 or 0.00001 in binary representation) to a variable of type float (single precision floating-point), due to the limited storage space of float (usually 32 bits), it cannot fully store this infinite repeating binary decimal and can only perform truncation.

The consequence of truncation is: the float variable will store an approximate value, rather than an exact value. This is why you might see 0.0000000000000001 as a tiny deviation.

Example Code and In-Depth Understanding:

Let’s intuitively feel this through a simple example:

#include <stdio.h>int main() {    float num = 0.1f; // Note the f suffix here!    printf("Original floating-point number: %.2f\n", num);  // Keep two decimal places    printf("Keep 20 decimal places: %.20f\n", num); // Keep 20 decimal places    return 0;}

The output may look like:

原始浮点数：0.10保留20位小数：0.10000000149011611938

From the output, we can clearly see that when we try to print 0.1f with higher precision, it is not exactly 0.1, but an approximate value with a string of trailing digits. This is a direct manifestation of float precision loss.

Professional Correction and Supplement: The F or f suffix of float variables

When defining floating-point constants of type float, we must add an f or F suffix after the number, such as 0.1f or 0.1F.

Why?

This is a requirement of the C language. Floating-point constants without a suffix (like 0.1) are by default treated as double (double precision floating-point) in C. If a double type constant is directly assigned to a float variable, the compiler will perform an implicit type conversion, but this may still lead to precision issues. By explicitly adding the f or F suffix, we inform the compiler that this is a float type constant, avoiding unnecessary type conversions and reminding programmers that this value may have precision issues.

Whether it is f or F, the effect is completely the same; you can choose one based on personal preference or team coding standards and maintain consistency.

02

Double Precision Floating-Point Number double: Higher Precision, but Not Omnipotent

Since float loses precision, is there a more precise type? Of course! The C language provides the double type, which is double precision floating-point.

The double type typically occupies 64 bits of storage space, which is twice that of float’s 32 bits, thus providing a higher precision range.

Let’s modify the previous example to double type:

#include <stdio.h>int main() {    double num = 0.1; // No suffix needed for double type constant    printf("Original floating-point number (double): %.2f\n", num);    printf("Keep 20 decimal places (double): %.20f\n", num);    return 0;}

The output may look like:

原始浮点数（double）：0.10保留20位小数（double）：0.10000000000000000555

You will find that the precision of double is indeed much higher than that of float, but upon closer inspection, even with double, 0.1 is still notcompletely accurate. This means that while double can significantly reduce precision loss issues, it does not completely solve all floating-point precision problems.

Application Scenario Tips:

• Float Single Precision: Suitable for scenarios where precision is not critical, or where a large number of floating-point operations are needed to save memory and computational resources (such as graphics, game development).

• Double Double Precision: Suitable for scenarios requiring higher precision, or for extensive financial and scientific calculations (such as banking systems, physical simulations). In most general programming, to avoid precision issues, double is the more recommended choice.

03

C99 Standard: New Ways to Output Floating-Point Numbers—Scientific Notation and Hexadecimal Floating-Point

In addition to the common floating-point output format %f, the C99 standard (and even earlier C89/C90 standards had %e and %E) and subsequent standards like C11 introduced more flexible output methods for floating-point numbers, among which the most commonly used are scientific notation and hexadecimal floating-point representation.

1. Scientific Notation: %e and %E

Scientific notation is a convenient way to represent extremely large or small numbers. In C language, you can use the %e or %E format specifier to output the scientific notation representation of floating-point numbers.

• %e: Outputs scientific notation with a lowercase e (e.g., 1.2345e+002).

• %E: Outputs scientific notation with an uppercase E (e.g., 1.2345E+002).

They are functionally identical except for the case of the letters.

2. Hexadecimal Floating-Point: %a and %A (P-notation)

This is a feature introduced in the C99 standard, which represents floating-point numbers in hexadecimal form. This representation method is commonly referred to as P-notation, which can more accurately reflect the binary representation of floating-point numbers in memory.

• %a: Outputs hexadecimal floating-point with lowercase a and p (e.g., 0x1.92p+1).

• %A: Outputs hexadecimal floating-point with uppercase A and P (e.g., 0X1.92P+1).

Note: Not all systems fully support %a and %A formats, but they are usually available in modern compilers and environments.

Example Code:

#include <stdio.h>int main() {    float number = 123.456f; // Test floating-point number    // Normal floating-point output    printf("Using %%f: %.6f\n", number);    // Scientific notation output    printf("Using %%e: %.6e\n", number); // lowercase e    printf("Using %%E: %.6E\n", number); // uppercase E    // Hexadecimal floating-point output (C99 standard)    printf("Using %%a: %a\n", number);   // lowercase a and p    printf("Using %%A: %A\n", number);   // uppercase A and P    return 0;}

The output may look like:

Using %f: 123.456001Using %e: 1.234560e+002Using %E: 1.234560E+002Using %a: 0x1.edae14p+6Using %A: 0X1.EDAE14P+6

Little Tip: How to Output a Percentage % in printf?

In the printf function, the % symbol is used to introduce format specifiers. If you want to directly print a percentage sign in the output, you need to use double percentage signs %%.

For example:

#include <stdio.h>int main() {    printf("Print a percentage sign: 100%%\n"); // Output "Print a percentage sign: 100%"    return 0;}

04

Summary and Elevation

Floating-point precision loss is an unavoidable topic in the C language, and understanding the underlying binary storage principles is crucial. Although the double type provides higher precision, we must always remember: in floating-point operations, precise comparisons and avoiding cumulative errors is a complex issue, often requiring specialized mathematical libraries or fixed-point arithmetic to resolve.

At the same time, the output formats provided by the C language, such as %e/%E and %a/%A, also offer us more dimensions for observing and debugging floating-point numbers. Mastering this knowledge will make your C language code more robust and professional!