• Bisher:
  • Elementare Datentypen, wie z. B. int, bool, char, float
  • Bitoperationen und Byte-Order sind ebenfalls bekannt
• Was noch fehlt:
  • Interner Aufbau der Datentypen
    • Zweierkomplement
    • IEEE-754
  • Konvertierung zwischen den Datentypen

• Zur Erinnerung: Gleitkommazahlen im Standard IEEE 754 definiert
• In C Unterscheidung zwischen
  • einfacher Genauigkeit (32 Bit → float) und
  • doppelter Genauigkeit (64 Bit → double)
• Außerdem noch (nicht in C):
  • Halbe Genauigkeit (16 Bits)
  • Vierfache Genauigkeit (128 Bits)
  • Achtfache Genauigkeit (256 Bits)

Schauen wir uns die Kodierung einmal im Detail an

• Wie kann Gleitkommazahl dargestellt werden?

Was bedeutet das jetzt alles? 🤯

• Aufbau einer Gleitkommazahl mit einfacher Genauigkeit (32 Bit)

• Höchstwertiges Bit
• Mögliche Werte:
  • 0 → positive Zahl
  • 1 → negative Zahl
• Deswegen ist das Vorzeichen in der Formel auch als \((-1)^S\) dargestellt

• Darstellung mit Bias:

  Auf den Exponent wird zusätzlich immer eine Konstante addiert

• Konstante abhängig von der Genauigkeit der Gleitkommazahl

  • Ist für jede Genauigkeit fest
  • Einfache Genauigkeit → Bias \(B = 127\)

• Warum so kompliziert?
• Wozu die Verwendung eines Bias?

• Nachkommateil \(M\) einer Zahl in binärer Darstellung
• Bestimmung

  • Verschiebe das Komma bis eine 1 vor dem Komma steht

  • Das höchstwertige Bit ist Vorkommaanteil

    (implizite 1, wird nicht gespeichert)

  • Restlichen Bits entsprechen dem Nachkommaanteil \(M\)

• Beispiel: 8.125_D = 1000.001

  • Verschiebung des Kommas, bis nur das MSBit noch vor dem Komma steht

    → 1.000001 \(\cdot 2^3\)

  • Exponent entspricht Anzahl an verschobenen Stellen

    → \(E = 3 + B = 3 + 127 = 130\)

• Beispiele bis hierher gelten nur für einfache Genauigkeit

• Berechnungsformel ist allerdings für alle gleich

  • Float \(F = (-1)^S \cdot (1 + M) \cdot (2)^E\)

• Unterschiede: Wertebereich, Bias und Bitbreite von Exponent und Mantisse

  → Ansonsten kein Unterschied in der Berechnung!

• Nachkommastellen sind in ebenfalls gut darstellbar
• Beispiel: 16.625_D
• Vorkommaanteil: Ist einfach→ $2^4 = $ 0001 0000

• Gleitkommazahlen ungeeignet für exakte Darstellung beliebiger Zahlen:
• 0.375_D = 0.011 → \(2^{-2}+ 2^{-3}\)
• Aber: 0.1_D nicht genau darstellbar → Rundung auf nächste darstellbare Zahl
• Verschiedene Rundungsstrategien:
  • Immer aufrunden (zu \(+\infty\))
  • Immer abrunden (zu \(-\infty\))
  • Immer Richtung Null runden

Es gibt verschiedene Online-Tools für das Darstellen von IEEE-754-Zahlen, zum Beispiel auf weltz.de

• Genau Null
  • Exponent und Mantisse haben jeweils Wert 0
  • Vorzeichen unterscheidet zwischen +0 und -0
• Infinity (\(\infty\))
  • Alle Bits im Exponent gesetzt, Mantisse hat Wert 0
  • Vorzeichenbit bestimmt \(\pm \infty\)
• NaN (Not a Number)
  • Kodiert mathematisch nicht erlaubte Operationen (z.B. Division durch 0)
  • Exponentbits alle gesetzt, aber Mantisse hat Wert \(\neq\) 0

• Beispiel: Aus 16.625 = 10000.101_B wird:

  1. Verschiebe Komma bis hinter die höchste Stelle → 1.0000101 \(\cdot 2^4\)

  2. Exponenten $E= 4 + 127 = 131 = $ 10000011

  3. Mantisse \(M\) entspricht Nachkommaanteil → 0000101

  4. Vorzeichenbit \(S\): Zahl positiv → 0

• Berechnung von Gleitkommazahlen braucht auf der CPU viele Schritte

  → Verwendung von Gleitkommazahlen ist ein Flaschenhals

• Einsatz spezialisierter Hardware-Komponente nur für Gleitkommazahlen:

  → Floating-Point Unit (FPU)

• Auf allen modernen CPUs enthalten

• Einige alte CPUs und Mikrocontroller enthalten diese aber nicht

• Falls nicht vorhanden, dann Rückfall auf Software-Berechnung

• Und wenn wir eine feste Anzahl an Nachkommastellen benötigen?

• Lösung: Fixed-Point-Zahlen

• Nur per Software möglich, keine übliche Hardware-Komponente

• Eigene Umsetzung notwendig, C bietet keine vorhandene Implementierung

