Floating point precision in C++

Floating point numbers in C++ (and most other languages) are often approximations due to the way they're represented in binary. This can lead to some surprising results.

In C++, float and double types are typically implemented as IEEE 754 floating point numbers. These numbers are represented in binary with a fixed number of bits for the mantissa (the fraction part) and the exponent.

Because of this fixed size representation, not all decimal numbers can be represented exactly in binary. For example, 0.1 in decimal is a repeating fraction in binary (just like how 1/3 is a repeating decimal in base 10). The binary representation of 0.1 is cut off at some point, leading to a slight inaccuracy.

Here's a famous example of this inaccuracy:

1#include <iostream>
2
3int main() {
4  double a = 0.1;
5  double b = 0.2;
6  double c = a + b;
7
8  std::cout << std::boolalpha;
9
10  // Outputs "false"
11  std::cout << (c == 0.3);
12}

1false

In this case, a + b is not exactly equal to 0.3 due to the imprecision in the binary representations of 0.1 and 0.2.

To handle this, you usually want to avoid comparing floating point numbers directly for equality. Instead, check if the difference between the numbers is less than some small threshold value (often called an epsilon):

1#include <iostream>
2#include <cmath>
3
4bool almost_equal(double a, double b,
5  double epsilon = 1e-8) {
6  return std::abs(a - b) < epsilon;
7}
8
9int main() {
10  double a = 0.1;
11  double b = 0.2;
12  double c = a + b;
13
14  std::cout << std::boolalpha;
15
16  // Outputs "true"
17  std::cout << almost_equal(c, 0.3);
18}

1true

Another way to handle this is to use integer types for arithmetic when possible (if you're dealing with fixed-point numbers, for example), or to use a decimal library for financial calculations where exact decimal representations are crucial.

It's also worth noting that double has more precision than float (usually 64 bits vs 32 bits), so it can represent numbers more accurately. But it still suffers from the same fundamental issue of not being able to exactly represent all decimal numbers.