Avoid copy in `to_static_string`

[Flamefire]

Those functions do a snprintf to a temporary buffer and copy that to the result.

Instead the buffer of the resulting static_string could be used directly

[gennaroprota]

Those functions generate the digits in reverse order, and don't know in advance how many digits will be generated, so they start writing from *--end(). If one does the same into the internal buffer of static_string, then characters must be finally moved to the beginning; something like this:

template< std::size_t N, typename Integer >
inline
static_string< N >
to_static_string_int_impl( Integer value ) noexcept
{
  static_string< N > str;
  str.set_size( N );
  const auto digits_end = str.end();
  const auto digits_begin = integer_to_string< std::char_traits< char >, Integer >(
    digits_end, value, std::is_signed< Integer >{} );
  str.set_size( static_cast< std::size_t >( digits_end - digits_begin ) );
  std::memmove( str.data(), digits_begin, str.size() );
  return str;
}

Is that what you have in mind?

[Flamefire]

I was looking at the float impls which is basically:

  char buffer[N + 1];
  std::snprintf(buffer, N + 1, "%f", value)
  return static_string<N>(buffer);

For the int conversion with that reverse-writing I guess memcpy would be faster than the memmove

However currently it ends up calling traits_type::move, i.e. memmove at which point you could do what you suggested above directly which might be better as omitting the buffer could lead to less cache contention. If the optimizer isn't smart enough to elide it anyway.
Or do a direct memcpy in to_static_string_int_impl from the buffer to data()

[gennaroprota]

Fixed with cd1a1a4.