• Beispiel: 16.375_D in Fixed-Point-Notation mit 2 Nachkommastellen

  10000.011 → 010000.01 (Fixed-Point)

• Wir kennen jetzt fast alles Grundlegende, was elementare Datentypen angeht!

• Vorgehen: „Ergänze eine positive Zahl in Binärdarstellung um Vorzeichenbit”
  • 0 → positiv
  • 1 → negativ
• Beispiel: -3 = 1 11
• Vorteil: Einfach zu lesen und zu konvertieren
• Aber: Es kostet Mehraufwand
  • Hälfte des Zahlenraums geht an das Vorzeichen verloren
  • 0 wird doppelt kodiert: \(+0\) → 00 und \(-0\) → 10

• Bitbreite: 1 Byte = 8 Bit
• Beispiel: -79_D

• Beispiel: -255_D

→ Bei fester Byte-Größe Überlauf in das nächste Byte (7 Bits verschwendet)

• Positive Zahl: Keine Veränderung der Binärdarstellung – wie bisher
• Negative Zahl
  • Umwandlung in Binärdarstellung
  • Invertiere den Wert jedes Bits
  → Negative Zahlen haben ebenfalls 1 als MSBit
• Beispiel:
  • +79 → 0100 1111_B
  • -79 → 1011 0000₁
• Auch hier gilt: 0 wird doppelt kodiert mit +0 (00₁) und -0 (11₁)

• MSB ist 0: Umwandlung in Dezimal wie bisher
• MSB ist 1:
  1. Wandle die Binärzahl in Dezimalzahl um
  2. Addiere 1
• Beispiel: -79

1. Summe der Bitwertigkeiten: -128 + 32 + 16 = -80
2. Addiere 1: -80 + 1 = -79

• Positive Zahl: Keine Veränderung der Binärdarstellung
• Negative Zahl:
  1. Umwandlung in Binärdarstellung
  2. Invertiere jedes Bit
  3. Addiere 1
• Vorteile des Zweierkomplements:

  • Keine Überprüfung auf das Vorzeichen

    → Addition und Subtraktion sind identische Operationen

  • Keine doppelte Darstellung der 0

• Dies ist die in Computern übliche Darstellung

• Computer verwenden intern das Zweierkomplement

• Aufwand für Konvertierung < Aufwand für Rechenoperationen

• Anstatt zwei Operationen

  1. Prüfen des Vorzeichenbit
  2. anschließend Addieren oder Subtrahieren

• Nur noch eine Operation: Addition

• Achtung: Auf der Hardware kommt noch die Byte-Order hinzu!

  → Wichtig, wenn Speicher direkt ausgelesen wird

• Bisher: Darstellung von Datentypen in Hardware
• Es fehlt: Umwandlung von Datentypen
• In der CPU? Egal. Abfolge von Bits von Bytes
• Interpretation der Bitfolge geschieht auf höherer Ebene nach fest definierten Regeln

• Bereits bekannt: Implizite Umwandlung (automatisch) in einen Datentyp

  → Skalar zu booleschem Ausdruck bei if-Blöcken

• Alternativ: float zu int bei Zuweisung (und umgekehrt)

  float f = 3;

• Es fehlt: explizite Umwandlung (manuell) in einen Datentyp, z. B. int zu double

🚨 Achtung: Unerwartete Fehler bei Zwischenschritten durch Umwandlungen

#include <stdio.h>
int main() {
    int i = 13, j = 4;
    double d = i / j;
    printf("%#.02f\n", d);
    return 0;
}

Warum geschieht das?

#include <stdio.h>
int main() {
    int i = 13, j = 4;
    double d = (double)i / j;
    printf("%#.02f\n", d);
    return 0;
}

• Lösung: explizites Type-Casting: double d = (double) i / j;

• In C++ prinzipiell ähnlich, aber einige wichtige Unterschiede
• Explizite Umwandlung in C++ nicht gern gesehen:
  • Geschieht unbedingt
  • Untergräbt das Typensystem des Compilers
• Compiler überprüft in C++ bereits mögliche Fehler oder Probleme
  • In C treten Fehler erst zur Laufzeit auf
  • C++ hat feiner unterteilte Möglichkeiten zur Typenumwandlung
  • Verteilt Funktionalität von C-Style-Casting auf verschiedene Funktionen

• static_cast
  • Konvertierung unter Berücksichtigung impliziter Regeln
  • double d = static_cast<double>(3);
• reinterpret_cast:
  • Ähnlich zu C-Style-Cast, Uminterpretierung auf Bitebene (gefährlich)
  • int i = reinterpret_cast<int>(3.5f);
• (const_cast)
• (dynamic_cast)

• Erinnerung an Integer

  🚨 Breite in Bits ist abhängig von der Hardwarearchitektur! 🚨

• Unerwartete Effekte bei Type Casting möglich

  Besonders bei int auf unterschiedlichen CPU-Architekturen

• Dringende Empfehlung: Stattdessen Datentypen mit fester Breite verwenden

  → uint8_t, uint16_t, uint32_t, uint64_t

  → int8_t, int16_t, int32_t, int64_t

• Einbindung über den Header <stdint.h>

int32_t i32 = 0;
uint8_t ui8 = 0;