Printing hexadecimal characters in C

Question

I'm trying to read in a line of characters, then print out the hexadecimal equivalent of the characters.

For example, if I have a string that is "0xc0 0xc0 abc123", where the first 2 characters are c0 in hex and the remaining characters are abc123 in ASCII, then I should get

c0 c0 61 62 63 31 32 33

However, printf using %x gives me

ffffffc0 ffffffc0 61 62 63 31 32 33

How do I get the output I want without the "ffffff"? And why is it that only c0 (and 80) has the ffffff, but not the other characters?

Solution 1

You are seeing the ffffff because char is signed on your system. In C, vararg functions such as printf will promote all integers smaller than int to int. Since char is an integer (8-bit signed integer in your case), your chars are being promoted to int via sign-extension.

Since c0 and 80 have a leading 1-bit (and are negative as an 8-bit integer), they are being sign-extended while the others in your sample don't.

char    int
c0 -> ffffffc0
80 -> ffffff80
61 -> 00000061

Here's a solution:

char ch = 0xC0;
printf("%x", ch & 0xff);

This will mask out the upper bits and keep only the lower 8 bits that you want.

Solution 2

Indeed, there is type conversion to int. Also you can force type to char by using %hhx specifier.

printf("%hhX", a);

In most cases you will want to set the minimum length as well to fill the second character with zeroes:

printf("%02hhX", a);

ISO/IEC 9899:201x says:

7 The length modifiers and their meanings are: hh Specifies that a following d, i, o, u, x, or X conversion specifier applies to a signed char or unsigned char argument (the argument will have been promoted according to the integer promotions, but its value shall be converted to signed char or unsigned char before printing); or that a following

Solution 3

You can create an unsigned char:

unsigned char c = 0xc5;

Printing it will give C5 and not ffffffc5.

Only the chars bigger than 127 are printed with the ffffff because they are negative (char is signed).

Or you can cast the char while printing:

char c = 0xc5; 
printf("%x", (unsigned char)c);

Solution 4

You can use hh to tell printf that the argument is an unsigned char. Use 0 to get zero padding and 2 to set the width to 2. x or X for lower/uppercase hex characters.

uint8_t a = 0x0a;
printf("%02hhX", a); // Prints "0A"
printf("0x%02hhx", a); // Prints "0x0a"

---

Edit: If readers are concerned about 2501's assertion that this is somehow not the 'correct' format specifiers I suggest they read the printf link again. Specifically:

Even though %c expects int argument, it is safe to pass a char because of the integer promotion that takes place when a variadic function is called.

The correct conversion specifications for the fixed-width character types (int8_t, etc) are defined in the header <cinttypes>(C++) or <inttypes.h> (C) (although PRIdMAX, PRIuMAX, etc is synonymous with %jd, %ju, etc).

As for his point about signed vs unsigned, in this case it does not matter since the values must always be positive and easily fit in a signed int. There is no signed hexideximal format specifier anyway.

Edit 2: ("when-to-admit-you're-wrong" edition):

If you read the actual C11 standard on page 311 (329 of the PDF) you find:

hh: Specifies that a following d, i, o, u, x, or X conversion specifier applies to a signed char or unsigned char argument (the argument will have been promoted according to the integer promotions, but its value shall be converted to signed char or unsigned char before printing); or that a following n conversion specifier applies to a pointer to a signed char argument.

Solution 5

You are probably storing the value 0xc0 in a char variable, what is probably a signed type, and your value is negative (most significant bit set). Then, when printing, it is converted to int, and to keep the semantical equivalence, the compiler pads the extra bytes with 0xff, so the negative int will have the same numerical value of your negative char. To fix this, just cast to unsigned char when printing:

printf("%x", (unsigned char)variable);

View more solutions

Comments

[burito]

The string that matches your array of bytes would be... "\xc0\xc0abc123"

[lvella]

My solution using a cast to unsigned char is one instruction smaller in gcc4.6 for x86-64...

[Bob Stein]

+1 the real best answer, explicit typing as close to the data declaration as possible (but not closer).

[2501]

Maybe I can help. This is (technically) undefined behavior because specifier x requires an unsigned type, but ch is promoted to int. The correct code would simply cast ch to unsigned, or use a cast to unsigned char and the specifier: hhx.

[2501]

Specifiers are not correct for the type uint8_t. Fixed width types use special print specifiers. See: inttypes.h

[Timmmm]

Yeah but all varargs integers are implicitly promoted to int.

[2501]

That may be, but as far as C is defined, behavior is undefined if you don't use the correct specifier.

[Timmmm]

But %x is the correct specifier. (char and unsigned char are promoted to int)[en.cppreference.com/w/cpp/language/variadic_arguments]. You would only need to use the PRI specifiers for things that don't fit in your platform int - e.g. unsigned int.

[2501]

%x is correct for unsigned int not int. Types char and unsigned char are promoted to int. In addition there is no guarantee that uint8_t is defined as unsigned char.

[Timmmm]

See my edit. There is no signed hex specifier. It is perfectly value to promote uint8_t to int. QED.

[2501]

You didn't address my comments. There is no signed hex specifier. Exactly, int cannot be printed using specifier x. Only unsigned int.The quote you posted is not from the C Standard. Therefore it is not relevant.

[2501]

As I have already written, you assume that uint8_t is always defined as unsigned char. This is not the case as C makes no such guarantee.

[Gustavo Meira]

If I have printf("%x", 0), nothing is printed.

[user2262111]

It doesn't print anything because the minimum is set to 0. To fix this, try printf("%.2x", 0); which will boost the minimum characters drawn to 2. To set a max, prepend the . with a number. For example, you can force only 2 characters drawn by doing printf("%2.2x", 0);

[maxschlepzig]

Any reason why printf("%x", ch & 0xff) should be better than just using printf("%02hhX", a) as in @brutal_lobster's answer?