C Standard Library float.h

What You’ll Learn

The <float.h> header defines macros that describe the limits and precision of float, double, and long double on your platform. Instead of guessing how big a float can get or how many decimal digits are reliable, you read constants like FLT_MAX and DBL_EPSILON at compile time.

Definition and Usage

Floating-point numbers cannot represent every real value exactly. They have a finite range (minimum and maximum magnitude) and finite precision (how many significant digits you can trust). <float.h> exposes those properties as preprocessor macros so your code adapts to the compiler and CPU.

Macros are grouped by type prefix: FLT_ for float, DBL_ for double, and LDBL_ for long double. The most commonly used are *_MAX, *_MIN, *_EPSILON, and *_DIG.

📝 Syntax

Include the header:

#include <float.h>

Essential float macros

• FLT_MAX — largest finite positive float.
• FLT_MIN — smallest positive normalized float.
• FLT_EPSILON — smallest float where 1.0f + FLT_EPSILON != 1.0f.
• FLT_DIG — decimal digits of precision you can round-trip through text.
• FLT_MANT_DIG — bits in the significand (mantissa).
• FLT_MIN_EXP / FLT_MAX_EXP — exponent range.

Essential double macros

• DBL_MAX, DBL_MIN, DBL_EPSILON, DBL_DIG
• DBL_MANT_DIG, DBL_MIN_EXP, DBL_MAX_EXP

Essential long double macros

• LDBL_MAX, LDBL_MIN, LDBL_EPSILON, LDBL_DIG
• LDBL_MANT_DIG, LDBL_MIN_EXP, LDBL_MAX_EXP

Other useful macros

• FLT_RADIX — radix of the exponent representation (usually 2).
• DECIMAL_DIG — decimal digits needed to round-trip any floating type to text and back.
• FLT_TRUE_MIN (C11) — smallest positive float, including subnormals.

Headers and linking

• #include <float.h> — macros only, no link flag needed.
• Pair with <math.h> for fabs, sqrt, etc. (-lm on GCC).
• Compile: gcc program.c -std=c11 -o program

Examples Gallery

Compile with gcc file.c -std=c11 -o out. Add -lm when using fabs from <math.h>. Output values depend on your platform; samples below match typical GCC on x86-64.

#include <stdio.h>
#include <float.h>

int main(void) {
    printf("=== float ===\n");
    printf("FLT_MAX:     %e\n", (double)FLT_MAX);
    printf("FLT_MIN:     %e\n", (double)FLT_MIN);
    printf("FLT_EPSILON: %e\n", (double)FLT_EPSILON);
    printf("FLT_DIG:     %d\n", FLT_DIG);

    printf("\n=== double ===\n");
    printf("DBL_MAX:     %e\n", DBL_MAX);
    printf("DBL_MIN:     %e\n", DBL_MIN);
    printf("DBL_EPSILON: %e\n", DBL_EPSILON);
    printf("DBL_DIG:     %d\n", DBL_DIG);

    printf("\n=== long double ===\n");
    printf("LDBL_MAX:     %Le\n", LDBL_MAX);
    printf("LDBL_MIN:     %Le\n", LDBL_MIN);
    printf("LDBL_EPSILON: %Le\n", LDBL_EPSILON);
    printf("LDBL_DIG:     %d\n", LDBL_DIG);

    return 0;
}

=== float ===
FLT_MAX:     3.402823e+38
FLT_MIN:     1.175494e-38
FLT_EPSILON: 1.192093e-07
FLT_DIG:     6

=== double ===
DBL_MAX:     1.797693e+308
DBL_MIN:     2.225074e-308
DBL_EPSILON: 2.220446e-16
DBL_DIG:     15

=== long double ===
LDBL_MAX:     1.189731e+4932
LDBL_MIN:     3.362103e-4932
LDBL_EPSILON: 1.084202e-19
LDBL_DIG:     18

#include <float.h>
#include <stdio.h>

int main(void) {
    float a = 1.0f;
    float b = 1.0f + FLT_EPSILON;
    float c = 1.0f + FLT_EPSILON / 2.0f;

    printf("1.0f + FLT_EPSILON     = %.9f  (different: %s)\n",
           b, (a != b) ? "yes" : "no");
    printf("1.0f + FLT_EPSILON/2   = %.9f  (different: %s)\n",
           c, (a != c) ? "yes" : "no");

    return 0;
}

1.0f + FLT_EPSILON     = 1.000000119  (different: yes)
1.0f + FLT_EPSILON/2   = 1.000000000  (different: no)

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

int approx_equal(double a, double b) {
    return fabs(a - b) <= DBL_EPSILON * 10.0;
}

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

    printf("x = %.17f\n", x);
    printf("y = %.17f\n", y);
    printf("x == y:        %s\n", (x == y) ? "true" : "false");
    printf("approx_equal:  %s\n", approx_equal(x, y) ? "true" : "false");

    return 0;
}

x = 0.30000000000000004
y = 0.30000000000000004
x == y:        false
approx_equal:  true

#include <float.h>
#include <stdio.h>

int safe_multiply(float a, float b, float *out) {
    if (a != 0.0f && b > FLT_MAX / a) {
        return -1;  /* would overflow */
    }
    *out = a * b;
    return 0;
}

int main(void) {
    float result;
    float big = FLT_MAX / 2.0f;

    if (safe_multiply(big, 3.0f, &result) != 0) {
        printf("Overflow avoided: product too large for float\n");
    } else {
        printf("Result: %e\n", result);
    }

    return 0;
}

Overflow avoided: product too large for float

#include <float.h>
#include <stdio.h>

int main(void) {
    printf("Radix (usually 2):     %d\n", FLT_RADIX);
    printf("float  decimal digits: %d (FLT_DIG)\n", FLT_DIG);
    printf("double decimal digits: %d (DBL_DIG)\n", DBL_DIG);
    printf("DECIMAL_DIG (widest):  %d\n", DECIMAL_DIG);

    printf("\nUse float for ~%d significant digits; double for ~%d.\n",
           FLT_DIG, DBL_DIG);

    return 0;
}

Radix (usually 2):     2
float  decimal digits: 6 (FLT_DIG)
double decimal digits: 15 (DBL_DIG)
DECIMAL_DIG (widest):  21

Use float for ~6 significant digits; double for ~15.

🚀 Common Use Cases

• Overflow prevention — guard multiplies and exponentials with FLT_MAX / DBL_MAX.
• Fuzzy comparisons — use *_EPSILON instead of == for floats.
• Formatted output — limit printf precision with FLT_DIG or DECIMAL_DIG.
• Memory vs precision — pick float arrays when FLT_DIG is enough.
• Unit tests — assert results within epsilon of expected values.
• Cross-platform libraries — never hard-code IEEE 754 constants; read macros.

📝 Notes

• Macro values are implementation-defined—print them once on your target platform if unsure.
• FLT_MIN is the smallest normalized positive value; subnormals can be smaller.
• *_EPSILON is defined around 1.0; tolerance for large numbers may need scaling.
• long double size varies: 80-bit, 128-bit, or same as double on some compilers.
• Floating literals like 3.14 are double unless suffixed with f or L.
• For integer limits, see <limits.h>; for math functions, see <math.h>.

⚡ Optimization

float uses half the memory of double and can be faster on SIMD or embedded hardware. Use FLT_DIG to confirm six digits is enough before switching. Macros themselves have zero runtime cost—they are resolved at compile time.

💡 Best Practices