Inserting leading zeros into an integer

I have a function in C which generates a number of hours from a rtc peripheral, which I then want to fill an array within a struct object. The array is set up to take 5 digits, but I need to prepend leading zeros to the number when开发者_高级运维 it is less than 5 digits.

Could anyone advise on an easy way of achieving this?

char array[5];
snprintf(array, 5, "%05d", number)

A couple little routines that'll do what you want without having a printf() library hanging around. Note that there's not a way for the routines to tell you that the int you've passed in is too big for the buffer size passed in - I'll leave adding that as an exercise for the reader. But these are safe against buffer overflow (unless I've left a bug in there).

void uint_to_str_leading( char* dst, unsigned int i, size_t size )
{
    char* pCurChar;

    if (size == 0) return;

    pCurChar = dst + size;  // we'll be working the buffer backwards

    *--pCurChar = '\0';   // take this out if you don't want an ASCIIZ output
                          //   but think hard before doing that...

    while (pCurChar != dst) {        
        int digit = i % 10;
        i = i /10;

        *--pCurChar = '0' + digit;
    }

    return;
}


void int_to_str_leading( char* dst, int i, size_t size )
{
    if (size && (i < 0)) {
        *dst++ = '-';
        size -= 1;

        i *= -1;
    }

    uint_to_str_leading( dst, i, size);

    return;
}

Note that these routines pass in the buffer size and terminate with a '\0', so your resulting strings will have one less character than the size you've passed in (so don't just pass in the field size you're looking for).

If you don't want the terminating '\0' character because you're dealing with a fixed char[] array that's not terminated, it's easy enough to take out that one line of code that does the termination (but please consider terminating the char[] array - if you don't, I'll bet you'll see at least one bug related to that sometime over the next 6 months).

Edit to answer some questions:

dst is a pointer to a destination buffer. The caller is responsible to have a place to put the string that's produced by the function, much like the standard library function strcpy().

The pointer pCurChar is a pointer to the location that the next digit character that's produced will go. It's used a little differently than most character pointers because the algorithm starts at the end of the buffer and moves toward the start (that's because we produce the digits from the 'end' of the integer). Actually, pCurChar points just past the place in the buffer where it's going to put the next digit. When the algorithm goes to add a digit to the buffer, it decrements the pointer before dereferencing it. The expression:

*--pCurChar = digit;

Is equivalent to:

pCurChar = pCurChar-1;  /* move to previous character in buffer */
*pCurChar = digit;

It does this because the test for when we're done is:

while (pCurChar == dst) {   /* when we get to the start of the buffer we're done */

The second function is just a simple routine that handles signed ints by turning negative numbers into positive ones and letting the 1st function do all the real work, like so:

• putting a '-' character at the start of the buffer,
• adjusting the buffer pointer and size, and
• negating the number to make it positive
• passing that onto the function that converts an unsigned int to do the real work

An example of using these functions:

char buffer[80];

uint_to_str_leading( buffer, 0, 5); 
printf( "%s\n", buffer);

uint_to_str_leading( buffer, 123, 6); 
printf( "%s\n", buffer);

uint_to_str_leading( buffer, UINT_MAX, 14); 
printf( "%s\n", buffer);

int_to_str_leading( buffer, INT_MAX, 14); 
printf( "%s\n", buffer);

int_to_str_leading( buffer, INT_MIN, 14); 
printf( "%s\n", buffer);

Which produces:

0000
00123
0004294967295
0002147483647
-002147483648

like @Aaron's solution, the only way to do it in C is to treat it like a character instead of a number. Leading zeros are ignored when they occur as a value and indicate an octal constant when appearing in code.

int a = 0000015; // translates to decimal 13.

Initialize every element in the array to 0 before inserting the digits into the array. That way you're guaranteed to always have 5 digits with leading zeroes.

If the type is int, then no. Set the type to string?

try this :

    char source[5+1] = { '1','2', 0, 0, 0, 0 };
    char dest[5+1];
    int nd = strlen(source) ;
    memset ( dest, '0', 5 - nd );
    sprintf ( dest+nd+1, "%s", source );

Doesn't simple total bzero() or something like this and then filling with new value suit you? Could you please describe more details if not?

I'm not joking, I have seen several cases when total filling with 0 is faster then tricks to add 0s, especially if memory was cached and bzero() had some burst write support.

int newNumber [5]  = 0;

for ( int i=0; givenNumber != 0 && i < 5 ; i++ ) {
    newNumber[i] = givenNumber%10;
    givenNumber = givenNumer/10;
}

apologies for the lack of detail. My code generates a 32-bit integer, which I am expecting to only get to 5 decimal digits in size. I then call the function:

numArray = numArrayFill(12345, buf, sizeof(buf));

(uint32_t number, char *buffer, int size) 
{
    char *curr = &buffer[size];             
    *--curr = 0;                            
    do 
    {
        *--curr = (number % 10) + '0';
        number /= 10;
    } 
    while (number != 0);

    if (curr == buffer && number != 0)      
    return NULL;

    return curr;
}   

The problem comes when I put in a less than 5 digit number and I get random behaviour. What I need to do is to append zeros to the front so that it is always a 5 digit number.

Thanks Dave