printf int to char array with left padded spaces - c++

Question

I have a bit of a brain dead moment.
I have to store the string representation of an int to a char[], but the ascii representation will have to be left padded by spaces.
A snprintf will do the job.
char data [6];
int msg_len = 10;
std::snprintf(data, 6, "%*d", 5, msg_len);
//" 10" <-- OK
I just wonder if there is a more elegant way to do it.
I have access to C++11
Also there's a a bit of a problem, I think snprintf will add also a terminating character, and I have to avoid that.
I could have an intermediary buffer and copy that one into my data, but it would add additional complexity.
I need to do it in place, because those data structures are part of a message I have to send to a server that accepts input formatted that way.
The message looks like:
struct
{
char first_field [6];
char second_field [8];
char data_field [12];
};
And I might need to set the second_field before having set the first one. Also I have a lot more fields to fill in, so a generic solution would be appreciated.
As long as I can convert an int to that string representation would be fine.

Answer 1

this can be achived by combination of std::ostringstream, and io manipulators, such as: std::setfill, std::setw and other:
std::ostringstream s;
s << std::setfill('0') << std::setw(7) << 1015;
std::string str = s.str();
std::cout << str << std::endl; // outputs "0001015"

Answer 2

Within your indicated constraints this may improve on your own answer:
#include <algorithm>
#include <cstddef>
#include <cassert>
inline void
unsigned_to_decimal( unsigned long number, char* buffer, std::size_t size)
{
std::size_t i = size;
buffer[size - 1] = '0';
for (unsigned long n ;(n = number) > 0 && i > 0 ;) {
buffer[--i] = '0' + n - (10 * (number /= 10));
}
assert(number == 0);
std::fill(buffer,buffer + (i - (i == size)),' ');
}
For a demo, append:
#include <iostream>
#include <string>
#include <climits>
#include <array>
constexpr std::size_t decimal_digits(unsigned long n)
{
return n / 10 > 0 ? 1 + decimal_digits(n / 10) : 1;
}
int main()
{
const std::size_t max_digits = decimal_digits(ULONG_MAX);
std::cout << "Print decimal 0, UINT_MAX, ULONG_MAX "
"from left-padded char buffer, size " << max_digits << ":-\n";
for (auto ul : std::array<unsigned long,3>{0,UINT_MAX,ULONG_MAX}) {
char buf[max_digits];
std::fill(buf,buf + max_digits,'?');
std::cout << '[' << std::string(buf,buf + max_digits) << "]\n";
unsigned_to_decimal(ul,buf,max_digits);
std::cout << '[' << std::string(buf,buf + max_digits) << "]\n";
}
return 0;
}
which runs like:
Print decimal 0, UINT_MAX, ULONG_MAX from left-padded char buffer, size 20:-
[????????????????????]
[ 0]
[????????????????????]
[ 4294967295]
[????????????????????]
[18446744073709551615]
(g++ -Wall -std=c++11 -pedantic, GCC 5.3.1)

Answer 3

I just wonder if there is a more elegant way to do it.
Andrei R. already showed an elegant way, so I won't repeat it, but I'll answer your other questions.
Also there's a a bit of a problem, I think snprintf will add also a terminating character, and I have to avoid that.
There is no way to avoid writing null with snprintf.
I could have an intermediary buffer and copy that one into my data, but it would add additional complexity.
That is the typical way to achieve what you want. This approach can also be taken using the result from std::ostringstream as the intermediary buffer.
Depending on what you intend to use the non null terminated string for, there might be approaches.

Answer 4

For those interested I rolled out my own simplistic solution, which fits my needs for now.
I only handle unsigned values and no locale, but it works for what I need to do.
inline void unsigned_to_decimal( unsigned long number, char* buffer, std::size_t size)
{
char* start = buffer;
char* end = buffer + size;
if(number == 0)
{
*buffer++ = '0';
}
else
{
while( number != 0 )
{
*buffer++ = '0' + number % 10;
number /= 10;
}
std::reverse( start, buffer );
//need to fill the remaining characters with spaces
std::fill(buffer, end, ' ');
std::rotate(start, start + std::distance(start, buffer), end);
}
}