Swift માં struct અને class વચ્ચે શું ફરક છે?

Question

IT Interview Practice · Accepted Answer

`struct` એ **value type** છે: assignment પર તેની copy બને છે, અને દરેક copy સ્વતંત્ર હોય છે. `class` એ **reference type** છે: assignment એક જ instance ને share કરે છે, અને બંને variable એક જ object તરફ point કરે છે. આ એક જ ફરક Swift માં મોટાભાગના design નિર્ણયોને દોરે છે.

## તે કેવી રીતે કામ કરે છે

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

## Trade-offs

| પાસું | struct (value) | class (reference) |
|--------|----------------|-------------------|
| Copy semantics | સ્વતંત્ર copy | shared reference |
| Mutation | `var` / `mutating` જોઈએ | કોઈપણ reference થી mutable |
| Identity | કોઈ નહીં (value થી compare) | `===` identity |
| Inheritance | નહીં | હા |
| Memory | સામાન્ય રીતે stack, ARC નહીં | heap, ARC-managed |

Struct ને method માં stored property બદલવા માટે `mutating` પણ જોઈએ, કારણ કે method ને default રૂપે immutable `self` મળે છે.

## ક્યારે કયું વાપરવું

- **Default રૂપે `struct` વાપરો** — Swift ની standard library (`Array`, `String`, `Int`) અને SwiftUI `View` બધા value type છે. તેઓ thread વચ્ચે share કરવા સુરક્ષિત છે અને તેમાં retain cycle નથી.
- જ્યારે તમને **shared mutable state**, **identity**, **inheritance**, અથવા Objective-C interop (`NSObject`) જોઈએ ત્યારે `class` વાપરો.

## આ શા માટે મહત્વનું છે

Value vs reference ની પસંદગી નક્કી કરે છે કે એક જગ્યાએ થયેલો ફેરફાર બીજી જગ્યાએ લીક થાય કે નહીં. "એક item edit કરવાથી બધા edit થઈ ગયા" જેવા bug અણધાર્યા reference sharing થી આવે છે; SwiftUI નું આખું model સસ્તા, copyable value-type view ધારે છે — તેથી interviewer તપાસે છે કે તમે પહેલા `struct` તરફ વળો છો કે નહીં.

પાસું	struct (value)	class (reference)
Copy semantics	સ્વતંત્ર copy	shared reference
Mutation	`var` / `mutating` જોઈએ	કોઈપણ reference થી mutable
Identity	કોઈ નહીં (value થી compare)	`===` identity
Inheritance	નહીં	હા
Memory	સામાન્ય રીતે stack, ARC નહીં	heap, ARC-managed

તે કેવી રીતે કામ કરે છે

Trade-offs

ક્યારે કયું વાપરવું

આ શા માટે મહત્વનું છે

સંબંધિત પ્રશ્નો