Question

I need to generate a path string from a number (in C)

e.g:

53431453 -> 0003/2F4/C9D

what I have so far is this:

char *id_to_path(long long int id, char *d)
{
    char t[MAX_PATH_LEN];
    sprintf(t, "%010llX", id);

    memcpy(d,   t,   4);
    memcpy(d+5, t+4, 3);
    memcpy(d+9, t+7, 4);

    d[4] = d[8] = '/';

    return d;
}

I’m wondering if there’s a better way, e.g to generate the final string in one step instead of doing sprintf and then moving the bytes around.

Thanks

Edit:

I benchmarked the given solutions

results in operations per second (higher is better):

(1) sprintf + memcpy  : 3383005
(2) single sprintf    : 2219253 
(3) not using sprintf : 10917996

when compiling with -O3 the difference is even greater:

(1) 4422101
(2) 2207157
(3) 178756551

Since this function will be called a lot, I’ll use the fastest solution even though the single sprintf is the shortest and most readable.

Thanks for your answers!

Answer 1

Since the string uses hex, it can be quite easily done using shift and bit operators.

Getting the 4 highest bits from the value can be done like this:

id >> 28

Converting this to a digit simply means adding the character ‘0’ to it, like this:

'0' + (id >> 28)

However, since A, B, C, … don’t immediately follow the character 9, we have to perform an additional check, something like:

if (c > '9') c = c - '9' - 1 'A'

If we want the next 4 bits, we should only shift 24 bits, but then we still have the highest 4 bits left, so we should mask them out, like this:

(id >> 24) & 0xf

If we pour this into your function, we get this:

char convert (int value)
{
char c = value + '0';
if (c > '9') c = c - '9' - 1 + 'A';
return c;
}

void main()
{
long id = 53431453;
char buffer[20];

buffer[0] = convert(id >> 28);
buffer[1] = convert((id >> 24) & 0xf);
buffer[2] = convert((id >> 20) & 0xf);
buffer[3] = convert((id >> 16) & 0xf);
buffer[4] = convert((id >> 12) & 0xf);
buffer[5] = convert((id >>  8) & 0xf);
buffer[6] = convert((id >>  4) & 0xf);
buffer[7] = convert((id >>  0) & 0xf);
buffer[8] = '\0';
}

Now adjust this to add the slashes in between, the extra zeroes in the beginning, …

EDIT:
I know this is not in one step, but it is better extensible if you later want to change the places of the slashes, …