Why hexadecimal printf prints 4-bytes values?

Question

I have following function:

void hexDump(char *buf, size_t size) {
for(int i = 0; i < size; i++) {
    if(i % 4 == 0) {
        printf("\n");
    }

    printf("%02x ", buf[i]);
}

The first two lines always output fine, but the next lines break:

24 00 00 00 
00 0a 04 04 
ffffffe8 ffffffd9 22 63 
00 00 00 00 
02 00 0a 00 
...

Real content of buf obtained by gdb:

0x7fffffffd320: 0x24    0x00    0x00    0x00    0x00    0x0a    0x04    0x04
0x7fffffffd328: 0xe8    0xd9    0x22    0x63    0x00    0x00    0x00    0x00
0x7fffffffd330: 0x02    0x00    0x0a    0x00    0x00    0x00    0x00    0x00

How can I fix it?

Please make this a [mcve] – SuperStormer Sep 15 '22 at 08:06 — SuperStormer, Sep 15 '22 at 08:06

score 2 · Accepted Answer · answered Sep 15 '22 at 08:10

2

Four things leads to this problem:

It's implementation-defined if char is signed or unsigned.
Default argument promotion leads to char values being promoted to int.
When signed integer values are promoted, it's sign-extended to keep negative values negative.
Negative values are usually stored using two's complement, which sets the top bit.

All this leads to a value like 0xf0 could be considered negative, and will be promoted to 0xfffffff0 as an int.

To print only the byte use the hh prefix:

printf("%02hhx ", buf[i]);

Or make sure that the data is unsigned:

void hexDump(unsigned char *buf, size_t size) { ... }

Alternatively, instead if unsigned char use uint8_t.

answered Sep 15 '22 at 08:10

Some programmer dude

400,186
35
402
621

Is not `printf("%02hhx ", buf[i]);` _undefined behavior_ when used to print a negative value signed `char`? "make sure that the data is unsigned" seems to be a requirement. – chux - Reinstate Monica Sep 15 '22 at 08:22
Negative values using _any encoding_, sets the top (sign) bit. – chux - Reinstate Monica Sep 15 '22 at 08:28
@chux-ReinstateMonica I'm sure there have been (historical) systems where the sign indicator have been stored separately from the value. :) – Some programmer dude Sep 15 '22 at 09:08
1

All 3 allowable integer C encodings including 2's complement have always had a sign bit "There shall be exactly one sign bit." , value bits and potential padding (except with `char` and friends). – chux - Reinstate Monica Sep 15 '22 at 09:14

Fe2O3 · Answer 2 · 2022-09-15T08:46:46.453

Here are 3 fixups

void hexDump( unsigned char *buf, size_t size ) {
    for( size_t i = 0; i < size; i++ )
        printf( "%02x%c", buf[ i ], "   \n"[ i % 4 ] );
}

1 - buf should be treated like hex. Hexadecimal is unsigned

2 - size_t i Don't compare an int to a size_t type

3 - indexing into a 4 byte string (3 x SP and 1 x LF) eliminates the if()

You could even go on to add the snazzy address column on the left:

#include <stdio.h>
#include <string.h>

void hexDump( unsigned char *buf, size_t size ) {
    for( size_t i = 0; i < size; i++ ) {
        if( i % 4 == 0 )
            printf( "%04X ", i );
        printf( "%02x%c", buf[ i ], "   \n"[ i % 4 ] );
    }
}

int main() {
    char *str = "The quick brown fox jumps over the lazy dogs";
    hexDump( (unsigned char*) str, strlen( str ) + 1 );
    return 0;
}

Output

0000 54 68 65 20
0004 71 75 69 63
0008 6b 20 62 72
000C 6f 77 6e 20
0010 66 6f 78 20
0014 6a 75 6d 70
0018 73 20 6f 76
001C 65 72 20 74
0020 68 65 20 6c
0024 61 7a 79 20
0028 64 6f 67 73
002C 00

Or, the ACTUAL memory address with 8 / line. (Notice now 7xSP + 1xLF)

void hexDump( unsigned char *buf, size_t size ) {
    for( size_t i = 0; i < size; i++ ) {
        if( i % 8 == 0 )
            printf( "%p ", buf + i );
        printf( "%02x%c", buf[ i ], "       \n"[ i % 8 ] );
    }
}
/* Output */
00422B10 54 68 65 20 71 75 69 63
00422B18 6b 20 62 72 6f 77 6e 20
00422B20 66 6f 78 20 6a 75 6d 70
00422B28 73 20 6f 76 65 72 20 74
00422B30 68 65 20 6c 61 7a 79 20
00422B38 64 6f 67 73 00

Why hexadecimal printf prints 4-bytes values?

2 Answers2