Swift Academy · Lektion

Stack vs. Heap: Wo Werte liegen

Wie Structs auf dem Stack und Klassen auf dem Heap liegen und welche Auswirkungen dies auf die Leistung hat.

Stack vs. Heap: Wo Werte liegen ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Willkommen

Zu verstehen, wo Swift-Werte im Speicher liegen – auf dem Stack oder im Heap – ist entscheidend, um performanten und vorhersehbaren Code zu schreiben.

Der Stack

Der Stack ist ein zusammenhängender Speicherbereich, der automatisch verwaltet wird: • Lokale Variablen und Parameter von Funktionen liegen hier • Die Allokation ist O(1) – es muss lediglich ein Zeiger verschoben werden • Der Speicher wird beim Verlassen des Gültigkeitsbereichs automatisch freigegeben • Thread-lokal – jeder Thread besitzt seinen eigenen Stack

Der Heap

Der Heap ist ein gemeinsam genutzter Speicherpool für langlebige Allokationen: • Objekte liegen hier, wenn ihre Lebensdauer über einen Gültigkeitsbereich hinausgeht • Für die Allokation muss freier Speicher gefunden werden – sie ist daher aufwendiger • Bei Klassen wird der Speicher durch ARC verwaltet • Der Heap wird von mehreren Threads gemeinsam genutzt – eine Synchronisierung ist erforderlich

Structs liegen auf dem Stack

```swift func compute() { var pt = CGPoint(x: 3, y: 4) // on the stack pt.x += 1 } // pt freed automatically ``` Kleine Structs werden per Kopie übergeben – ohne zusätzlichen Heap-Aufwand.

Klassen liegen auf dem Heap

```swift class Dog { var name: String init(name: String) { self.name = name } } var d = Dog(name: "Rex") // Dog instance on heap // 'd' is a pointer on the stack ```

Große Structs können den Heap verwenden

Große Structs (Arrays, Strings und große Werttypen) verwenden intern COW und Heap-Speicher, obwohl sie sich wie Werttypen verhalten: ```swift var arr = [Int](repeating: 0, count: 10_000) // The array's buffer is on the heap; 'arr' itself is a stack value ```

Erfassen in Closures

Wenn eine Closure eine Variable eines Werttyps erfasst, die den Gültigkeitsbereich überleben muss, legt Swift sie in einer Box auf dem Heap ab: ```swift var count = 0 let increment = { count += 1 } // count captured in a heap box increment() print(count) // 1 ```

Boxing von Protokoll-Existentials

Das Speichern kleiner Werttypen in Variablen vom Typ `any Protocol` kann eine Heap-Allokation verursachen (Existential-Boxing): ```swift var shape: any Shape = Circle(radius: 5) // may allocate on heap ``` Kleine Typen (≤3 Wörter) werden inline gespeichert; größere Typen werden in einer Box abgelegt.

Allokationen messen

Verwenden Sie das Instruments-Template „Allocations“, um Heap-Allokationen zu sehen: 1. Profile > Allocations 2. Nach Klasse oder Kategorie filtern 3. Die Anzahl von `alloc` und `dealloc` verfolgen Eine hohe Anzahl von Allokationen in Schleifen weist häufig auf unerwartetes Boxing hin.

Auswirkungen auf das Design

• Bevorzugen Sie Structs für kurzlebige Datentypen – Geschwindigkeit des Stacks • Verwenden Sie Klassen, wenn Identität oder gemeinsam genutzter Zustand erforderlich ist • Vermeiden Sie Allokationen in engen Schleifen – allokieren Sie mit `reserveCapacity` vor • Führen Sie vor der Optimierung ein Profiling durch – vorzeitige Optimierung kostet Zeit

Kurze Überprüfung

Welcher Speichertyp wird automatisch freigegeben, wenn der Gültigkeitsbereich einer Funktion verlassen wird?

Zusammenfassung

Wichtige Erkenntnisse: • Stack: günstig, automatisch verwaltet, Thread-lokal, Werttypen • Heap: flexibel, durch ARC verwaltet, Referenztypen • Große Structs verwenden interne Heap-Puffer (COW) • Closures, die Variablen erfassen, legen diese in einer Box auf dem Heap ab • Verwenden Sie Instruments Allocations, um unerwartete Heap-Auslastung zu erkennen Als Nächstes: Mutation, gemeinsamer Zugriff und unerwartetes Aliasing.

Häufig gestellte Fragen

Ist die Lektion „Stack vs. Heap: Wo Werte liegen“ kostenlos?

Ja — der vollständige Text von „Stack vs. Heap: Wo Werte liegen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Swift Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Stack vs. Heap: Wo Werte liegen“?

Wie Structs auf dem Stack und Klassen auf dem Heap liegen und welche Auswirkungen dies auf die Leistung hat. Du übst Swift Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Swift Academy zu starten?

Keine Vorkenntnisse erforderlich. Swift Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Stack vs. Heap: Wo Werte liegen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Swift Academy-Lektion Code schreiben und ausführen?

Ja. Jede Swift Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Stack vs. Heap: Wo Werte liegen
Mutation, gemeinsames Nutzen und unerwartete Aliase
Gemischte Wert-/Referenzgraphen
APIs für Wertsemantik entwerfen

← Zurück zu Swift Academy