Swift Academy · Leçon

Pile ou tas : où résident les valeurs

Comprendre comment les structures résident dans la pile et les classes dans le tas, ainsi que les conséquences sur les performances.

Pile ou tas : où résident les valeurs est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Swift Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Swift Academy comprend 4 leçons au total.

Bienvenue

Comprendre où résident les valeurs Swift en mémoire — dans la pile ou dans le tas — est essentiel pour écrire du code performant et prévisible.

La pile

La pile est un bloc contigu de mémoire géré automatiquement : • Les variables locales et les paramètres de fonction y résident • L’allocation est en O(1) — il suffit de déplacer un pointeur • La mémoire est automatiquement libérée lorsque la portée se termine • Elle est locale à chaque thread — chaque thread possède sa propre pile

Le tas

Le tas est un espace partagé destiné aux allocations de longue durée : • Les objets y résident lorsque leur durée de vie dépasse une portée • L’allocation nécessite de trouver de la mémoire libre — elle est plus coûteuse • Elle est gérée par ARC pour les classes • Elle est partagée entre les threads — une synchronisation est nécessaire

Les structures résident dans la pile

```swift func compute() { var pt = CGPoint(x: 3, y: 4) // on the stack pt.x += 1 } // pt freed automatically ``` Les petites structures sont transmises par copie — sans surcharge du tas.

Les classes résident dans le tas

```swift class Dog { var name: String init(name: String) { self.name = name } } var d = Dog(name: "Rex") // Dog instance on heap // 'd' is a pointer on the stack ```

Les grandes structures peuvent utiliser le tas

Les grandes structures (tableaux, chaînes et grands types valeur) utilisent en interne COW et un stockage dans le tas, même si elles se comportent comme des types valeur : ```swift var arr = [Int](repeating: 0, count: 10_000) // The array's buffer is on the heap; 'arr' itself is a stack value ```

Capture dans les fermetures

Lorsqu’une fermeture capture une variable de type valeur qui doit survivre à la portée, Swift l’encapsule dans le tas : ```swift var count = 0 let increment = { count += 1 } // count captured in a heap box increment() print(count) // 1 ```

Encapsulation des types existentiels de protocoles

Le stockage de petits types valeur dans des variables `any Protocol` peut entraîner une allocation dans le tas (encapsulation existentielle) : ```swift var shape: any Shape = Circle(radius: 5) // may allocate on heap ``` Les petits types (≤3 mots) sont intégrés directement ; les types plus grands sont encapsulés.

Mesurer les allocations

Utilisez le modèle Allocations d’Instruments pour voir les allocations dans le tas : 1. Profil > Allocations 2. Filtrez par classe ou par catégorie 3. Suivez les nombres de `alloc` et de `dealloc` Un nombre élevé d’allocations dans les boucles indique souvent une encapsulation inattendue.

Conséquences pour la conception

• Préférez les structures pour les types qui contiennent des données à courte durée de vie — rapidité de la pile • Utilisez les classes lorsqu’une identité ou un état partagé est nécessaire • Évitez les allocations dans les boucles serrées — préallouez avec `reserveCapacity` • Profilez avant d’optimiser — l’optimisation prématurée fait perdre du temps

Vérification rapide

Quel type de mémoire est automatiquement libéré lorsque la portée d’une fonction se termine ?

Récapitulatif

Points essentiels : • Pile : économique, automatique, locale au thread, adaptée aux types valeur • Tas : flexible, géré par ARC, adapté aux types référence • Les grandes structures utilisent des tampons internes dans le tas (COW) • Les fermetures qui capturent des variables les encapsulent dans le tas • Utilisez Instruments Allocations pour détecter une pression inattendue sur le tas Ensuite : mutation, partage et aliasage inattendu.

Questions Fréquemment Posées

La leçon « Pile ou tas : où résident les valeurs » est-elle gratuite ?

Oui — le texte complet de « Pile ou tas : où résident les valeurs » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Swift Academy, passe à CoddyKit PRO. Le cours Swift Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Pile ou tas : où résident les valeurs » ?

Comprendre comment les structures résident dans la pile et les classes dans le tas, ainsi que les conséquences sur les performances. Tu pratiques Swift Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Swift Academy ?

Aucune expérience préalable n'est requise. Swift Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Pile ou tas : où résident les valeurs » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Swift Academy ?

Oui. Chaque leçon Swift Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Pile ou tas : où résident les valeurs
Mutation, partage et aliasing inattendu
Graphes mixtes de valeurs et de références
Concevoir des interfaces pour la sémantique des valeurs

← Retour à Swift Academy