std::numeric_limits<T>::max_digits10

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Diagnostics library

Memory management library

Metaprogramming library (C++11)

General utilities library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Strings library

Text processing library

Numerics library

Date and time library

Input/output library

Filesystem library (C++17)

Concurrency support library (C++11)

Execution control library (C++26)

Technical specifications

Symbols index

External libraries

 

Utilities library

Language support Type support (basic types, RTTI) Library feature-test macros (C++20) Program utilities Variadic functions initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) Coroutine support (C++20) Contract support (C++26) Three-way comparison three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

General utilities Function objects Bit manipulation (C++20) bitset hash (C++11) Relational operators (deprecated in C++20) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Integer comparison functions cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Swap and type operations swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Common vocabulary types pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

Type support

Basic types
Fixed width integer types (C++11)
Fixed width floating-point types (C++23)
ptrdiff_t size_t max_align_t (C++11)     byte (C++17)	nullptr_t (C++11) offsetof NULL
Numeric limits
numeric_limits
C numeric limits interface
Runtime type information
type_info type_index (C++11)	bad_typeid bad_cast

 

std::numeric_limits

Static constants

numeric_limits::is_specialized

numeric_limits::is_signed

numeric_limits::is_integer

numeric_limits::is_exact

numeric_limits::has_infinity

numeric_limits::has_quiet_NaN

numeric_limits::has_signaling_NaN

numeric_limits::has_denorm

numeric_limits::has_denorm_loss

numeric_limits::round_style

numeric_limits::is_iec559

numeric_limits::is_bounded

numeric_limits::is_modulo

numeric_limits::digits

numeric_limits::digits10

numeric_limits::max_digits10 (C++11)

numeric_limits::radix

numeric_limits::min_exponent

numeric_limits::min_exponent10

numeric_limits::max_exponent

numeric_limits::max_exponent10

numeric_limits::traps

numeric_limits::tinyness_before

Static member functions

numeric_limits::min

numeric_limits::lowest (C++11)

numeric_limits::max

numeric_limits::epsilon

numeric_limits::round_error

numeric_limits::infinity

numeric_limits::quiet_NaN

numeric_limits::signaling_NaN

numeric_limits::denorm_min

Helper types

float_round_style

float_denorm_style

 

static constexpr int max_digits10		(since C++11)

See More

The value of std::numeric_limits<T>::max_digits10 is the number of base-10 digits that are necessary to uniquely represent all distinct values of the type T, such as necessary for serialization/deserialization to text. This constant is meaningful for all floating-point types.

Standard specializations

T	Value of std::numeric_limits<T>::max_digits10
/* non-specialized */	0
bool	0
char	0
signed char	0
unsigned char	0
wchar_t	0
char8_t (since C++20)	0
char16_t	0
char32_t	0
short	0
unsigned short	0
int	0
unsigned int	0
long	0
unsigned long	0
long long	0
unsigned long long	0
float	FLT_DECIMAL_DIG or std::ceil(std::numeric_limits<float>::digits * std::log10(2) + 1)
double	DBL_DECIMAL_DIG or std::ceil(std::numeric_limits<double>::digits * std::log10(2) + 1)
long double	DECIMAL_DIG or LDBL_DECIMAL_DIG or std::ceil(std::numeric_limits<long double>::digits * std::log10(2) + 1)

Notes

Unlike most mathematical operations, the conversion of a floating-point value to text and back is exact as long as at least max_digits10 were used (9 for float, 17 for double): it is guaranteed to produce the same floating-point value, even though the intermediate text representation is not exact. It may take over a hundred decimal digits to represent the precise value of a float in decimal notation.

Example

Run this code

#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <sstream>

int main()
{
    float value = 10.0000086;

    constexpr auto digits10 = std::numeric_limits<decltype(value)>::digits10;
    constexpr auto max_digits10 = std::numeric_limits<decltype(value)>::max_digits10;
    constexpr auto submax_digits10 = max_digits10 - 1;

    std::cout << "float:\n"
                 "       digits10 is " << digits10 << " digits\n"
                 "   max_digits10 is " << max_digits10 << " digits\n"
                 "submax_digits10 is " << submax_digits10 << " digits\n\n";

    const auto original_precision = std::cout.precision();
    for (auto i = 0; i < 5; ++i)
    {
        std::cout
            << "   max_digits10: " << std::setprecision(max_digits10) << value << "\n"
               "submax_digits10: " << std::setprecision(submax_digits10) << value
            << "\n\n";
 
        value = std::nextafter(value, std::numeric_limits<decltype(value)>::max());
    }
    std::cout.precision(original_precision);
}

Output:

float:
       digits10 is 6 digits
   max_digits10 is 9 digits
submax_digits10 is 8 digits

   max_digits10: 10.0000086
submax_digits10: 10.000009

   max_digits10: 10.0000095
submax_digits10: 10.00001

   max_digits10: 10.0000105
submax_digits10: 10.00001

   max_digits10: 10.0000114
submax_digits10: 10.000011

   max_digits10: 10.0000124
submax_digits10: 10.000012

See also

radix [static]	the radix or integer base used by the representation of the given type (public static member constant)
digits [static]	number of radix digits that can be represented without change (public static member constant)
digits10 [static]	number of decimal digits that can be represented without change (public static member constant)
min_exponent [static]	one more than the smallest negative power of the radix that is a valid normalized floating-point value (public static member constant)
max_exponent [static]	one more than the largest integer power of the radix that is a valid finite floating-point value (public static member constant)