Width to fit any value of an unsigned (natural) number

Question

Background

I have a logging system that outputs records to a std::ostream. Each record is annotated with a counter that is increased by one with each output, like this:

=====  Batch # 5  =====
  This is the fifth record
=====  Batch # 19  =====
  This is the nineteenth record
=====  Batch # 187  =====
  Who knows to spell *that*?

The counter is a std::size_t, i.e., an unsigned integer.

Problem

As it is now, numbers are outputted without any padding, which looks ugly. I would like to achieve this:

=====  Batch #     5  =====
  This is the fifth record
=====  Batch #    19  =====
  ...
=====  Batch #   187  =====
=====  Batch # 12345  =====

Making the stream object handle this can be achieved with std::setw. However, I still need to know how many digits takes the base-10 representation of the maximum possible value.

Request

The solution must compute statically (i.e. at translation-time) how many digits takes the base-10 representation of the maximum possible value of a std::size_t. I will welcome any method that meets this requirement, although I will prefer those that employ C++14's (relaxed) constexprs.

Hints and things I have tried

It seems that the representation of a natural number N in base-B takes as many digits as the truncation of (the B-index logarithm of N) plus 1. For example, the value 100 is three digits long in base 10, and the common logarithm of 100 plus 1 is 3; the value 1234 is four digits long in base 10, and the truncation of (the common logarithm of 1234) plus 1 is 4. In pseudo-something:

digits( value , base ) = floor( logarithm( radicand=value , index=base ) ) + 1

I apologize for the lazyness of the explanation and the formatting; if someone knows a better way, please, feel free to edit my post or to suggest it. You can try this here. It seems to work, but I haven't thoroughly verified it.

As for the maximum value a std::size_t object can hold, it is std::numeric_limits<std::size_t>::max().

---

I intend to answer this question. I will give some time before posting my answer, and wait more before accepting any.

Answer 1

Seems that std::numeric_limits::digits10 is what you want. live example

Answer 2

The C++ Standard Library provides the std::numeric_limits class template, which may be used to query various properties of arithmetic types. Among them is the number of base-10 digits that can be represented by each type, which is encoded in the digits10 static member, a constexpr int. However, and as outlined by Martin Ba in his comments, it is necessary to add 1. Do this:

template<class T>
constexpr int maximum_base10_digits =
    std::numeric_limits<T>::digits10 + 1;

It will also ensure that the value is computed at translation-time (if you simply pass the value to, say, std::setw, the addition could be performed at runtime... a terrible slowdown!).

Although the corresponding cppreference.com page does not list any specialization for std::size_t, it is not a problem, as stood out in the std::numeric_limits page linked above:

The standard library types that are aliases of arithmetic types (such as std::size_t or std::streamsize) may also be examined with the std::numeric_limits type traits.

Additionally, this approach has been available since C++11 (or C++98, if you are willing to drop the constexpr), which makes it compatible with many more C++ implementations. Just don't make it a variable template if there's no C++14.

#include <cstddef>
#include <iomanip>
#include <iostream>
#include <limits>


namespace
{
    template<typename T>
    void
    pretty_print
    (
     const T value
    )
    {
        // Ensure that it's computed at compile-time
        constexpr int maximum_digits = std::numeric_limits<T>::digits10 + 1;

        std::cout << std::setw( maximum_digits ) << value << '\n';
    }
}

int
main
( )
{
    pretty_print( std::size_t{ 7 } );
    pretty_print( std::numeric_limits<std::size_t>::max() );
}

As a side note, do not get confused with the C++11 addition std::numeric_limits::max_digits10 (see this question). If you have a look at the list of specializations provided by the Standard Library, you'll note that its value is 0 for all integer types.