Swift Academy · Lección

Stack frente a heap: dónde viven los valores

Comprenda cómo viven los structs en el stack y las clases en el heap, y conozca sus implicaciones de rendimiento.

Stack frente a heap: dónde viven los valores es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Swift Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Swift Academy incluye 4 lecciones en total.

Bienvenida

Comprender dónde viven los valores de Swift en la memoria —en la pila o en el montón— es esencial para escribir código eficiente y predecible.

La pila

La pila es un bloque contiguo de memoria que se administra automáticamente: • Las variables locales y los parámetros de las funciones viven aquí • La asignación es O(1): solo hay que mover un puntero • Se libera automáticamente al salir del ámbito • Es local al subproceso: cada subproceso tiene su propia pila

El montón

El montón es un conjunto compartido para asignaciones de larga duración: • Los objetos viven aquí cuando su ciclo de vida supera un ámbito • La asignación requiere encontrar memoria libre, por lo que es más costosa • ARC lo administra para las clases • Se comparte entre subprocesos, por lo que requiere sincronización

Las estructuras viven en la pila

```swift func compute() { var pt = CGPoint(x: 3, y: 4) // on the stack pt.x += 1 } // pt freed automatically ``` Las estructuras pequeñas se pasan por copia, sin sobrecoste del montón.

Las clases viven en el montón

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

Las estructuras grandes pueden usar el montón

Las estructuras grandes (arrays, strings y tipos de valor grandes) usan internamente COW y almacenamiento en el montón, aunque se comporten como tipos de valor: ```swift var arr = [Int](repeating: 0, count: 10_000) // The array's buffer is on the heap; 'arr' itself is a stack value ```

Captura en closures

Cuando un closure captura una variable de tipo de valor que debe sobrevivir al ámbito, Swift la encapsula en el montón: ```swift var count = 0 let increment = { count += 1 } // count captured in a heap box increment() print(count) // 1 ```

Encapsulado de existenciales de protocolos

Almacenar tipos de valor pequeños en variables `any Protocol` puede provocar una asignación en el montón (encapsulado existencial): ```swift var shape: any Shape = Circle(radius: 5) // may allocate on heap ``` Los tipos pequeños (≤3 palabras) se insertan directamente; los tipos más grandes se encapsulan.

Medición de asignaciones

Use la plantilla Allocations de Instruments para ver las asignaciones del montón: 1. Profile > Allocations 2. Filtre por clase o categoría 3. Realice un seguimiento de los recuentos de `alloc` y `dealloc` Un número elevado de asignaciones en bucles suele indicar un encapsulado inesperado.

Implicaciones de diseño

• Prefiera estructuras para tipos de corta duración que contengan datos: velocidad de la pila • Use clases cuando necesite identidad o estado compartido • Evite asignar memoria en bucles estrechos: reserve memoria previamente con `reserveCapacity` • Haga un perfil antes de optimizar: la optimización prematura hace perder tiempo

Comprobación rápida

¿Qué tipo de memoria se libera automáticamente al salir del ámbito de una función?

Repaso

Puntos clave: • Pila: económica, automática, local al subproceso y asociada a tipos de valor • Montón: flexible, administrado por ARC y asociado a tipos de referencia • Las estructuras grandes usan búferes internos en el montón (COW) • Los closures que capturan variables las encapsulan en el montón • Use Instruments Allocations para detectar una presión inesperada sobre el montón Siguiente: mutación, uso compartido y aliasing inesperado.

Preguntas frecuentes

¿La lección «Stack frente a heap: dónde viven los valores» es gratis?

Sí — el texto completo de «Stack frente a heap: dónde viven los valores» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Swift Academy, actualiza a CoddyKit PRO. El curso de Swift Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Stack frente a heap: dónde viven los valores»?

Comprenda cómo viven los structs en el stack y las clases en el heap, y conozca sus implicaciones de rendimiento. Practicas Swift Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Swift Academy?

No se requiere experiencia previa. Swift Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Stack frente a heap: dónde viven los valores»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Swift Academy?

Sí. Cada lección de Swift Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Stack frente a heap: dónde viven los valores
Mutación, compartición y aliasing inesperado
Grafos mixtos de valores y referencias
Diseño de APIs con semántica de valor

← Volver a Swift Academy