0Pricing
Swift Academy · Lección

Cómo ARC cuenta las referencias

Comprenda qué hace ARC en tiempo de compilación, las llamadas retain/release y la duración de los objetos.

Cómo ARC cuenta las referencias 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

Automatic Reference Counting (ARC) gestiona la memoria de las instancias de clases. Comprender cómo cuenta las referencias le ayuda a escribir código sin fugas de memoria.

Qué hace ARC

ARC realiza un seguimiento del número de referencias *strong* que apuntan a cada instancia de clase. Cuando el contador llega a cero, llama a `deinit` y libera la memoria automáticamente.

Referencias strong

```swift var a: Dog? = Dog(name: "Rex") // count = 1 var b = a // count = 2 a = nil // count = 1 b = nil // count = 0 → deinit ```

ARC se ejecuta en tiempo de compilación

ARC inserta llamadas a retain/release durante la compilación, no durante la ejecución como un recolector de basura. Esto significa: • No hay pausas del recolector de basura • Desasignación determinista • Un ligero aumento del tamaño del código debido a las llamadas a retain/release

Riesgo de ciclos de referencias strong

```swift class Node { var next: Node? } var n1: Node? = Node() var n2: Node? = Node() n1?.next = n2 n2?.next = n1 // cycle! n1 = nil; n2 = nil // both stuck at count=1 — leaked! ```

Conteo con varias variables

```swift class Engine {} var car1: Engine? = Engine() // count = 1 var car2 = car1 // count = 2 var car3 = car2 // count = 3 car1 = nil // count = 2 car2 = nil // count = 1 // Engine still alive — car3 holds it car3 = nil // count = 0 → deinit ```

ARC en colecciones

```swift var dogs: [Dog] = [] dogs.append(Dog(name:"A")) // count = 1 dogs.append(Dog(name:"B")) // count = 1 each dogs.removeAll() // both deinit called ```

ARC NO se aplica a los tipos valor

Las structs, los enums y las tuplas NO se gestionan mediante conteo de referencias: ```swift struct Point { var x, y: Double } // no retain/release var p1 = Point(x:1,y:2) var p2 = p1 // copy — no ARC ```

Observación de ARC con deinit

```swift class Cat { let name: String init(name: String) { self.name = name; print("\(name) born") } deinit { print("\(name) deallocated") } } var c: Cat? = Cat(name: "Luna") c = nil // "Luna deallocated" printed ```

Rendimiento de ARC frente al recolector de basura

• GC: pausa la ejecución periódicamente para recopilar objetos; implica un equilibrio entre rendimiento y latencia • ARC: desasigna inmediatamente cuando el contador llega a 0; no produce pausas • Coste de ARC: cada asignación mediante una referencia strong tiene el coste de un par retain/release

Comprobación rápida

¿Cuándo llama ARC a `deinit` y libera la memoria de un objeto?

Resumen

Conclusiones clave: • ARC realiza un seguimiento de las referencias strong a las instancias de clases • Contador 0 → se llama a `deinit` → se libera la memoria • ARC se ejecuta en tiempo de compilación: no hay pausas del recolector de basura • Los tipos valor (struct/enum) no están gestionados por ARC • Los ciclos impiden que el contador llegue a 0: use weak/unowned Siguiente: ciclos de retención.

Preguntas frecuentes

¿La lección «Cómo ARC cuenta las referencias» es gratis?

Sí — el texto completo de «Cómo ARC cuenta las referencias» 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 «Cómo ARC cuenta las referencias»?

Comprenda qué hace ARC en tiempo de compilación, las llamadas retain/release y la duración de los objetos. 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 «Cómo ARC cuenta las referencias»?

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

  1. Cómo ARC cuenta las referencias
  2. Ciclos de retención: causas y detección
  3. Referencias weak y unowned
  4. Listas de captura de closures y [weak self]
← Volver a Swift Academy