Swift Academy · Lekcja

Mieszane grafy wartości i odwołań

Struktury zawierające klasy: ukryta semantyka odwołań i sposoby radzenia sobie z nią.

Mieszane grafy wartości i odwołań to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Swift Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Swift Academy zawiera 4 lekcji w sumie.

Wprowadzenie

Struktury mogą zawierać klasy jako przechowywane właściwości. W takim przypadku struktura z zewnątrz zachowuje się jak typ wartości, ale wewnątrz współdzieli referencję do klasy — jest to subtelna pułapka.

Struktura zawierająca klasę

```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! ```

Kopiowane są tylko właściwości będące typami wartości

Podczas kopiowania struktury: • Właściwości będące typami wartości (`label: String`) są w pełni kopiowane • Właściwości będące typami referencyjnymi (`storage: Storage`) — kopiowany jest tylko wskaźnik Nazywa się to *kopią płytką*.

Tworzenie kopii głębokiej

```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 na ratunek

Kolekcje wbudowane w Swift unikają tego problemu, używając COW: ```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) } } ```

Klasy zawierające struktury

```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 ```

Tożsamość a równość

```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 ```

Rekurencyjna struktura za pośrednictwem klasy

Struktury nie mogą odwoływać się do samych siebie, ale mogą zawierać klasę, która odwołuje się do struktury: ```swift struct Tree { var value: Int var children: [Tree] // OK — Array uses class internally } ```

Wykrywanie nieoczekiwanego współdzielenia

Użyj `isKnownUniquelyReferenced` w czasie działania, aby wykryć współdzielenie: ```swift var s = Storage() var r: AnyObject = s print(isKnownUniquelyReferenced(&s)) // true var s2 = s print(isKnownUniquelyReferenced(&s)) // false — shared ```

Wskazówki projektowe

Gdy struktura musi przechowywać zmienny stan będący typem referencyjnym: 1. Zaimplementuj COW, aby przywrócić semantykę wartości 2. Użyj niezmiennej klasy: `let` zamiast `var` dla właściwości klasy 3. Przeprojektuj rozwiązanie — być może struktura powinna być klasą Jasno dokumentuj, kiedy współdzielenie jest zamierzone.

Szybkie sprawdzenie

Co dzieje się z klasą podczas kopiowania struktury zawierającej właściwość będącą klasą?

Podsumowanie

Najważniejsze informacje: • Kopia struktury jest płytka — referencje do klas są współdzielone • `isKnownUniquelyReferenced` wykrywa współdzielenie w czasie działania • Zaimplementuj COW, aby przywrócić prawdziwą semantykę wartości • `===` / `!==` sprawdzają tożsamość obiektu w przypadku klas • Struktury rekurencyjne używają tablicy (`Array`, opartej wewnętrznie na klasie) jako kolekcji elementów potomnych Dalej: projektowanie API z semantyką wartości.

Często zadawane pytania

Czy lekcja „Mieszane grafy wartości i odwołań” jest bezpłatna?

Tak — pełny tekst „Mieszane grafy wartości i odwołań” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Swift Academy, przejdź na CoddyKit PRO. Kurs Swift Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Mieszane grafy wartości i odwołań”?

Struktury zawierające klasy: ukryta semantyka odwołań i sposoby radzenia sobie z nią. Ćwiczysz Swift Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Swift Academy?

Nie wymagamy żadnego doświadczenia. Swift Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Mieszane grafy wartości i odwołań”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Swift Academy?

Tak. Każda lekcja Swift Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Stos a sterta: gdzie przechowywane są wartości
Mutowanie, współdzielenie i nieoczekiwane aliasowanie
Mieszane grafy wartości i odwołań
Projektowanie API z semantyką wartości

← Powrót do Swift Academy