Destructores en Programación: Liberación de Recursos Automática

Curso de Programación Orientada a Objetos en Swift

Contenido del curso

Estructuras y Clases

Tipos de Propiedades

Métodos, subíndices y herencia

Inicializadores o constructores

Encadenamiento opcional

Conclusión

27
Desarrollo de Aplicaciones Móviles con Swift
01:23 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:007:12

Destructores en Programación: Liberación de Recursos Automática

Curso de Programación Orientada a Objetos en Swift

Clase 22 de 27

Clase 22 / 27

Recursos

Controla la memoria y los recursos en Swift con seguridad: el desinicializador permite limpiar automáticamente objetos asociados cuando un objeto principal se destruye. Con un ejemplo práctico de un banco y un jugador, verás cómo retornar monedas al sistema al finalizar su ciclo de vida evita residuos en memoria y estados incoherentes.

¿Qué es y cuándo usar el desinicializador en Swift?

El desinicializador se ejecuta cuando un objeto se destruye: su objetivo es limpiar y notificar a otras partes del sistema. Swift trae uno por defecto, pero conviene sobreescribirlo cuando debes devolver recursos compartidos o desregistrar dependencias. Imagina un jugador que muere mientras su inventario sigue vivo: ese inventario ocupa memoria sin valor. Al implementar deinit, el Player puede devolver al Bank todas las monedas que llevaba encima, manteniendo el estado consistente.

Evita objetos “pululando” sin uso en memoria.
Devuelve recursos compartidos al sistema de origen.
Reduce errores por estados desbalanceados.

¿Cómo construir Bank y Player para devolver monedas al destruirse?

La idea es simple: Bank guarda un saldo global con una variable static y expone dos métodos static: uno para distribuir monedas y otro para recibirlas. Player pide monedas al crearse con init y al ganar, siempre desde Bank. En deinit, devuelve lo que tenga en su monedero.

¿Cómo se distribuyen e ingresan monedas en Bank?

final class Bank {
    static var coinsInBank = 2000

    static func distribute(coinsRequested: Int) -> Int {
        let coinsToVend = min(coinsRequested, coinsInBank)
        coinsInBank -= coinsToVend
        return coinsToVend
    }

    static func receive(coins: Int) {
        coinsInBank += coins
    }
}

Saldo compartido con variable estática.
Distribución limitada al mínimo entre lo solicitado y lo disponible.
Recepción directa: siempre se puede ingresar.

¿Cómo el Player gana y devuelve monedas?

final class Player {
    var coinsInPurse: Int

    init(coins: Int) {
        self.coinsInPurse = Bank.distribute(coinsRequested: coins)
    }

    func win(coins: Int) {
        coinsInPurse += Bank.distribute(coinsRequested: coins)
    }

    deinit {
        Bank.receive(coins: coinsInPurse)
    }
}

Toma inicial de monedas en el init desde Bank.
Ganancias siempre mediadas por Bank.
Limpieza automática en deinit: se devuelven todas las monedas.

¿Cómo se usa con un optional para poder destruir al jugador?

var playerOne: Player? = Player(coins: 100)   // Bank pasa de 2000 a 1900.
playerOne!.win(coins: 2000)                   // Bank reparte lo que quede; puede llegar a 0.
playerOne = nil                               // deinit: Bank recupera todas las monedas del player.
// Bank vuelve a 2000 tras la destrucción del jugador.

Se usa optional para poder asignar nil y disparar el deinit.
Si fuera let o no optional, no podrías destruirlo manualmente.
Al morir o “irse a dormir” el jugador, el banco recupera automáticamente las monedas.

¿Qué habilidades y palabras clave refuerzas?

Desinicializador (deinit): se ejecuta al destruir un objeto y limpia recursos compartidos.
Inicializador (init): configura el estado pidiendo monedas al banco.
Variable y métodos estáticos (static): estado global del banco y operaciones centralizadas.
Transferencia de recursos: siempre que el jugador toma o gana, lo hace vía Bank.
Optional y nil: permiten destruir el objeto para activar deinit cuando convenga.
Control de disponibilidad: retirada limitada al mínimo entre pedido y saldo.
Consistencia del sistema: al destruir el jugador, el banco vuelve a su saldo inicial.

¿Te gustaría comentar otros escenarios donde deinit te ha ayudado a mantener el estado limpio en tus modelos de juego o apps?

Yusef Gonzalez

Hace un año

class Animal {

var nombre: String

// Constructor (inicializador)

init(nombre: String) {

self.nombre = nombre

print("Se creó un animal llamado \(nombre) 🐾")

}

func hacerSonido() {

print("El animal hace un sonido")

}

// Destructor (deinicializador)

deinit {

print("El animal \(nombre) fue destruido 💨")

}

protocol Movible {

func mover()

}

class Perro: Animal, Movible {

var raza: String

// Constructor del perro (inicializador)

init(nombre: String, raza: String) {

self.raza = raza

super.init(nombre: nombre) // Llamamos al init de la clase padre

print("Se creó un perro de raza \(raza) llamado \(nombre) 🐶")

}

func mover() {

print("\(nombre) corre feliz 🐾")

}

override func hacerSonido() {

print("\(nombre) dice: Guau guau! 🐕")

}

// Destructor del perro (deinicializador)

deinit {

print("El perro \(nombre) de raza \(raza) fue destruido 💀")

}

MIREN COMO SE INSERTA UN PROTOCOLO

Estructuras y Clases

Programación Orientada a Objetos en Swift: Nivel Avanzado

Estructuras vs Clases en Programación Orientada a Objetos

Inicializadores y copias por valor en Swift

Por qué las clases Swift no copian valores

Tipos de Propiedades

Propiedades Almacenadas en Swift: Uso y Ejemplos Prácticos

Propiedades Lazy en Programación: Uso y Ventajas

Propiedades Computadas en Swift: Uso y Ejemplos Prácticos

Computed properties de solo lectura en Swift

Observers en Swift: willSet y didSet

Variables estáticas en clases, estructuras y enumerados

Métodos, subíndices y herencia

Métodos de instancia en Swift con self

Métodos Mutantes en Estructuras y Enumerados en Swift

Métodos de clase en Swift: static vs class

Subíndices en Swift: Sintaxis y Aplicaciones Prácticas

Manipulación de Matrices y Subíndices en Programación

Herencia de Clases en Programación Orientada a Objetos

Sobrescritura de Métodos y Propiedades en Clases Derivadas

Inicializadores o constructores

Inicializadores en Sweet: Creación y Uso Efectivo de Constructores

Modificación de Constructores y Parámetros Opcionales en Swift

Constructores Designados y de Conveniencia en Herencia de Clases

Constructores y manejo de inicialización opcional en Swift

Destructores en Programación: Liberación de Recursos Automática

Encadenamiento opcional

Encadenamiento de Valores Opcionales en Programación

Estructuras para optional chaining en Swift

Optional chaining en Swift: acceso seguro

Encadenamiento de Opcionales en Programación Avanzada

Conclusión

Desarrollo de Aplicaciones Móviles con Swift

Destructores en Programación: Liberación de Recursos Automática