Printf() printing character as 32 bit

Question

I'm running a quick test to make sure I have my pointer arithmetic down:

main.c

#include <stdio.h>
#include <stdlib.h>

#define ADDRESS    0xC0DCA11501LL
#define LENGTH     5


void print_address( char *, char );

/* Main program */
int main( int argc, char *argv[] )
{
    char nums[ LENGTH ];

    /* LSB first */
    for( int i = 0; i < LENGTH; i++ )
    {
        nums[ i ] = ( ADDRESS >> ( 8 * i ) ) & 0xFF;
    }

    print_address( nums, LENGTH );

    system("PAUSE");

    return 0;
}

void print_address( char *data, char len )
{
     char *data_ptr = data;

     while( len-- )
     {
            printf( "%X\n", *data_ptr++ );
     }
}

What I expect is the bytes of ADDRESS to be printed out LSB first in hex format. But the last 3 bytes appear to be printed with 32-bit lengths:

1
15
FFFFFFA1
FFFFFFDC
FFFFFFC0
Press any key to continue . . .

Is this due to my bit-shifting arithmetic, something compiler-specific, some printf() behavior?

(I'm using MinGW GCC v6.3.0 on Windows 10 to compile.)

Betcha that char is a signed value and that you are seeing the FFFFs because A1 is greater than 0x80 and is showing up signed. Try using unsigned char pointer. — Michael Dorgan, Mar 16 '18 at 18:18
@MichaelDorgan D'oh! You're right -- changing the A, D, and C to 7s made it go away. — calcium3000, Mar 16 '18 at 18:19
also `0xC0DCA11501LL` should be `0xC0DCA11501ULL`. Shifting signed integers is undefined behaviour — Jean-François Fabre, Mar 16 '18 at 18:26
Shifting negative signed integers in undefined. Shift positive signed integers is implementation defined. Still, unsigned is a better choice in these cases for many reasons. https://stackoverflow.com/questions/4009885/arithmetic-bit-shift-on-a-signed-integer — Michael Dorgan, Mar 16 '18 at 18:48

Michael Dorgan · Accepted Answer · 2018-03-16T18:49:57.777

5

I believe that your char is a being used as a signed value and that you are seeing the FFFFs because 0xA1 is greater than 0x80 and is therefore showing up signed. Try using unsigned char pointer (and for the nums array and data in your function prototype) and the problem should go away.

edited Mar 16 '18 at 18:49

answered Mar 16 '18 at 18:20

Michael Dorgan

12,453
3
31
61

1

I assume that "_Betcha_" is a slang for "_I bet that_". Is my assumption correct? – machine_1 Mar 16 '18 at 18:36
Yes - sorry for the slang. Betcha is I bet that. – Michael Dorgan Mar 16 '18 at 18:47
Please compile it and let me know how that works. Because that was also my first guess but it didn't work to me. If it works, I remove my answer. If it does not work, upvote mine :-) – Jose Manuel Gomez Alvarez Mar 18 '18 at 19:27

score 2 · Answer 2 · answered Mar 16 '18 at 19:23

Type char seems to be signed in your environment, such that A1 as an 8 bit value actually represents a negative number. Note then that the varargs of printf are promoted to int type, and a negative number is filled up with leading 1-bits. In other words, signed A1 when promoted to 32 bit integer will give FFFFFFA1. That's why.

Use unsigned char instead:

void print_address( unsigned char *, char );

/* Main program */
int main( int argc, char *argv[] )
{
    unsigned char nums[ LENGTH ];

    /* LSB first */
    for( int i = 0; i < LENGTH; i++ )
    {
        nums[ i ] = ( ADDRESS >> ( 8 * i ) ) & 0xFF;
    }

    print_address( nums, LENGTH );

    system("PAUSE");

    return 0;
}

void print_address( unsigned char *data, char len )
{
    unsigned char *data_ptr = data;

    while( len-- )
    {
        printf( "%X\n", *data_ptr++ );
    }
}

Jose Manuel Gomez Alvarez · Answer 3 · 2018-03-16T18:42:42.013

0

The problem is that printf does not know that the type of your data is char.

Try this

void print_address( char *data, char len )
{
     char *data_ptr = data;

     while( len-- )
     {
            printf( "%02X\n", *data_ptr++ &0xFF);
     }
}

Result:

[jmgomez@d1 tmp]$ a.o
01
15
A1
DC
C0
sh: PAUSE: command not found
[jmgomez@d1 tmp]$

edited Mar 16 '18 at 18:42

answered Mar 16 '18 at 18:37

Jose Manuel Gomez Alvarez

1,972
22
29

1

While this does work, it does so by hiding the signed/unsigned issue with truncation. Better to work with unsigned when doing byte work to prevent the issue beforehand. – Michael Dorgan Mar 16 '18 at 18:52

Printf() printing character as 32 bit

3 Answers3