Printing hexadecimal characters in C

Mastering Hexadecimal Output in C with printf

Learn how to effectively print hexadecimal characters and values in C using the versatile printf function, covering various formatting options and common use cases.

Hexadecimal notation is a crucial concept in low-level programming, embedded systems, and data representation. It provides a more compact and human-readable way to express binary data compared to long strings of 0s and 1s. In C, the printf function offers robust capabilities for formatting and printing hexadecimal values. This article will guide you through the different format specifiers and modifiers available for displaying hexadecimal characters and integers, ensuring you can present your data exactly as needed.

Basic Hexadecimal Output with %x and %X

The primary format specifiers for printing unsigned integer values in hexadecimal are %x and %X. Both convert an unsigned integer argument to its hexadecimal representation. The key difference lies in the case of the alphabetic characters (A-F) used for digits 10 through 15. %x uses lowercase letters (a, b, c, d, e, f), while %X uses uppercase letters (A, B, C, D, E, F). It's important to remember that these specifiers expect an unsigned integer type. If you pass a signed integer with a negative value, its representation will be the two's complement hexadecimal value.

#include <stdio.h>

int main() {
    int num1 = 255;       // Decimal 255
    int num2 = 42;        // Decimal 42
    unsigned int num3 = 1000;
    int num4 = -1;        // Example of negative number

    printf("Lowercase hex for 255: %x\n", num1);    // ff
    printf("Uppercase hex for 255: %X\n", num1);    // FF
    printf("Lowercase hex for 42: %x\n", num2);     // 2a
    printf("Uppercase hex for 42: %X\n", num2);     // 2A
    printf("Lowercase hex for 1000: %x\n", num3);   // 3e8
    printf("Uppercase hex for 1000: %X\n", num3);   // 3E8
    printf("Hex for -1 (unsigned int context): %x\n", num4); // ffffffff (on 32-bit system)

    return 0;
}

Basic usage of %x and %X to print hexadecimal values.

Adding Precision and Prefixes

printf offers several modifiers to enhance the readability of hexadecimal output. The # flag adds the 0x or 0X prefix to the output, making it explicitly clear that the number is hexadecimal. The precision specifier (e.g., .4) can be used to specify the minimum number of digits to be printed; if the value has fewer digits, it will be padded with leading zeros. The width specifier (e.g., 8) can be used to specify the minimum field width, padding with spaces if the value is shorter.

#include <stdio.h>

int main() {
    int value = 255;
    int small_value = 10;

    printf("With 0x prefix: %#x\n", value);        // 0xff
    printf("With 0X prefix: %#X\n", value);        // 0XFF
    printf("Padded with zeros (min 4 digits): %.4x\n", small_value); // 000a
    printf("Padded with zeros (min 8 digits): %.8X\n", small_value); // 0000000A
    printf("Right-justified (width 8): %8x\n", value);       //      ff
    printf("Left-justified (width 8): %-8x\n", value);       // ff      
    printf("Combined: %#08x\n", small_value);       // 0x0000000a

    return 0;
}

Using format flags and precision with hexadecimal output.

Anatomy of a printf hexadecimal format specifier.

Printing Larger Hexadecimal Values: long and long long

For long and long long integer types, you need to use the appropriate length modifiers with %x or %X. The l (lowercase L) modifier is used for long unsigned int, and ll is used for long long unsigned int. Failing to use the correct length modifier can lead to undefined behavior, often manifesting as incorrect output or crashes, especially on systems where int, long, and long long have different sizes.

#include <stdio.h>
#include <stdint.h> // For fixed-width integer types

int main() {
    long unsigned int large_num = 0xDEADBEEFL;
    long long unsigned int very_large_num = 0xCAFEBABEDEADBEEFLL;
    uint64_t uint64_val = 0x123456789ABCDEF0ULL;

    printf("Long unsigned int: %lx\n", large_num);
    printf("Long long unsigned int: %llX\n", very_large_num);
    printf("uint64_t with PRIx64: %" PRIx64 "\n", uint64_val); // Recommended for portability

    return 0;
}

Printing long and long long hexadecimal values.