Swift Academy · Lekcja

Jak ARC zlicza odwołania

Działanie ARC podczas kompilacji, wywołania retain/release i cykle życia obiektów.

Jak ARC zlicza odwołania to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 1 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

Automatic Reference Counting (ARC) zarządza pamięcią instancji klas. Zrozumienie sposobu zliczania referencji pomaga pisać kod wolny od wycieków pamięci.

Działanie ARC

ARC śledzi liczbę *silnych* referencji wskazujących na każdą instancję klasy. Gdy licznik osiągnie zero, ARC wywołuje `deinit` i zwalnia pamięć — automatycznie.

Silne referencje

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

ARC działa w czasie kompilacji

ARC wstawia wywołania retain/release w czasie kompilacji — a nie w czasie działania, jak moduł odśmiecania pamięci. Oznacza to: • Brak okresowych wstrzymań działania przez GC • Deterministyczne zwalnianie pamięci • Niewielki narzut na rozmiar kodu wynikający z wywołań retain/release

Ryzyko cyklu silnych referencji

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

Zliczanie za pomocą wielu zmiennych

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

```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 NIE dotyczy typów wartości

Struktury, enumeracje i krotki NIE są objęte zliczaniem referencji: ```swift struct Point { var x, y: Double } // no retain/release var p1 = Point(x:1,y:2) var p2 = p1 // copy — no ARC ```

Obserwowanie ARC za pomocą deinit

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

Wydajność ARC a GC

• GC: okresowo wstrzymuje wykonywanie, aby przeprowadzić odśmiecanie; kompromis między przepustowością a opóźnieniem • ARC: zwalnia pamięć natychmiast po osiągnięciu przez licznik wartości 0; nie powoduje wstrzymań • Narzut ARC: każde przypisanie za pośrednictwem silnej referencji kosztuje parę retain/release

Szybkie sprawdzenie

Kiedy ARC wywołuje `deinit` i zwalnia pamięć obiektu?

Podsumowanie

Najważniejsze informacje: • ARC śledzi silne referencje do instancji klas • Licznik równy 0 → wywołanie `deinit` → zwolnienie pamięci • ARC działa w czasie kompilacji — brak wstrzymań przez GC • Typy wartości (`struct`/`enum`) nie są zarządzane przez ARC • Cykle uniemożliwiają osiągnięcie przez licznik wartości 0 → używaj `weak`/`unowned` Dalej: cykle referencji.

Często zadawane pytania

Czy lekcja „Jak ARC zlicza odwołania” jest bezpłatna?

Tak — pełny tekst „Jak ARC zlicza odwołania” 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 „Jak ARC zlicza odwołania”?

Działanie ARC podczas kompilacji, wywołania retain/release i cykle życia obiektów. Ć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 1 z 4.

Ile czasu zajmuje lekcja „Jak ARC zlicza odwołania”?

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

Jak ARC zlicza odwołania
Cykle retain: przyczyny i wykrywanie
Odwołania weak i unowned
Listy przechwytywania domknięć i [weak self]

← Powrót do Swift Academy