C Program For Hexadecimal To Binary Conversion

Hexadecimal and binary number systems are fundamental in computing, often used for representing data at a low level. Converting between them is a common task, especially when working with memory addresses, register values, or raw data. In this article, you will learn how to write a C program to efficiently convert hexadecimal numbers to their binary equivalents, understanding the underlying logic and implementation details.

Problem Statement

The challenge lies in translating a base-16 number (hexadecimal) into its base-2 counterpart (binary). Each hexadecimal digit represents a value from 0 to 15, which can be perfectly represented by a group of four binary digits (bits). For instance, hexadecimal 'A' (decimal 10) is 1010 in binary. The problem requires a systematic way to process an entire hexadecimal string and convert each of its digits. This conversion is crucial in various computing contexts, from debugging memory dumps to understanding network packet structures, where data is often presented in hexadecimal for compactness but processed in binary.

Example

Consider the hexadecimal number A5. - The hexadecimal digit A corresponds to decimal 10, which is 1010 in binary. - The hexadecimal digit 5 corresponds to decimal 5, which is 0101 in binary. - Concatenating these gives the binary equivalent: 10100101.

Background & Knowledge Prerequisites

To effectively understand and implement the hexadecimal to binary conversion program in C, a reader should be familiar with:

• C Programming Basics: Understanding fundamental concepts such as variables, data types (especially char arrays for strings), loops (while, for), conditional statements (if-else, switch), and functions.
• Number Systems: A basic understanding of decimal, binary, and hexadecimal number systems, including how they represent values and their respective bases.
• Character Handling: Knowledge of how characters are stored and manipulated in C, including ASCII values and string termination (\0).

Use Cases or Case Studies

Converting hexadecimal to binary is a common operation in several computing domains:

• Embedded Systems Programming: Microcontrollers and other embedded devices often expose registers and memory addresses in hexadecimal. Converting these to binary helps in understanding the exact state of individual bits (e.g., configuring hardware flags).
• Network Protocol Analysis: Network packet headers and payloads are frequently displayed in hexadecimal format. Converting specific fields to binary allows engineers to examine individual flags and control bits defined by the protocol specifications.
• Memory Forensics and Debugging: When analyzing memory dumps or debugging programs, raw memory content is typically shown in hexadecimal. Converting sections to binary can reveal patterns or specific bit configurations that indicate program state or data corruption.
• Cryptographic Applications: Keys, hashes, and other cryptographic values are often represented in hexadecimal. Converting them to binary helps in understanding their underlying bit structure, which is critical for cryptographic operations.
• Digital Logic Design: When designing or simulating digital circuits, inputs and outputs are fundamentally binary. Hexadecimal is used as a shorthand for longer binary sequences, and conversion is needed to map these to actual logic levels.

Solution Approaches

This section presents two practical approaches to convert hexadecimal numbers to their binary equivalents in C, focusing on clarity and ease of understanding.

Approach 1: Digit-by-Digit Conversion using switch Statement

This method processes each hexadecimal digit individually, converting it into its corresponding 4-bit binary sequence using a switch statement for character mapping.

// Hexadecimal to Binary Converter using Switch
#include <stdio.h>
#include <string.h> // Required for strlen()
#include <ctype.h>  // Required for toupper()

// Function to convert a single hexadecimal digit to its 4-bit binary equivalent
void hexToBinary(char hexDigit) {
    switch (toupper(hexDigit)) { // Convert to uppercase for consistent comparison
        case '0': printf("0000"); break;
        case '1': printf("0001"); break;
        case '2': printf("0010"); break;
        case '3': printf("0011"); break;
        case '4': printf("0100"); break;
        case '5': printf("0101"); break;
        case '6': printf("0110"); break;
        case '7': printf("0111"); break;
        case '8': printf("1000"); break;
        case '9': printf("1001"); break;
        case 'A': printf("1010"); break;
        case 'B': printf("1011"); break;
        case 'C': printf("1100"); break;
        case 'D': printf("1101"); break;
        case 'E': printf("1110"); break;
        case 'F': printf("1111"); break;
        default:  printf("\\nError: Invalid hexadecimal digit '%c'\\n", hexDigit);
    }
}

int main() {
    char hexNum[20]; // Buffer to store hexadecimal input
    int i = 0;

    // Step 1: Prompt user for input
    printf("Enter a hexadecimal number: ");
    scanf("%s", hexNum);

    printf("Binary equivalent: ");

    // Step 2: Iterate through each character of the hexadecimal string
    while (hexNum[i] != '\\0') {
        hexToBinary(hexNum[i]); // Call function to convert and print
        i++;
    }
    printf("\\n");

    return 0;
}

Run

Sample Output:

Enter a hexadecimal number: 1A
Binary equivalent: 00011010

Enter a hexadecimal number: FF00
Binary equivalent: 1111111100000000

Stepwise Explanation:

