Quelle est la différence entre struct et class en Swift ?

Question

IT Interview Practice · Accepted Answer

Un `struct` est un **value type** : il est copié lors de l'affectation, et chaque copie est indépendante. Une `class` est un **reference type** : l'affectation partage une seule instance, et les deux variables pointent vers le même objet. Cette unique différence guide la plupart des décisions de conception en Swift.

## Comment ça fonctionne

```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          // COPIE — b est un struct distinct
b.x = 99
print(a.x, b.x)    // => 1 99  (a inchangé)

let c = PointC(x: 1)
let d = c          // PARTAGE — même instance
d.x = 99
print(c.x, d.x)    // => 99 99 (les deux changent)
```

## Compromis

| Aspect | struct (value) | class (reference) |
|--------|----------------|-------------------|
| Sémantique de copie | copie indépendante | référence partagée |
| Mutation | nécessite `var` / `mutating` | mutable via n'importe quelle référence |
| Identité | aucune (comparaison par valeur) | identité `===` |
| Héritage | non | oui |
| Mémoire | généralement la pile, pas d'ARC | tas, géré par ARC |

Les structs nécessitent aussi `mutating` pour modifier des propriétés stockées dans une méthode, car les méthodes reçoivent par défaut un `self` immuable.

## Quand utiliser lequel

- **Par défaut, choisissez `struct`** — la bibliothèque standard de Swift (`Array`, `String`, `Int`) et les `View`s de SwiftUI sont tous des value types. Ils peuvent être partagés en toute sécurité entre threads et n'engendrent pas de cycles de rétention.
- Utilisez `class` lorsque vous avez besoin d'un **état mutable partagé**, d'**identité**, d'**héritage**, ou d'interopérabilité avec Objective-C (`NSObject`).

## Pourquoi c'est important

Choisir entre value et reference détermine si une modification à un endroit se propage ailleurs. Les bugs du type « modifier un élément les a tous modifiés » viennent d'un partage de référence inattendu ; tout le modèle de SwiftUI suppose des vues value type peu coûteuses et copiables — les recruteurs vérifient donc que vous optez d'abord pour `struct`.

Aspect	struct (value)	class (reference)
Sémantique de copie	copie indépendante	référence partagée
Mutation	nécessite `var` / `mutating`	mutable via n'importe quelle référence
Identité	aucune (comparaison par valeur)	identité `===`
Héritage	non	oui
Mémoire	généralement la pile, pas d'ARC	tas, géré par ARC

Comment ça fonctionne

Compromis

Quand utiliser lequel

Pourquoi c'est important

Questions connexes