Il Distruttore

In C++, ogni oggetto ha un ciclo di vita: nasce, viene utilizzato e poi viene eliminato. Per gestire automaticamente questa vita, esistono due strumenti fondamentali: costruttori e distruttori.

1. Il Costruttore (Constructor)

Un costruttore in C++ è una funzione speciale di una classe che viene chiamata automaticamente quando un oggetto viene creato. Serve principalmente a inizializzare i membri della classe, cioè a dare valori iniziali alle variabili dell’oggetto.

È un metodo speciale che ha lo stesso nome della classe e non ha tipo di ritorno (nemmeno void).

🔧 Caratteristiche fondamentali

• Ha lo stesso nome della classe.
• Se la classe si chiama Punto, il costruttore si chiamerà Punto.
• Non ha tipo di ritorno, nemmeno void.
• Viene chiamato automaticamente quando crei un oggetto.
• Può essere sovraccaricato: puoi avere più costruttori con parametri diversi.
• Se non ne definisci uno, il compilatore ne crea uno di default.

class Punto {
private:
    int x, y;

public:
    // Costruttore
    Punto(int a, int b) {
        x = a;
        y = b;
    }
};

Punto p(3, 4);

💡 Senza il costruttore, dovresti impostare manualmente x e y, rischiando errori e valori casuali.

✨ Perché è importante

I costruttori rendono il codice più sicuro e leggibile, perché garantiscono che ogni oggetto inizi la sua vita in uno stato coerente. Senza di loro, dovresti ricordarti ogni volta di inizializzare tutto manualmente.

2. Il Distruttore (Destructor)

Il distruttore è il “saluto finale” di un oggetto in C++: un metodo speciale che viene eseguito automaticamente quando l’oggetto sta per essere eliminato. Se il costruttore prepara l’oggetto alla vita, il distruttore si occupa di chiudere tutto in modo ordinato.

🗑️ Cos’è un distruttore

• Ha lo stesso nome della classe, preceduto da una tilde ~ .
• Non ha tipo di ritorno.
• Non accetta parametri.
• Serve a liberare risorse (memoria, file aperti, connessioni).
• Viene chiamato in automatico quando l’oggetto esce di scope o viene distrutto.

“Se il costruttore inizializza l’oggetto, il distruttore fa l’opposto: si occupa di liberare le risorse quando l’oggetto non serve più.”

class Punto {
private:
    int x, y;

public:
    // Costruttore
    Punto(int a, int b) {
        x = a;
        y = b;
    }

    // Distruttore
    ~Punto() {
        // Qui potresti liberare risorse o stampare un messaggio
        // std::cout << "Oggetto Punto distrutto\n";
    }
};

🧩 Esempio con risorsa da liberare

class Punto {
private:
    int* coord; // memoria dinamica

public:
    // Costruttore
    Punto(int a, int b) {
        coord = new int[2]; // allocazione dinamica
        coord[0] = a;
        coord[1] = b;
    }

    // Distruttore
    ~Punto() {
        delete[] coord; // liberazione della memoria
    }
};

3. Ciclo di vita di un oggetto

Puoi pensare al ciclo così:

Creazione oggetto -> Costruttore -> Uso -> Fine scope -> Distruttore

#include <iostream>
#include <string>
using namespace std;

class Player {
private:
    string nome;
    int salute;

public:
    // 1. Costruttore di Default
    Player() {
        nome = "Ospite";
        salute = 100;
        cout << "[Sistema] Creato giocatore standard." << endl;
    }

    // 2. Costruttore con Parametri (Overloading)
    Player(string n, int s) {
        nome = n;
        salute = s;
        cout << "[Sistema] Creato giocatore personalizzato: " << nome << endl;
    }

    // 3. Distruttore
    ~Player() {
        cout << "[Sistema] Il giocatore " << nome << " ha lasciato la sessione." << endl;
    }

    void status() {
        cout << "Player: " << nome << " | Salute: " << salute << endl;
    }
};

int main() {
    cout << "--- Inizio Sessione ---" << endl;

    // Richiama il costruttore di default
    Player p1; 
    p1.status();

    // Richiama il costruttore con parametri
    Player p2("Warrior_99", 150);
    p2.status();

    cout << "--- Fine Sessione ---" << endl;
    return 0; 
    // Qui vengono chiamati automaticamente i distruttori di p2 e p1 (ordine inverso)
}