Zahlenformate in der Programmierung

Jede Programmiersprache benötigt Möglichkeiten zur Darstellung von Zahlen. Das Verständnis von Ganzzahltypen, Gleitkommaformaten und Zahlenbasisnotationen hilft Ihnen, korrekten Code zu schreiben und subtile Fehler in Bezug auf Präzision, Überlauf und Darstellung zu vermeiden.

Ganzzahltypen

Ganzzahlen fester Größe

Sprachbeispiele

• C/C++: int, long, int32_t, uint64_t
• Java: byte, short, int, long
• Rust: i8, i16, i32, i64, u8, u16, u32, u64
• Go: int8, int16, int32, int64

Gleitkommazahlen

IEEE 754 Standard

• float (32-Bit): ~7 Dezimalstellen Präzision
• double (64-Bit): ~15-16 Dezimalstellen Präzision

Struktur

• Vorzeichenbit (1 Bit)
• Exponent (8 oder 11 Bits)
• Mantisse/Signifikand (23 oder 52 Bits)

Das berühmte Problem

0.1 + 0.2 = 0.30000000000000004

Dies geschieht, weil 0,1 und 0,2 in binärer Gleitkommadarstellung nicht exakt dargestellt werden können.

Zahlenbasisnotation nach Sprache

*C: Binärliterale in C23 hinzugefügt; C++14 und Java 7+ unterstützen sie.

JavaScript-Zahlen

Eigenschaften

• Alle Zahlen sind 64-Bit-Gleitkomma (IEEE 754)
• Sicherer Ganzzahlbereich: ±9.007.199.254.740.991 (2⁵³-1)
• BigInt für größere Ganzzahlen (ab ES2020)

Zahlenliterale

let dec = 255;        // Dezimal
let hex = 0xFF;       // Hexadezimal
let bin = 0b11111111; // Binär
let oct = 0o377;      // Oktal
let big = 9007199254740992n; // BigInt

Fallstricke

• 0.1 + 0.2 !== 0.3 (Gleitkomma)
• parseInt('08') === 8 (in modernem JS behoben)

Python-Zahlen

Eigenschaften

• Ganzzahlen haben beliebige Präzision (kein Überlauf)
• Floats sind 64-Bit IEEE 754
• Komplexe Zahlen eingebaut

Zahlenliterale

dec = 255          # Dezimal
hex_num = 0xFF     # Hexadezimal  
bin_num = 0b11111111  # Binär
oct_num = 0o377    # Oktal
complex_num = 3+4j # Komplex

Umwandlungen

bin(255)  # '0b11111111'
hex(255)  # '0xff'
oct(255)  # '0o377'
int('FF', 16)  # 255

Zahlen mit beliebiger Präzision

Wann benötigt

• Kryptografie (große Schlüssel)
• Finanzberechnungen (exaktes Dezimal)
• Wissenschaftliches Rechnen (extreme Präzision)

Sprachunterstützung

• Python: int (immer beliebige Präzision)
• JavaScript: BigInt (für Ganzzahlen)
• Java: BigInteger, BigDecimal
• C#: BigInteger, decimal

Beispiel: JavaScript BigInt

const big = 9007199254740993n;
const result = big * 2n;  // n-Suffix erforderlich

Formatierte Ausgabe

JavaScript

num.toString(2)   // Binärzeichenkette
num.toString(16)  // Hex-Zeichenkette
num.toFixed(2)    // 2 Dezimalstellen

Python

f"{255:b}"    # '11111111' (binär)
f"{255:x}"    # 'ff' (hex)
f"{255:08b}"  # '11111111' (aufgefüllt)

C/C++

printf("%d", num);   // Dezimal
printf("%x", num);   // Hex (Kleinbuchstaben)
printf("%X", num);   // Hex (Großbuchstaben)
printf("%o", num);   // Oktal

Bitweise Operationen

In den meisten Sprachen für Ganzzahltypen verfügbar:

Fazit

Programmiersprachen verarbeiten Zahlen über verschiedene Typen: Ganzzahlen fester Größe (int32, int64), Gleitkomma (float, double) und Typen mit beliebiger Präzision (BigInt, BigDecimal). Das Verständnis von Basisnotationen (0b, 0o, 0x-Präfixe) und der Einschränkungen jedes Typs – insbesondere Probleme mit der Gleitkommapräzision – hilft, subtile Fehler zu vermeiden. Wenn exakte Dezimalarithmetik wichtig ist (Finanzen, Währungen), verwenden Sie spezialisierte Dezimaltypen statt Gleitkomma.

Verwandte Artikel

• Binär in der Informatik: Wie Computer in Einsen und Nullen denken
• Anwendungen von Zahlensystemen: Wo verschiedene Basen eingesetzt werden