Mastering Decimal-to-Binary and Hex Conversion in C: A Hands-On Tutorial for CSCI 247

Introduction: Why Manual Conversion Matters

In computer systems, understanding how data is stored at the lowest level is crucial. Decimal, binary, and hexadecimal are the three representations you'll encounter constantly. While calculators and built-in functions like printf's %x can do the conversion for you, writing the conversion yourself — as required in CSCI 247 Homework 1 — deepens your grasp of bitwise operations and number systems. In this tutorial, you'll build a C program called convert that reads decimal integers from standard input and outputs their binary or hexadecimal representation based on a command-line flag (-x for hex, -b for binary). We'll follow the assignment specifications: no %x, well-structured code, and proper use of functions.

Getting Started: Program Skeleton and Command-Line Arguments

Your program must accept exactly one argument: -x or -b. If the user provides no arguments or an invalid flag, print a usage message and exit. Use argc and argv to access command-line arguments. Here's a basic structure:

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

int main(int argc, char* argv[]) {
    if (argc != 2) {
        printf("Usage: ./convert [-x|-b]\n");
        return 1;
    }
    // ...
    return 0;
}

Use strcmp to compare the argument string. Remember, == does not work for C strings. The flag determines which conversion function to call later.

Reading Decimal Integers from Standard Input

The program should read integers until EOF (Ctrl+D on Unix). Use scanf in a loop. scanf returns the number of items successfully read, or EOF on end-of-file. Example:

int value;
while (scanf("%d", &value) == 1) {
    // convert and print
}

This loop will continue until you press Ctrl+D. No need to prompt the user; just read and convert each number.

Converting to Binary: The Bitwise Approach

Binary representation is simply the base-2 expansion of the number. Since an int is typically 32 bits, you can extract each bit using bitwise AND and shifting. Start from the most significant bit (bit 31) and go down to bit 0. For each bit, check if it's set: (value & (1 << i)). Print '1' if true, '0' otherwise. To make output readable, group bits in nibbles (4 bits) with spaces. Example for 1234: 100 1101 0010.

void print_binary(int n) {
    for (int i = 31; i >= 0; i--) {
        if (n & (1 << i))
            putchar('1');
        else
            putchar('0');
        if (i % 4 == 0 && i != 0)
            putchar(' ');
    }
    putchar('\n');
}

This method works for positive and negative numbers because bitwise operations treat the integer as its two's complement representation. For negative numbers, you'll see the full 32-bit pattern.

Converting to Hexadecimal: Manual Digit Extraction

Hexadecimal (base-16) uses digits 0-9 and letters A-F. Each hex digit corresponds to 4 bits. To convert, repeatedly divide the number by 16 and collect remainders. Use an array to store digits in reverse order. Digits 0-9 map to '0'-'9', and 10-15 map to 'A'-'F'. Print the result with a leading "0x". Example: 1234 in hex is 0x4D2.

void print_hex(int n) {
    char hex_digits[] = "0123456789ABCDEF";
    char buffer[9]; // enough for 32-bit int
    int index = 0;
    unsigned int un = (unsigned int)n; // handle negative as unsigned
    if (un == 0) {
        printf("0x0\n");
        return;
    }
    while (un > 0) {
        buffer[index++] = hex_digits[un % 16];
        un /= 16;
    }
    printf("0x");
    for (int i = index - 1; i >= 0; i--)
        putchar(buffer[i]);
    putchar('\n');
}

Notice the use of unsigned int to avoid sign extension issues when shifting or dividing negative numbers. This is a common pitfall.

Putting It All Together: Main Function and Error Handling

In main, parse the flag and call the appropriate conversion function inside the read loop. For invalid input (non-integer), scanf will fail; you may want to clear the input buffer, but the assignment doesn't require it. Keep the code clean and modular. Example complete structure:

int main(int argc, char* argv[]) {
    if (argc != 2 || (strcmp(argv[1], "-x") != 0 && strcmp(argv[1], "-b") != 0)) {
        printf("Usage: ./convert [-x|-b]\n");
        return 1;
    }
    int flag = (strcmp(argv[1], "-x") == 0) ? 1 : 0; // 1 for hex, 0 for binary
    int value;
    while (scanf("%d", &value) == 1) {
        if (flag)
            print_hex(value);
        else
            print_binary(value);
    }
    return 0;
}

Testing Your Program

Compile with gcc -o convert convert.c. Test with the examples from the assignment:

$ ./convert -x
1234
0x4D2
879
0x36F
^D
$ ./convert -b
1234
100 1101 0010
4321
1 0000 1110 0001
^D
$ ./convert
Usage: ./convert [-x|-b]

Make sure your output matches exactly, including spaces and newlines. The binary output should have spaces every 4 bits (except the last group). The hex output should have a leading "0x" and uppercase letters.

Common Pitfalls and Tips

• String comparison: Always use strcmp, not ==.
• Bitwise precedence: & has lower precedence than <<, so use parentheses: (value & (1 << i)).
• Negative numbers: When converting to hex, treat the integer as unsigned to avoid infinite loops. For binary, the bitwise method works directly.
• No %x: You must implement the conversion manually. Using printf("%x") will result in zero credit.
• Code style: Use meaningful function names, add header comments, and avoid magic numbers. Define constants like BITS_PER_INT if needed.

Going Further: Real-World Connections

Understanding number base conversions is not just academic. In cybersecurity, analyzing binary exploits often requires reading hex dumps. In embedded systems (like the microcontroller in a smartwatch), you might debug memory using hex values. Even in modern AI, data is often stored in binary formats for efficiency. By mastering this assignment, you're building a foundation for low-level programming.

Conclusion

This tutorial walked you through implementing a C program that converts decimal integers to binary or hexadecimal without using built-in formatting. You practiced bitwise operators, command-line arguments, and manual conversion algorithms — all key skills for CSCI 247. Remember to test thoroughly and adhere to the coding style guidelines. Good luck, and happy coding!