Dezimal zu Binär und Hexadezimal in C – CSCI 247 Tutorial

Warum Zahlenbasis-Konvertierung in C lernen?

In der Computer Systems I (CSCI 247) Hausaufgabe geht es darum, Dezimalzahlen in Binär oder Hexadezimal umzuwandeln – und zwar ohne bequeme printf-Formatierer. Das klingt erstmal nach einer trockenen Übung, aber es ist der Schlüssel, um zu verstehen, wie dein Rechner wirklich tickt. Egal ob du später an KI-Anwendungen, Spiele-Engines oder Finanzsoftware arbeitest – Bit-Operationen und Zahlenbasen sind überall. Stell dir vor, du entwickelst ein E-Sport-Scoreboard: Die Punktzahlen werden intern als Binärzahlen verarbeitet, und du musst sie für die Anzeige in Dezimal oder Hex umwandeln. Genau diese Fähigkeiten trainierst du hier.

Die Aufgabenstellung verstehen

Dein Programm convert soll:

Ein Kommandozeilen-Flag -x (Hexadezimal) oder -b (Binär) akzeptieren.
Dezimalzahlen von der Standardeingabe lesen (bis ^D).
Jede Zahl manuell in die gewünschte Basis umwandeln und ausgeben.
Ohne printf("%x") auskommen – du musst die Konvertierung selbst programmieren.

Das klingt nach viel Arbeit, aber mit einer sauberen Struktur und bitweisen Operatoren in C wird es überschaubar. Im Folgenden zeige ich dir einen Ansatz, der dir hilft, die Aufgabe zu meistern, ohne die komplette Lösung vorwegzunehmen.

Grundlagen der Zahlenkonvertierung

Bevor wir Code schreiben, frischen wir kurz auf, wie die Umwandlung funktioniert:

Dezimal → Binär: Teile die Zahl durch 2, notiere den Rest (0 oder 1). Wiederhole, bis der Quotient 0 ist. Die Reste von unten nach oben ergeben die Binärzahl.
Dezimal → Hexadezimal: Teile durch 16, notiere den Rest (0-15, wobei 10-15 als A-F dargestellt werden). Wiederhole, bis der Quotient 0 ist. Die Reste von unten nach oben ergeben die Hex-Zahl.

Diese Algorithmen sind einfach, aber repetitiv. Genau deshalb automatisieren wir sie in C.

Bitweise Operatoren in C – deine besten Freunde

Für die manuelle Konvertierung sind bitweise Operatoren essenziell. Sie erlauben dir, einzelne Bits zu extrahieren oder zu setzen. Die wichtigsten:

& (UND): Zum Maskieren von Bits. zahl & 1 gibt das niederwertigste Bit.
| (ODER): Zum Setzen von Bits.
<< (Linksverschiebung): Multipliziert mit 2er-Potenzen.
>> (Rechtsverschiebung): Dividiert durch 2er-Potenzen.

Mit >> und & kannst du jede Dezimalzahl Bit für Bit zerlegen – perfekt für die Binär- und Hex-Konvertierung.

Programmstruktur und Funktionen

Ein gut strukturiertes C-Programm besteht aus mehreren Funktionen. Hier ein Vorschlag, wie du deine convert.c aufbauen könntest:

/* * Name: Dein Name * Beschreibung: Konvertiert Dezimalzahlen in Binär oder Hexadezimal */ #include <stdio.h> #include <string.h> // für strcmp static const int BASE_BIN = 2; static const int BASE_HEX = 16; /* * Funktion: print_binary * Wandelt eine Dezimalzahl in Binär um und gibt sie aus. * Parameter: value - die umzuwandelnde Zahl */ void print_binary(int value) { // TODO: Implementierung } /* * Funktion: print_hex * Wandelt eine Dezimalzahl in Hexadezimal um und gibt sie aus. * Parameter: value - die umzuwandelnde Zahl */ void print_hex(int value) { // TODO: Implementierung } /* * Funktion: main * Liest Dezimalzahlen von stdin und ruft die entsprechende Konvertierung auf. * Parameter: argc, argv - Kommandozeilenargumente * Rückgabe: 0 bei Erfolg, 1 bei Fehler */ int main(int argc, char* argv[]) { // Überprüfe Kommandozeilenargumente if (argc != 2 || (strcmp(argv[1], "-x") != 0 && strcmp(argv[1], "-b") != 0)) { printf("Usage: ./convert [-x|-b]\n"); return 1; } int flag_hex = (strcmp(argv[1], "-x") == 0); int zahl; // Lese Dezimalzahlen bis EOF while (scanf("%d", &zahl) == 1) { if (flag_hex) { print_hex(zahl); } else { print_binary(zahl); } } return 0; }

