Why Does Floating-Point Arithmetic in C Lead to Precision Issues?

Floating-Point Precision Quirks in C

Floating-point arithmetic in C exhibits behaviors that can be counterintuitive. Consider the following:

The expression double a = 0.3; assigns a value that logically represents 0.3 to the variable a. However, the output of std::cout

Similarly, in the loop where a is repeatedly added to b, the result at the end of the loop (50 iterations) is "15.000000000000014211," which is higher than it should be. This outcome demonstrates how rounding errors can accumulate over multiple operations.

To circumvent these precision issues, it is important to avoid setting the precision of floating-point values higher than the actual precision of the data type. This can be achieved using the following approach:

<code class="cpp">#include <iostream>
#include <limits>

int main() {
    double a = 0.3;
    std::cout.precision(std::numeric_limits<double>::digits10);
    std::cout ::digits10);
    std::cout <p>By setting the precision to the maximum available precision of the double data type, the output will accurately represent the stored values. However, if the loop is run for a significantly larger number of iterations (e.g., 5000 instead of 50), the accumulated error will still become noticeable due to inherent limitations of floating-point arithmetic.</p></double></limits></iostream></code>

The above is the detailed content of Why Does Floating-Point Arithmetic in C Lead to Precision Issues?. For more information, please follow other related articles on the PHP Chinese website!