Swift Academy · Lektion

Gemischte Wert-/Referenzgraphen

Structs mit enthaltenen Klassen: die verborgene Referenzsemantik und der richtige Umgang damit.

Gemischte Wert-/Referenzgraphen ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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

Structs können Klassen als gespeicherte Eigenschaften enthalten. In diesem Fall verhält sich das Struct nach außen wie ein Werttyp, teilt intern jedoch die Klassenreferenz – eine subtile Fehlerquelle.

Ein Struct mit einer Klasse

```swift class Storage { var data: [Int] = [] } struct Container { var storage = Storage() var label: String = "" } var a = Container() var b = a // copies label, but SHARES storage! a.storage.data.append(1) print(b.storage.data) // [1] — shared! ```

Nur Werteigenschaften werden kopiert

Wenn ein Struct kopiert wird: • Eigenschaften mit Werttyp (`label: String`) werden vollständig kopiert • Eigenschaften mit Referenztyp (`storage: Storage`) – nur der Zeiger wird kopiert Dies wird als *flache Kopie* bezeichnet.

Eine tiefe Kopie erstellen

```swift struct Container { var storage: Storage func deepCopy() -> Container { let newStorage = Storage() newStorage.data = storage.data // copy values return Container(storage: newStorage, label: label) } } ```

COW zur Rettung

Die collections von Swift vermeiden dies, indem sie COW verwenden: ```swift struct SafeContainer { private(set) var storage = Storage() mutating func append(_ n: Int) { if !isKnownUniquelyReferenced(&storage) { storage = storage.copy() // copy before mutating } storage.data.append(n) } } ```

Klassen mit Structs

```swift class ViewModel { var point = CGPoint(x: 0, y: 0) // value type inside reference type } let vm1 = ViewModel() let vm2 = vm1 // same ViewModel! vm1.point.x = 5 print(vm2.point.x) // 5 — shared because ViewModel is a class ```

Identität und Gleichheit

```swift class Dog { var name: String = "" } let x = Dog() let y = x print(x === y) // true — same object print(x !== y) // false let z = Dog() print(x === z) // false — different objects ```

Rekursives Struct über eine Klasse

Structs können nicht auf sich selbst verweisen, aber eine Klasse enthalten, die auf das Struct verweist: ```swift struct Tree { var value: Int var children: [Tree] // OK — Array uses class internally } ```

Unerwartetes Teilen erkennen

Verwenden Sie `isKnownUniquelyReferenced` zur Laufzeit, um geteilte Referenzen zu erkennen: ```swift var s = Storage() var r: AnyObject = s print(isKnownUniquelyReferenced(&s)) // true var s2 = s print(isKnownUniquelyReferenced(&s)) // false — shared ```

Richtlinien für das Design

Wenn ein Struct veränderlichen Zustand eines Referenztyps enthalten muss: 1. Implementieren Sie COW, um die Wertsemantik wiederherzustellen 2. Oder verwenden Sie eine unveränderliche Klasse: `let` statt `var` für die Klasseneigenschaft 3. Oder überarbeiten Sie das Design – vielleicht sollte das Struct eine Klasse sein Dokumentieren Sie eindeutig, wenn die gemeinsame Nutzung beabsichtigt ist.

Kurze Überprüfung

Was passiert mit der Klasse, wenn Sie ein Struct kopieren, das eine Klasseneigenschaft enthält?

Zusammenfassung

Die wichtigsten Punkte: • Eine Struct-Kopie ist flach – Klassenreferenzen werden geteilt • `isKnownUniquelyReferenced` erkennt geteilte Referenzen zur Laufzeit • Implementieren Sie COW, um eine echte Wertsemantik wiederherzustellen • `===` / `!==` prüfen die Objektidentität von Klassen • Rekursive Strukturen verwenden Array (intern klassenbasiert) als children Als Nächstes: APIs für Wertsemantik entwerfen.

Häufig gestellte Fragen

Ist die Lektion „Gemischte Wert-/Referenzgraphen“ kostenlos?

Ja — der vollständige Text von „Gemischte Wert-/Referenzgraphen“ 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 „Gemischte Wert-/Referenzgraphen“?

Structs mit enthaltenen Klassen: die verborgene Referenzsemantik und der richtige Umgang damit. 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 3 von 4.

Wie lange dauert die Lektion „Gemischte Wert-/Referenzgraphen“?

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