Come avviene la pulizia dello stack nello sviluppo…

Lo stack di chiamata in iOS viene automaticamente pulito al termine dell'esecuzione di una funzione o metodo. Quando una funzione termina, il suo frame (insieme di variabili locali, argomamenti e indirizzo di ritorno) viene rimosso dallo stack.

Per gli oggetti allocati nello stack (ad esempio, strutture o tipi di dati semplici), la pulizia avviene direttamente alla rimozione del frame.

Per gli oggetti allocati nell'heap, a cui si fa riferimento dallo stack, la gestione automatica della memoria in iOS (ARC - conteggio automatico delle referenze) svolge un ruolo chiave. ARC non pulisce lo stack, ma gestisce la durata degli oggetti nell'heap.

Quando una variabile contenente un riferimento forte a un oggetto nell'heap esce dal suo ambito (cosa che avviene alla rimozione del frame dallo stack), ARC riduce automaticamente il contatore di riferimenti di quell'oggetto. Se il contatore raggiunge zero, ARC libera la memoria occupata dall'oggetto nell'heap.

Pertanto, la pulizia dello stack consiste nella rimozione diretta dei frame al termine delle funzioni, mentre la liberazione della memoria degli oggetti nell'heap, a cui le variabili nello stack fanno riferimento, avviene indirettamente tramite ARC.

Esempio:

struct MyStruct {
    let value: Int
}

class MyClass {
    var name: String

    init(name: String) {
        self.name = name
        print("Istanza di MyClass \(name) creata")
    }

    deinit {
        print("Istanza di MyClass \(name) deallocata")
    }
}

func myFunction() {
    let stackStruct = MyStruct(value: 10) // Allocato nello stack
    let heapObject = MyClass(name: "Esempio") // Allocato nell'heap, riferimento nello stack

    // ... operiamo con stackStruct e heapObject

    // La funzione termina, i frame di stackStruct e il riferimento a heapObject vengono rimossi dallo stack
    // ARC riduce il contatore di riferimenti di heapObject. Se raggiunge zero, l'oggetto viene deallocato.
}

myFunction() // Chiamata alla funzione

In questo esempio:

stackStruct è allocato direttamente nello stack all'interno del frame di myFunction. Quando myFunction termina, il frame viene rimosso e stackStruct viene automaticamente pulito.
heapObject è un riferimento a un'istanza di MyClass, che si trova nell'heap. La variabile heapObject (il riferimento) si trova nello stack. Quando myFunction termina, il riferimento heapObject viene rimosso dallo stack. Poiché era l'unico riferimento forte all'istanza MyClass("Esempio"), ARC rileva che il contatore di riferimenti è zero e chiama deinit, liberando la memoria nell'heap.

Come avviene la pulizia dello stack nello sviluppo iOS?