Float vs Double: Difference in Precision, Range, and Memory

By the end of this page, you will understand what float and double are, how they store decimal numbers, why they differ in precision and range, and when choosing one over the other matters. You will also see practical examples of where they behave similarly and where they produce different results.

float and double are data types used to store floating-point numbers, which are numbers with fractional parts such as 3.14, 0.1, or -12.75.

The main difference is this:

• float usually uses 32 bits of storage
• double usually uses 64 bits of storage

Because double has more bits available, it can usually store:

• more precise values
• larger numbers
• smaller non-zero numbers

In most modern languages and systems, both follow the IEEE 754 floating-point standard:

• float is typically single precision
• double is typically double precision

Why this matters

A floating-point value does not store decimal numbers exactly in many cases. For example, values like 0.1 cannot usually be represented perfectly in binary floating-point.

That means two things:

Think of float and double as two measuring tools:

• float is like a ruler with fewer markings
• double is like a ruler with many finer markings

Both can measure length, and for large, rough measurements they may give results that look the same. But if you need careful, detailed measurement, the ruler with finer markings gives a better answer.

Another way to think about it:

• float is a notebook with fewer pages for storing number details
• double is a notebook with more pages

If the number needs more detail than the smaller notebook can hold, some information gets rounded away.

In C-like languages, the syntax often looks like this:

float price = 19.99f;
double total = 19.99;

Notice the f suffix on the float literal. Without it, a decimal literal is often treated as a double by default.

Basic example

#include <iostream>
#include <iomanip>

int main() {
    float f = 0.1f;
    double d = 0.1;

    std::cout << std::fixed << std::setprecision(20);
    std::cout << "float:  " << f << "\n";
    std::cout << "double: " << d << "\n";
}

Possible output:

float:  0.10000000149011611938
double: 0.10000000000000000555

What this shows

Both values are approximations, not exact decimal .

Consider this example:

#include <iostream>
#include <iomanip>

int main() {
    float f = 1.0f / 3.0f;
    double d = 1.0 / 3.0;

    std::cout << std::fixed << std::setprecision(20);
    std::cout << f << "\n";
    std::cout << d << "\n";
}

Step by step:

1. 1.0f / 3.0f is computed using float precision.
2. The result cannot be represented exactly, so it is rounded to the nearest float value.
3. 1.0 / 3.0 is computed using double precision.
4. This also cannot be represented exactly, but it is rounded to a more precise value because double has more bits.
5. When both values are printed with 20 decimal places, the double output usually shows more correct digits.

Typical output:

float and double are both used in real software, but the choice depends on the problem.

Common uses for double

• General scientific or engineering calculations
• Business logic where fractional values are used but exact decimal arithmetic is not required
• Statistical calculations
• Simulation code
• Most everyday application code

Common uses for float

• Graphics programming, such as 3D coordinates, colors, and shaders
• Large arrays of numeric data where memory matters
• Embedded systems with tighter memory budgets
• Machine learning tensors in some contexts
• Game development, where millions of values may be stored and processed

Example scenarios

• A physics engine may use float for position vectors to reduce memory bandwidth
• A reporting tool may use double for averages and calculations to reduce precision loss
• A file format or GPU API may require 32-bit floating-point values, making float the correct choice

In real codebases, developers often follow a few practical rules.

1. Use double as the default for general calculations

This is common because:

• it reduces accidental precision problems
• modern CPUs handle double efficiently
• it usually makes code more robust

2. Use float when there is a clear reason

Typical reasons include:

• memory savings in large datasets
• compatibility with graphics libraries or hardware
• network or file formats that specify 32-bit floats
• performance tuning on specific platforms

3. Convert at boundaries

A common pattern is to calculate internally with double, then convert to float only when sending data to an API.

double internalValue = 12.345678901234;
float gpuValue = static_cast<float>(internalValue);

4. Validate assumptions when comparing values

Real projects avoid direct equality checks for most floating-point results.

#include <cmath>

{
     std::(a - b) < epsilon;
}

1. Assuming float and double always give the same result

Broken assumption:

float f = 0.1f;
double d = 0.1;

// These are not the same internal value

Avoid this by remembering that both are approximations, but double is usually more precise.

2. Comparing floating-point values with ==

Broken code:

#include <iostream>

int main() {
    double a = 0.1 + 0.2;
    if (a == 0.3) {
        std::cout << "Equal\n";
    }
}

This may fail because of representation error.

Better:

#include <cmath>

bool nearlyEqual {
     std::(a - b) < epsilon;
}

float vs double in practice

• float usually = 32-bit IEEE 754 single precision
• double usually = 64-bit IEEE 754 double precision
• float precision: about 6–7 significant decimal digits
• double precision: about 15–16 significant decimal digits
• double is usually the safer default
• float uses less memory
• Many decimal values like 0.1 are not exactly representable in either type
• Avoid == for computed floating-point values
• Use an epsilon comparison for approximate equality
• In C/C++, decimal literals like 3.14 are usually double
• Use 3.14f for a float literal
• float may lose small changes when numbers are already large
• For money, prefer fixed-point or decimal approaches when exactness is required

Quick syntax

float f = 1.23f;
double d = 1.23;

Approximate comparison

Is double always better than float?

Not always. double is usually better for precision, but float is useful when memory, bandwidth, or API compatibility matters.

Why do float and double sometimes print the same value?

Because the difference may be too small to show with default formatting, or the number may be exactly representable in both types.

Can float and double both have rounding errors?

Yes. Both are floating-point types, so many decimal values are stored approximately.

Should I use float or double in C++?

Use double by default unless you have a specific reason to use float, such as memory limits or a graphics API requirement.

Why is 0.1 + 0.2 != 0.3 sometimes true?

Because numbers like 0.1 and 0.2 are usually not represented exactly in binary floating-point, so the result is only approximately .

• IEEE 754 floating-point standard — defines how floating-point numbers are commonly stored and computed.
• Significant digits — helps explain what precision really means.
• Rounding error — shows why results may differ from exact mathematics.
• Type conversion — important when moving between float, double, and other numeric types.
• Integer vs floating-point types — useful for understanding when fractions are allowed.
• Approximate equality — important for comparing floating-point values safely.
• Fixed-point arithmetic — a common alternative when exact decimal behavior is required.
• Numeric overflow and underflow — related to the range limits of floating-point types.