Swift Academy · Lektion

Wie ARC Referenzen zählt

Was ARC zur Compile-Zeit tut, retain-/release-Aufrufe und Objektlebensdauern.

Wie ARC Referenzen zählt 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

Automatic Reference Counting (ARC) verwaltet den Speicher von Klasseninstanzen. Wenn Sie verstehen, wie ARC Referenzen zählt, können Sie Code ohne Speicherlecks schreiben.

Was ARC tut

ARC verfolgt, wie viele *starke* Referenzen auf jede Klasseninstanz zeigen. Sobald der Zähler null erreicht, ruft ARC `deinit` auf und gibt den Speicher automatisch frei.

Starke Referenzen

```swift var a: Dog? = Dog(name: "Rex") // count = 1 var b = a // count = 2 a = nil // count = 1 b = nil // count = 0 → deinit ```

ARC arbeitet zur Compile-Zeit

ARC fügt Aufrufe von retain/release zur Compile-Zeit ein – nicht zur Laufzeit wie ein Garbage Collector. Das bedeutet: • Keine Pausen durch eine Garbage Collection • Deterministisches Freigeben von Speicher • Leichter Overhead bei der Codegröße durch retain/release-Aufrufe

Risiko durch starke Referenzzyklen

```swift class Node { var next: Node? } var n1: Node? = Node() var n2: Node? = Node() n1?.next = n2 n2?.next = n1 // cycle! n1 = nil; n2 = nil // both stuck at count=1 — leaked! ```

Zählen mit mehreren Variablen

```swift class Engine {} var car1: Engine? = Engine() // count = 1 var car2 = car1 // count = 2 var car3 = car2 // count = 3 car1 = nil // count = 2 car2 = nil // count = 1 // Engine still alive — car3 holds it car3 = nil // count = 0 → deinit ```

ARC in Collections

```swift var dogs: [Dog] = [] dogs.append(Dog(name:"A")) // count = 1 dogs.append(Dog(name:"B")) // count = 1 each dogs.removeAll() // both deinit called ```

ARC gilt NICHT für Werttypen

Structs, Enums und Tupel werden NICHT über Referenzen gezählt: ```swift struct Point { var x, y: Double } // no retain/release var p1 = Point(x:1,y:2) var p2 = p1 // copy — no ARC ```

ARC mit deinit beobachten

```swift class Cat { let name: String init(name: String) { self.name = name; print("\(name) born") } deinit { print("\(name) deallocated") } } var c: Cat? = Cat(name: "Luna") c = nil // "Luna deallocated" printed ```

ARC und GC im Leistungsvergleich

• GC: unterbricht die Ausführung regelmäßig zum Sammeln; Kompromiss zwischen Durchsatz und Latenz • ARC: gibt den Speicher sofort frei, wenn der Zähler 0 erreicht; keine Pausen • ARC-Overhead: Jede Zuweisung über eine starke Referenz verursacht ein retain/release-Paar

Kurze Überprüfung

Wann ruft ARC `deinit` auf und gibt den Speicher eines Objekts frei?

Zusammenfassung

Die wichtigsten Punkte: • ARC verfolgt starke Referenzen auf Klasseninstanzen • Zähler 0 → `deinit` wird aufgerufen → Speicher wird freigegeben • ARC arbeitet zur Compile-Zeit – keine GC-Pausen • Werttypen (struct/enum) werden nicht von ARC verwaltet • Zyklen verhindern, dass der Zähler 0 erreicht → verwenden Sie weak/unowned Als Nächstes: Referenzzyklen.

Häufig gestellte Fragen

Ist die Lektion „Wie ARC Referenzen zählt“ kostenlos?

Ja — der vollständige Text von „Wie ARC Referenzen zählt“ 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 „Wie ARC Referenzen zählt“?

Was ARC zur Compile-Zeit tut, retain-/release-Aufrufe und Objektlebensdauern. 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 „Wie ARC Referenzen zählt“?

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

← Zurück zu Swift Academy