Get number of digits in a base10 integer

Question

It bugged me that std::to_string doesn't allow for custom allocators, so I'm writing my own implementation. For this it would be beneficial to know beforehand how many digits I need to allocate string space for. I could do it in multiple ways:

Use a for loop like demonstrated here:

int length = 1;
int x = 234567545;
while (x /= 10)
   length++;

Use base 10 logarithm + 1:

uint32_t x{234567};
double ds = std::log10(static_cast<double>(x)) + 1;
int digits = static_cast<int>(ds);

.. maybe other solutions.

Here's my code:

Demo

#include <concepts>
#include <cstdio>
#include <string>
#include <memory_resource>
#include <cinttypes>

using allocator_t = std::pmr::polymorphic_allocator<std::byte>;

template <std::integral T>
inline auto to_string(T number, allocator_t allocator = {}) -> std::pmr::string {
    // const std::size_t size = ???
    std::pmr::string str{ size, '\0', allocator };
    if constexpr(std::same_as<T, uint32_t>) {
        std::snprintf(&str.front(), size, "%" PRIu32, number);
    } else if constexpr (std::same_as<T, uint16_t>) {
        std::snprintf(&str.front(), size, "%" PRIu16, number);
    } else if constexpr (std::same_as<T, uint8_t>) {
        std::snprintf(&str.front(), size, "%" PRIu8, number);
    }
    // ...
    return str;
}

int main()
{
    uint32_t x = 256;
    printf("My number = %s\n", to_string(x).data());
}

The question is: What is the most efficient and robust way to get the number of digits of an integral number for this use-case?

Answer 1

I played around with a few options. Calculating the log base 10 was ridiculously slow (30000+ cycles). The first simple loop (while (x /= 10)) you posted was pretty hard to beat, but here's an option which appears to be a bit faster for inputs with several and similar in performance for those with only a few. The idea behind it was that subtraction/comparison is supposed to be much faster than division.

static inline uint8_t uint32digits(const uint32_t input) {
  uint8_t length = 1;
  length += (input >= 1000000000);
  length += (input >= 100000000);
  length += (input >= 10000000);
  length += (input >= 1000000);
  length += (input >= 100000);
  length += (input >= 10000);
  length += (input >= 1000);
  length += (input >= 100);
  length += (input >= 10);
  return length;
}

I counted machine cycles, which I know isn't a great way to benchmark, but it's simple and doesn't fall into the trap of measuring overly optimised code. For single digit numbers I got 104 vs 72 cycles, for 5 digit numbers I got 96 vs 176 cycles, and for 10 digit numbers 96 vs 240 cycles. As expected, my function's cost is pretty independent of the input.

EDIT: Actually, this appears to be a little faster still...

static inline uint8_t mynumdigits(const uint32_t input) {
  return 1 + (input >= 1000000000) + (input >= 100000000) + (input >= 10000000) +
         (input >= 1000000) + (input >= 100000) + (input >= 10000) +
         (input >= 1000) + (input >= 100) + (input >= 10);
}

---

Here's a function template for dealing with all integral types. The only branching here occurs if T is some future type with more than 64 bits or if a signed type is used.

#include <limits>
#include <type_traits>

template <class T>
    requires std::is_unsigned_v<T>
constexpr static inline int intdigits(const T input) {
    int length = 1 + (input >= 10u) + (input >= 100u);

    if constexpr (std::numeric_limits<T>::max() > 0xFF) {
        // T is more than 8 bits
        length += (input >= 1000u) + (input >= 10000u);

        if constexpr (std::numeric_limits<T>::max() > 0xFFFF) {
            // T is more than 16 bits
            length +=
                (input >=       100'000u) +
                (input >=     1'000'000u) +
                (input >=    10'000'000u) +
                (input >=   100'000'000u) +
                (input >= 1'000'000'000u);

            if constexpr (std::numeric_limits<T>::max() > 0xFFFF'FFFF) {
                // T is more than 32 bits
                length +=
                    (input >=             10'000'000'000u) +
                    (input >=            100'000'000'000u) +
                    (input >=          1'000'000'000'000u) +
                    (input >=         10'000'000'000'000u) +
                    (input >=        100'000'000'000'000u) +
                    (input >=      1'000'000'000'000'000u) +
                    (input >=     10'000'000'000'000'000u) +
                    (input >=    100'000'000'000'000'000u) +
                    (input >=  1'000'000'000'000'000'000u) +
                    (input >= 10'000'000'000'000'000'000u);

                if constexpr (std::numeric_limits<T>::max() >
                              0xFFFF'FFFF'FFFF'FFFF)
                {   // T is more than 64 bits - future proofing.
                    // Make the recursive call unconditionally to make
                    // it branchless: 
                    if (input > 0xFFFF'FFFF'FFFF'FFFF)
                        return length - 1 + intdigits(
                            input / 10'000'000'000'000'000'000u);
                }
            }
        }
    }
    return length;
}

template <class T>
    requires std::is_signed_v<T>
constexpr static inline int intdigits(const T input) {
    return intdigits(static_cast<std::make_unsigned_t<T>>(std::abs(input)));
}

Answer 2

After some tinkering I came up with the following solution:

Demo

#include <concepts>
#include <cstdio>
#include <string>
#include <memory_resource>
#include <limits>
#include <type_traits>

using allocator_t = std::pmr::polymorphic_allocator<std::byte>;

template <std::integral T>
constexpr std::size_t get_max_digits()
{
    T val = std::numeric_limits<T>::max();
    std::size_t cnt=1;
    while (val /= 10) {
        ++cnt;
    }
    if constexpr (std::unsigned_integral<T>) {
        return cnt;
    } else {
        return cnt+1;
    }
}

template <typename T> struct PRI{};
template<> struct PRI<signed char> { static constexpr const char* value = "%hhd"; };
template<> struct PRI<unsigned char> { static constexpr const char* value = "%hhu"; };
template<> struct PRI<char> : std::conditional_t<std::is_signed_v<char>, PRI<signed char>, PRI<unsigned char>>{};
template<> struct PRI<short> { static constexpr const char* value = "%hd"; };
template<> struct PRI<unsigned short> { static constexpr const char* value = "%hu"; };
template<> struct PRI<int> { static constexpr const char* value = "%d"; };
template<> struct PRI<unsigned int> { static constexpr const char* value = "%u"; };
template<> struct PRI<long> { static constexpr const char* value = "%ld"; };
template<> struct PRI<unsigned long> { static constexpr const char* value = "%lu"; };
template<> struct PRI<long long> { static constexpr const char* value = "%lld"; };
template<> struct PRI<unsigned long long> { static constexpr const char* value = "%llu"; };

template <typename T>
inline constexpr const char* PRI_v = PRI<T>::value;

template <std::integral T>
inline auto to_string(T number, allocator_t allocator = {}) -> std::pmr::string {
    constexpr std::size_t size = get_max_digits<T>();
    std::pmr::string str{ size, '\0', allocator };
    const std::size_t written_s = std::snprintf(&str.front(), size+1, PRI_v<T>, number);
    str.resize(written_s);
    return str;
}

int main()
{
    int x = -256325651;
    char ch = 'A';
    printf("Integer as string = %s\n", to_string(x).c_str());
    printf("char as string = %s\n", to_string(ch).c_str());
}

Output:

Integer as string = -256325651
char as string = 65

This will work for all major platforms (tested on x86, RISC-V and ARM) and for all common integral types. I decided allocate for the maximum number of digits and downsize to the actually used digits later. This will give me only one allocation syscall and one call to snprintf while the maxdigits calculation can be done at compile time. It should be reasonably fast.