Skip to content
Modul 20 — Unsafe Code: Verträge, Rohe Zeiger & Undefined Behavior
6

Pointer-Arithmetik, Sizes & Unions

Lektion 6 von 7

Zeiger-Arithmetik und Größen

Der Compiler kennt Größe und Ausrichtung jedes Typs. Für rohe Zeiger gibt es Methoden, die in Einheiten zählen (nicht in Bytes):

use std::mem;

let arr = [1u8, 2, 3, 4];
let ptr = arr.as_ptr();

// Zeiger n Elemente weiter bewegen (in T-Einheiten, hier Bytes):
let third = unsafe { *ptr.add(2) };
assert_eq!(third, 3);

println!("usize: {}", mem::size_of::<usize>());
// → usize: 8
  • .add(n) bewegt um n Elemente (Typr-basiert), .offset(n) ähnlich
  • size_of::<T>() / align_of::<T>() geben Größe/Ausrichtung
  • Der Vertrag: nur innerhalb der Grenzen des ursprünglichen Objekts bewegen

Unions

Eine union ist ein Strukturtyp aus C, dessen Felder alle am selben Speicherort liegen:

union UnspecifiedShape {
    circle: u32,
    rectangle: u32,
}

Anders als ein enum trägt eine Union keine Kennung, welches Feld initialisiert ist. Deshalb ist das Lesen aus einem Feld einer Union unsafe — nur das Schreiben ist sicher. Unions nutzt du fast nur für FFI / C-Kompatibilität.

Wie verhält sich enum vs union?

Ein enum hat eine Tag (Kennung), die angibt, welche Variante vorliegt — der Compiler weiß das. Eine union hat keine solche Kennung: Alle Felder liegen am selben Offset, und es gibt keine Information, welches gültig ist. Daher ist Lesen aus einer Union unsafe, außer du kennst den aktiven Wert.

⚠ Häufiger Fehler: .add(n) zählt Elemente, nicht Bytes: Auf einem *const u32 bewegt add(4) den Zeiger um 16 Bytes. Wer byte-weise denkt, liest am Ende des Arrays vorbei — sofort UB, oft ohne sichtbare Folge. Für echte Byte-Schritte gibt es .byte_add(n).

✅ Wichtige Erkenntnisse

0/3

Haken setzen, um deinen Lernfortschritt zu markieren:

  • Rufe dir die Kernpunkte in Erinnerung, bevor du die Liste aufdeckst.

Erinnerungstraining

Tippe den fehlenden Begriff aus dem Gedächtnis ein und prüfe.

Die Methode bewegt einen rohen Zeiger um n Elemente weiter — gezählt in Einheiten von T, nicht Bytes.
gibt die Größe eines Typs T in Bytes zurück; align_of::<T>() die Ausrichtung.
Eine union trägt im Gegensatz zum enum keine , welches Feld initialisiert ist — deshalb ist das Lesen unsafe.
0 von 3 richtig

This site uses essential cookies for Stripe payments. No tracking cookies.