1. Helper Function hexToBinary: A function hexToBinary is defined to take a single char representing a hexadecimal digit.
2. Character Normalization: Inside hexToBinary, toupper(hexDigit) is used to convert the input character to its uppercase equivalent. This ensures that both 'a' and 'A' are treated the same, simplifying the switch statement.
3. switch Statement for Mapping: The switch statement then checks the uppercase hexadecimal character. For each valid hexadecimal digit ('0'-'9', 'A'-'F'), it prints its corresponding 4-bit binary string. If an invalid character is encountered, an error message is printed.
4. Main Program Flow:

• In the main function, a character array hexNum is declared to store the user's hexadecimal input.
• The program prompts the user to enter a hexadecimal number using printf and reads the input string using scanf("%s", hexNum).
• A while loop iterates through each character of the hexNum string until the null terminator (\0) is encountered.
• In each iteration, the hexToBinary function is called with the current character, which then prints the 4-bit binary equivalent directly to the console.
• Finally, a newline character is printed for formatting.

Approach 2: Using a Lookup Array for Efficiency

This approach uses a predefined array to quickly map hexadecimal characters to their binary string representations, offering a more compact and potentially faster solution than a large switch statement for the lookup part.

// Hexadecimal to Binary Converter with Lookup Array
#include <stdio.h>
#include <string.h> // Required for strlen()
#include <ctype.h>  // Required for toupper()

// Lookup array for 4-bit binary equivalents of hex digits (0-F)
const char* hex_to_bin_map[] = {
    "0000", "0001", "0010", "0011", // 0, 1, 2, 3
    "0100", "0101", "0110", "0111", // 4, 5, 6, 7
    "1000", "1001", "1010", "1011", // 8, 9, A, B
    "1100", "1101", "1110", "1111"  // C, D, E, F
};

// Function to get the integer value of a hexadecimal character
int get_hex_value(char c) {
    if (c >= '0' && c <= '9') {
        return c - '0';
    } else if (c >= 'A' && c <= 'F') { // Handle uppercase A-F
        return c - 'A' + 10;
    } else if (c >= 'a' && c <= 'f') { // Handle lowercase a-f
        return c - 'a' + 10;
    } else {
        return -1; // Invalid hex character
    }
}

int main() {
    char hexNum[20];
    int i = 0;

    // Step 1: Prompt user for input
    printf("Enter a hexadecimal number: ");
    scanf("%s", hexNum);

    printf("Binary equivalent: ");

    // Step 2: Iterate through each character of the hexadecimal string
    while (hexNum[i] != '\\0') {
        int val = get_hex_value(hexNum[i]); // Get integer value of current hex digit

        if (val != -1) { // Check if it's a valid hex digit
            printf("%s", hex_to_bin_map[val]); // Print corresponding binary string from lookup map
        } else {
            printf("\\nError: Invalid hexadecimal digit '%c' found.\\n", hexNum[i]);
            return 1; // Indicate error and exit
        }
        i++;
    }
    printf("\\n");

    return 0;
}

Run

Sample Output:

Enter a hexadecimal number: F5c
Binary equivalent: 111101011100

Enter a hexadecimal number: 8Invalid
Error: Invalid hexadecimal digit 'I' found.

Stepwise Explanation:

1. Lookup Array hex_to_bin_map: A global const char* array hex_to_bin_map is initialized. Each index from 0 to 15 corresponds to the decimal value of a hexadecimal digit, and the element at that index stores its 4-bit binary string representation.
2. Helper Function get_hex_value: This function takes a hexadecimal character and returns its integer equivalent (0-15). It handles both uppercase ('A'-'F') and lowercase ('a'-'f') hexadecimal letters. If an invalid character is passed, it returns -1.
3. Main Program Flow:

• The main function reads the hexadecimal input string, similar to Approach 1.
• It iterates through each character of the input hexNum string.
• For each character, it calls get_hex_value to convert the hex character into an integer (val).
• Error Handling: It checks if val is -1. If so, an invalid hexadecimal digit was found, and an error message is printed before the program exits.
• If val is valid, it uses this integer as an index into the hex_to_bin_map array (hex_to_bin_map[val]) to retrieve the corresponding 4-bit binary string.
• The retrieved binary string is then printed using printf("%s", ...).
• The loop continues until the end of the input string, and a newline is printed at the end.

Conclusion

Converting hexadecimal numbers to their binary equivalents in C is a straightforward task that leverages the one-to-four digit mapping between the two number systems. Both the switch statement and lookup array approaches effectively achieve this by processing the input hexadecimal string character by character. The choice between them often comes down to personal preference or specific performance considerations; the lookup array can be slightly more compact and potentially faster for very large mappings, while the switch statement is very explicit and easy to read for a fixed number of cases. Regardless of the chosen method, understanding the core principle of converting each hex digit into its 4-bit binary form is key to successful implementation.

Summary

• Hexadecimal (base-16) numbers are a compact way to represent binary (base-2) data.
• Each single hexadecimal digit directly corresponds to a unique four-bit binary sequence.
• C programs can convert hexadecimal strings to binary by iterating through the input string, character by character.
• Common implementation techniques involve using switch statements or predefined lookup arrays to map each hexadecimal digit to its 4-bit binary representation.
• Error handling for invalid hexadecimal characters ensures the robustness of the conversion program.