Swift-இல் struct-க்கும் class-க்கும் இடையிலான வேறுபாடு என்ன?

Question

IT Interview Practice · Accepted Answer

`struct` என்பது ஒரு **value type**: அது assignment-இல் copy செய்யப்படுகிறது, ஒவ்வொரு copy-யும் தனித்தன்மையானது. `class` என்பது ஒரு **reference type**: assignment ஒரே instance-ஐ பகிர்ந்துகொள்கிறது, இரண்டு variable-களும் ஒரே object-ஐ சுட்டிக்காட்டுகின்றன. இந்த ஒற்றை வேறுபாடு 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 | பகிரப்பட்ட reference |
| Mutation | `var` / `mutating` தேவை | எந்த reference மூலமாகவும் mutable |
| Identity | இல்லை (value-ஆல் compare) | `===` identity |
| Inheritance | இல்லை | உண்டு |
| Memory | பொதுவாக stack, ARC இல்லை | heap, ARC-managed |

ஒரு method-இல் stored property-களை மாற்ற struct-க்கு `mutating` தேவை, ஏனெனில் method-கள் இயல்பாக ஒரு immutable `self`-ஐப் பெறுகின்றன.

## எதை எப்போது பயன்படுத்துவது

- **இயல்பாக `struct`-ஐ பயன்படுத்துங்கள்** — Swift-இன் standard library (`Array`, `String`, `Int`) மற்றும் SwiftUI `View`-கள் அனைத்தும் value type-கள். அவை thread-கள் முழுவதும் பகிர்வதற்குப் பாதுகாப்பானவை மற்றும் retain cycle-கள் இல்லை.
- **shared mutable state**, **identity**, **inheritance**, அல்லது Objective-C interop (`NSObject`) தேவைப்படும்போது `class`-ஐ பயன்படுத்துங்கள்.

## இது ஏன் முக்கியம்

value vs reference-ஐ தேர்ந்தெடுப்பது ஒரு இடத்தில் ஏற்படும் மாற்றம் மற்றொரு இடத்திற்குள் கசிகிறதா என்பதைத் தீர்மானிக்கிறது. "ஒரு item-ஐ edit செய்தால் அனைத்தையும் edit செய்தது" போன்ற bug-கள் எதிர்பாராத reference பகிர்விலிருந்து வருகின்றன; SwiftUI-இன் முழு model-உம் மலிவான, copy-செய்யக்கூடிய value-type view-களை அனுமானிக்கிறது — எனவே நீங்கள் முதலில் `struct`-ஐ நாடுகிறீர்களா என்பதை interviewer-கள் சரிபார்க்கிறார்கள்.

அம்சம்	struct (value)	class (reference)
Copy semantics	தனித்தன்மையான copy	பகிரப்பட்ட reference
Mutation	`var` / `mutating` தேவை	எந்த reference மூலமாகவும் mutable
Identity	இல்லை (value-ஆல் compare)	`===` identity
Inheritance	இல்லை	உண்டு
Memory	பொதுவாக stack, ARC இல்லை	heap, ARC-managed

இது எப்படி வேலை செய்கிறது

Trade-offs

எதை எப்போது பயன்படுத்துவது

இது ஏன் முக்கியம்

தொடர்புடைய கேள்விகள்