std::numeric_limits::digits10(3)

NAME
std::numeric_limits::digits10 - std::numeric_limits::digits10

Synopsis
   static const int digits10; (until C++11)
   static constexpr int digits10; (since C++11)
   The value of std::numeric_limits<T>::digits10 is the number of base-10 digits that
   can be represented by the type T without change, that is, any number with this many
   significant decimal digits can be converted to a value of type T and back to decimal
   form, without change due to rounding or overflow. For base-radix types, it is the
   value of digits() (digits - 1 for floating-point types) multiplied by \(\small
   \log_{10}{radix}\)log
   10(radix) and rounded down.

Standard specializations
   T value of std::numeric_limits<T>::digits10
   /* non-specialized */ 0
   bool 0
   char std::numeric_limits<char>::digits * std::log10(2)
   signed char std::numeric_limits<signed char>::digits * std::log10(2)
   unsigned char std::numeric_limits<unsigned char>::digits * std::log10(2)
   wchar_t std::numeric_limits<wchar_t>::digits * std::log10(2)
   char8_t (since C++20) std::numeric_limits<char8_t>::digits * std::log10(2)
   char16_t (since C++11) std::numeric_limits<char16_t>::digits * std::log10(2)
   char32_t (since C++11) std::numeric_limits<char32_t>::digits * std::log10(2)
   short std::numeric_limits<short>::digits * std::log10(2)
   unsigned short std::numeric_limits<unsigned short>::digits *
                        std::log10(2)
   int std::numeric_limits<int>::digits * std::log10(2)
   unsigned int std::numeric_limits<unsigned int>::digits * std::log10(2)
   long std::numeric_limits<long>::digits * std::log10(2)
   unsigned long std::numeric_limits<unsigned long>::digits * std::log10(2)
   long long (since C++11) std::numeric_limits<long long>::digits * std::log10(2)
   unsigned long long (since std::numeric_limits<unsigned long long>::digits *
   C++11) std::log10(2)
   float FLT_DIG (6 for IEEE float)
   double DBL_DIG (15 for IEEE double)
   long double LDBL_DIG (18 for 80-bit Intel long double; 33 for IEEE
                        quadruple)

Example
   An 8-bit binary type can represent any two-digit decimal number exactly, but 3-digit
   decimal numbers 256..999 cannot be represented. The value of digits10 for an 8-bit
   type is 2 (8 * std::log10(2) is 2.41)
   The standard 32-bit IEEE 754 floating-point type has a 24 bit fractional part (23
   bits written, one implied), which may suggest that it can represent 7 digit decimals
   (24 * std::log10(2) is 7.22), but relative rounding errors are non-uniform and some
   floating-point values with 7 decimal digits do not survive conversion to 32-bit
   float and back: the smallest positive example is 8.589973e9, which becomes
   8.589974e9 after the roundtrip. These rounding errors cannot exceed one bit in the
   representation, and digits10 is calculated as (24 - 1) * std::log10(2), which is
   6.92. Rounding down results in the value 6.
   Likewise, the 16-digit string 9007199254740993 does not survive text->double->text
   roundtrip, becoming 9007199254740992: the 64-bit IEEE 754 type double guarantees
   this roundtrip only for 15 decimal digits.

See also
   max_digits10 number of decimal digits necessary to differentiate all values of
   [static] (C++11) this type
                    (public static member constant)
   radix the radix or integer base used by the representation of the given
   [static] type
                    (public static member constant)
   digits number of radix digits that can be represented without change
   [static] (public static member constant)
   min_exponent one more than the smallest negative power of the radix that is a
   [static] valid normalized floating-point value
                    (public static member constant)
   max_exponent one more than the largest integer power of the radix that is a
   [static] valid finite floating-point value
                    (public static member constant)