Beachte: Die eigentlichen Konvertierungsfunktionen sind noch leer – das ist deine Aufgabe! Aber die Struktur zeigt, wie du vorgehen kannst.

Tipps zur Implementierung der Konvertierung

Binär-Konvertierung

Um eine Zahl in Binär darzustellen, musst du die Bits von links nach rechts ausgeben. Ein einfacher Weg: Bestimme die höchste Zweierpotenz, die in die Zahl passt, und arbeite dich dann nach unten.

void print_binary(int value) { // Annahme: 32-Bit-Integer, wir ignorieren Vorzeichen für unsigned int mask = 1 << 31; // Start mit dem höchsten Bit int started = 0; while (mask > 0) { if (value & mask) { putchar('1'); started = 1; } else if (started) { putchar('0'); } mask >>= 1; } if (!started) putchar('0'); // Falls value == 0 putchar('\n'); }

Dieser Code nutzt eine Maske, die durch die Bits wandert. value & mask prüft, ob das aktuelle Bit gesetzt ist. Wichtig: Wir geben erst ab dem ersten gesetzten Bit Nullen aus (außer bei 0).

Hexadezimal-Konvertierung

Für Hexadezimal extrahierst du 4-Bit-Blöcke. Eine mögliche Methode: Verwende eine Tabelle für die Ziffern 0-9 und A-F.

void print_hex(int value) { // Array für Hex-Ziffern (0-15 → '0'...'F') char hex_chars[] = "0123456789ABCDEF"; char buffer[9]; // 8 Hex-Ziffern + Nullterminator int index = 7; buffer[8] = '\0'; // Beginne mit dem niederwertigsten 4-Bit-Block while (index >= 0) { int nibble = value & 0xF; // untere 4 Bits buffer[index] = hex_chars[nibble]; value >>= 4; // nächstes Halbbyte index--; } // Führende Nullen entfernen (außer bei 0) char* ptr = buffer; while (*ptr == '0' && *(ptr+1) != '\0') ptr++; printf("0x%s\n", ptr); }

Hier speichern wir die Hex-Ziffern von rechts nach links in einem Buffer und entfernen dann führende Nullen. Der Ausdruck value & 0xF isoliert die unteren 4 Bits – das ist ein klassischer Bitmasken-Trick.

Häufige Fehler und wie du sie vermeidest

Vergessen von EOF: Deine Schleife muss scanf korrekt auswerten. scanf gibt die Anzahl der erfolgreich gelesenen Werte zurück (1 bei Erfolg) oder EOF bei Dateiende.
Falsche Argumentprüfung: Nutze strcmp zum Vergleichen von Strings. argv[1] == "-x" funktioniert nicht, weil es Zeiger vergleicht.
Keine Ausgabe bei 0: Deine Konvertierung muss den Fall value == 0 abdecken. Für Binär: gib mindestens eine '0' aus. Für Hex: gib 0x0 aus.
Formatierung: Die Aufgabenstellung verlangt Leerzeichen zwischen den Binärziffern (z.B. 100 1101 0010). Du kannst nach jeweils 4 Bits ein Leerzeichen einfügen.

Testen deines Programms

Kompiliere mit gcc -o convert convert.c und teste die Beispiele aus der Aufgabenstellung:

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

Deine Ausgabe sollte exakt so aussehen. Achte auf Groß-/Kleinschreibung bei Hex-Ziffern (die Aufgabenstellung verwendet Kleinbuchstaben, aber oft wird Großbuchstabe erwartet – prüfe die Vorgaben deines Dozenten).

Weiterführende Gedanken: Warum das wichtig ist

Die manuelle Konvertierung schult dein Verständnis für die Datenrepräsentation im Speicher. In der Praxis wirst du selten selbst Binär-Strings ausgeben, aber du wirst ständig mit Bitmasken, Flags und Speicheradressen arbeiten. Ein aktuelles Beispiel: In der KI-Entwicklung werden oft Quantisierungsverfahren eingesetzt, die Zahlen in niedrigere Bitbreiten konvertieren. Auch Spieleentwickler nutzen Bit-Operationen für Kollisionserkennung oder Zustandsmasken. Wenn du also das nächste Mal einen Viral-App-Prototypen baust oder an einem Finanz-Dashboard arbeitest, wirst du dankbar sein, dass du die Basics beherrschst.

Hilfreiche Ressourcen

man scanf – Details zur Eingabe
man printf – aber denk dran: %x ist tabu!
man strcmp – String-Vergleich
man strstr – falls du Teilstrings suchst (hier nicht nötig)

Viel Erfolg bei deiner CSCI 247 Hausaufgabe! Mit diesem Leitfaden und etwas Geduld wirst du die Konvertierung meistern und gleichzeitig deine C-Programmierkenntnisse auf das nächste Level bringen.