Costruttori in C++: inizializzare gli oggetti nel modo giusto

Cos'è un costruttore

Nella pagina precedente hai definito delle classi e hai dato loro delle variabili membro. Ma i membri di un oggetto appena creato contengono qualunque valore spazzatura ci fosse in quella memoria, a meno che tu non li imposti. Un costruttore risolve il problema: è una funzione membro speciale che viene eseguita automaticamente nel momento in cui un oggetto viene creato, e il suo unico compito è lasciare l'oggetto in uno stato valido e completamente inizializzato.

Un costruttore ha lo stesso nome della classe e nessun tipo di ritorno, nemmeno void. Non lo chiami mai direttamente: è il compilatore a chiamarlo per te ogni volta che un oggetto viene creato.

#include <iostream>
using namespace std;

class Counter {
public:
    int value;

    Counter() {          // costruttore: stesso nome della classe, nessun tipo di ritorno
        value = 0;
        cout << "Counter created\n";
    }
};

int main() {
    Counter c;           // il costruttore viene eseguito proprio qui
    cout << c.value << "\n";   // 0, non spazzatura
    return 0;
}

Counter() senza parametri si chiama costruttore di default: è quello usato quando crei un oggetto senza passare argomenti.

Costruttori parametrizzati

Un costruttore senza argomenti va bene, ma di solito vuoi creare un oggetto con valori specifici. Un costruttore parametrizzato accetta argomenti e li usa per inizializzare i membri.

#include <iostream>
using namespace std;

class Point {
public:
    int x;
    int y;

    Point(int startX, int startY) {
        x = startX;
        y = startY;
    }
};

int main() {
    Point p(3, 4);                // passa i valori al momento della creazione
    cout << p.x << ", " << p.y << "\n";   // 3, 4
    return 0;
}

Una classe può avere più di un costruttore, purché le liste dei parametri siano diverse: è il normale overloading delle funzioni applicato ai costruttori. Qui Point si può creare con o senza coordinate:

#include <iostream>
using namespace std;

class Point {
public:
    int x, y;

    Point() {            // costruttore di default
        x = 0;
        y = 0;
    }

    Point(int startX, int startY) {   // costruttore parametrizzato
        x = startX;
        y = startY;
    }
};

int main() {
    Point origin;        // chiama Point()
    Point p(3, 4);       // chiama Point(int, int)

    cout << origin.x << ", " << origin.y << "\n";  // 0, 0
    cout << p.x << ", " << p.y << "\n";            // 3, 4
    return 0;
}

Un'insidia comune: Point p(); non crea un oggetto, perché il compilatore lo legge come la dichiarazione di una funzione chiamata p che restituisce un Point. Per chiamare il costruttore di default scrivi Point p; (senza parentesi) oppure Point p{}; con le graffe.

Liste di inizializzazione dei membri

Finora gli esempi assegnavano i membri dentro il corpo del costruttore. Per i tipi semplici funziona, ma è lo strumento sbagliato. Quando il corpo viene eseguito, ogni membro è già stato costruito di default; il corpo poi butta via quel valore e ci assegna sopra. Una lista di inizializzazione dei membri inizializza ogni membro direttamente, prima del corpo, in un solo passaggio.

La sintassi prevede i due punti dopo la lista dei parametri, seguiti da coppie member(value):

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

class User {
public:
    string name;
    int age;

    User(string n, int a) : name(n), age(a) {   // lista di inizializzazione
        // il corpo può restare vuoto
    }
};

int main() {
    User u("Ada", 36);
    cout << u.name << " is " << u.age << "\n";   // Ada is 36
    return 0;
}

Per un membro string questo evita anche di costruire una stringa vuota e poi assegnarla: la lista di inizializzazione la costruisce correttamente al primo colpo.

La lista di inizializzazione non è solo un'ottimizzazione; è obbligatoria in tre casi, perché il corpo può solo assegnare, non inizializzare:

• Membri const: non puoi assegnare un valore a un const dopo che esiste.
• Membri riferimento: un riferimento deve essere legato nel momento in cui nasce.
• Membri il cui tipo non ha un costruttore di default.

class Sensor {
    const int id;        // membro const
    int& slot;           // membro riferimento

public:
    Sensor(int sensorId, int& s) : id(sensorId), slot(s) {}
    // Provare ad assegnare id o slot nel corpo non compilerebbe.
};

