რა განსხვავებაა struct-სა და class-ს შორის Swift-ში?

Question

IT Interview Practice · Accepted Answer

`struct` არის **value type**: ის კოპირდება მინიჭებისას და თითოეული ასლი დამოუკიდებელია. `class` არის **reference type**: მინიჭებისას ერთი ინსტანცია ზიარდება და ორივე ცვლადი ერთსა და იმავე ობიექტზე მიუთითებს. სწორედ ეს ერთი განსხვავება განაპირობებს Swift-ში დიზაინის გადაწყვეტილებების უმეტესობას.

## როგორ მუშაობს

```swift
struct PointS { var x: Int }
class  PointC { var x: Int; init(x: Int) { self.x = x } }

var a = PointS(x: 1)
var b = a          // COPY — b is a separate struct
b.x = 99
print(a.x, b.x)    // => 1 99  (a unaffected)

let c = PointC(x: 1)
let d = c          // SHARE — same instance
d.x = 99
print(c.x, d.x)    // => 99 99 (both changed)
```

## კომპრომისები

| ასპექტი | struct (value) | class (reference) |
|--------|----------------|-------------------|
| კოპირების სემანტიკა | დამოუკიდებელი ასლი | ზიარი მიმართვა |
| ცვლილება | სჭირდება `var` / `mutating` | ცვალებადი ნებისმიერი მიმართვით |
| იდენტობა | არ აქვს (შედარება მნიშვნელობით) | `===` იდენტობა |
| მემკვიდრეობა | არა | კი |
| მეხსიერება | ჩვეულებრივ stack, ARC-ის გარეშე | heap, ARC-ით მართული |

struct-ებს ასევე სჭირდებათ `mutating`, რომ მეთოდში შენახული თვისებები შეცვალონ, რადგან მეთოდები ნაგულისხმევად იღებენ უცვლელ `self`-ს.

## როდის რომელი

- **ნაგულისხმევად აირჩიე `struct`** — Swift-ის სტანდარტული ბიბლიოთეკა (`Array`, `String`, `Int`) და SwiftUI-ის `View`-ები ყველა value type-ია. ისინი უსაფრთხოა threads-ს შორის გასაზიარებლად და არ აქვთ retain cycle-ები.
- გამოიყენე `class`, როცა გჭირდება **ზიარი ცვალებადი მდგომარეობა**, **იდენტობა**, **მემკვიდრეობა** ან Objective-C-თან თანამშრომლობა (`NSObject`).

## რატომ არის ეს მნიშვნელოვანი

value vs reference არჩევანი წყვეტს, ერთ ადგილას განხორციელებული ცვლილება მეორეში გაჟონავს თუ არა. ბაგები, სადაც „ერთი ელემენტის რედაქტირებამ ყველა შეცვალა“, მიმართვის მოულოდნელი გაზიარებიდან მოდის; SwiftUI-ის მთელი მოდელი ეყრდნობა იაფ, კოპირებად value-type view-ებს — ამიტომ ინტერვიუერები ამოწმებენ, ჯერ `struct`-ს მიმართავ თუ არა.

ასპექტი	struct (value)	class (reference)
კოპირების სემანტიკა	დამოუკიდებელი ასლი	ზიარი მიმართვა
ცვლილება	სჭირდება `var` / `mutating`	ცვალებადი ნებისმიერი მიმართვით
იდენტობა	არ აქვს (შედარება მნიშვნელობით)	`===` იდენტობა
მემკვიდრეობა	არა	კი
მეხსიერება	ჩვეულებრივ stack, ARC-ის გარეშე	heap, ARC-ით მართული

როგორ მუშაობს

კომპრომისები

როდის რომელი

რატომ არის ეს მნიშვნელოვანი

დაკავშირებული კითხვები