Una sottigliezza da conoscere: i membri vengono inizializzati nell'ordine in cui sono dichiarati nella classe, non nell'ordine in cui li elenchi nella lista di inizializzazione. Se l'inizializzatore di un membro legge un altro membro, conta l'ordine di dichiarazione: far divergere i due ordini è una fonte classica di utilizzo di un valore non ancora inizializzato.

Argomenti predefiniti e costruttori delegati

Non servono sempre overload separati. Gli argomenti predefiniti permettono a un unico costruttore di coprire più casi: ometti un argomento e ci pensa il valore predefinito.

#include <iostream>
using namespace std;

class Point {
public:
    int x, y;

    Point(int startX = 0, int startY = 0) : x(startX), y(startY) {}
};

int main() {
    Point a;          // 0, 0
    Point b(5);       // 5, 0
    Point c(5, 9);    // 5, 9

    cout << a.x << "," << a.y << "  "
         << b.x << "," << b.y << "  "
         << c.x << "," << c.y << "\n";
    return 0;
}

Fai attenzione a combinare un costruttore parametrizzato con valori predefiniti e un costruttore di default Point() separato: il compilatore non sa quale chiamare per Point p; e segnala un'ambiguità. Scegli un solo approccio.

Quando hai più costruttori che condividono una parte della configurazione, un costruttore delegato (C++11) permette a un costruttore di chiamarne un altro invece di ripetere la logica. "Deleghi" mettendo l'altro costruttore nella lista di inizializzazione:

#include <iostream>
using namespace std;

class Rectangle {
public:
    int width, height;

    Rectangle(int w, int h) : width(w), height(h) {
        cout << "full constructor\n";
    }

    Rectangle() : Rectangle(1, 1) {   // delega al costruttore qui sopra
        cout << "default delegated\n";
    }
};

int main() {
    Rectangle r;                      // esegue il costruttore completo e poi il corpo di quello di default
    cout << r.width << "x" << r.height << "\n";   // 1x1
    return 0;
}

Il costruttore di copia

Quando crei un oggetto come copia di un altro, passandolo per valore, restituendolo o scrivendo Foo b = a;, viene eseguito il costruttore di copia. La sua firma riceve un riferimento const allo stesso tipo:

ClassName(const ClassName& other);

Se non ne scrivi uno, il compilatore genera un costruttore di copia predefinito che copia ogni membro. Per le classi che contengono solo valori (int, stringhe, vector) è esattamente ciò che serve, e non dovresti scriverne uno tuo.

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

class Box {
public:
    string label;
    int size;

    Box(string l, int s) : label(l), size(s) {}

    // Costruttore di copia personalizzato, qui solo per vederlo in azione:
    Box(const Box& other) : label(other.label + " (copy)"), size(other.size) {
        cout << "copy made\n";
    }
};

int main() {
    Box original("widget", 10);
    Box duplicate = original;      // viene eseguito il costruttore di copia

    cout << duplicate.label << " " << duplicate.size << "\n";  // widget (copy) 10
    return 0;
}

La grande insidia sta nel prossimo capitolo sulla memoria: se la tua classe possiede un puntatore grezzo a memoria heap, il costruttore di copia predefinito copia il puntatore, non i dati, quindi due oggetti finiscono per puntare alla stessa memoria ed entrambi proveranno a liberarla. È il bug del double free. La regola pratica è la Regola del Tre/Cinque: se scrivi un distruttore personalizzato, quasi sicuramente ti servono anche un costruttore di copia (e un'assegnazione per copia) personalizzati. Nel C++ moderno la soluzione più pulita è contenere un std::vector o uno smart pointer, così la copia generata dal compilatore funziona e basta.

Nota anche che ricevere il parametro per riferimento è obbligatorio, non facoltativo: un costruttore di copia che ricevesse l'argomento per valore dovrebbe copiare l'argomento per chiamare se stesso, una ricorsione infinita che non compila nemmeno.

Prossimo: Distruttori

Un costruttore prepara un oggetto; un distruttore lo smonta. Quando un oggetto esce dallo scope o viene eliminato, il suo distruttore viene eseguito automaticamente: il posto perfetto per rilasciare file, connessioni di rete o memoria heap che l'oggetto teneva. La prossima pagina spiega come funzionano i distruttori, quando esattamente scattano e come si abbinano ai costruttori per dare al C++ il potente schema RAII.