Sintassi della classe

Parlare di sintassi della classe in C++ significa addentrarsi in uno degli aspetti più caratteristici del linguaggio. Fin dai primi approcci, la classe emerge come una componente fondamentale, in grado di racchiudere dati (variabili membro) e comportamenti (funzioni membro) all’interno di un unico contenitore logico. Nella pratica, una classe risulta molto più di un semplice insieme di definizioni: è il luogo in cui si decide l’organizzazione di attributi e metodi, si stabiliscono le visibilità (public, private, protected) e si progettano le modalità d’uso dell’oggetto all’interno di un programma.

L’obiettivo di questo testo è offrire una panoramica articolata, ma al tempo stesso informale, su come si costruisce la sintassi di una classe in C++. Miriamo a rendere chiaro che, dietro una serie di regole apparentemente rigide, si cela un mondo di flessibilità e creatività. Anche se i termini “classe” e “oggetto” vengono spesso usati in maniera intercambiabile nel linguaggio quotidiano, è importante ricordare che la classe rappresenta il progetto, mentre l’oggetto è il risultato concreto della “costruzione” basata su quel progetto. Il C++ fornisce una sintassi ben precisa per dichiarare e definire classi, gestire la visibilità dei membri, specificare costruttori, distruttori, operatori e molto altro.

Nei paragrafi che seguono, andremo a esplorare l’architettura essenziale di una classe in C++, soffermandoci sui punti cardine della sua sintassi e sulle possibili varianti che il linguaggio ci mette a disposizione. Il nostro sarà un cammino che toccherà diversi aspetti, da quelli più basilari fino a dettagli più avanzati, offrendo esempi concreti su come impostare e utilizzare le classi in modo efficace.

Struttura di base: dichiarazione e definizione

Il punto di partenza per comprendere la sintassi di una classe in C++ è la dichiarazione, che in genere avviene attraverso la parola chiave class, seguita dal nome della classe. All’interno delle parentesi graffe, si specificano i membri, che possono essere dati o funzioni. Ecco un esempio minimale:

class Esempio {
public:
    int valore;

    void stampa() {
        std::cout << "Valore: " << valore << std::endl;
    }
};

In questo frammento, Esempio è una classe che contiene un membro pubblico di tipo int (chiamato valore) e una funzione membro pubblica denominata stampa. La parola chiave public: indica che tutto ciò che segue fino a un’eventuale altra sezione (come private: o protected:) sarà liberamente accessibile dall’esterno. Nella sintassi di una classe, ciò che non viene messo nella sezione pubblica rientra, per impostazione predefinita, nella sezione privata. Se dovessimo omettere la parola public:, i membri verrebbero dichiarati private, rendendoli accessibili solo dall’interno della classe stessa o da entità dichiarate amiche (friend).

È consuetudine, in molti progetti, suddividere i membri in sezioni logicamente distinte: una public: contenente l’interfaccia pubblica (funzioni e, talvolta, alcuni dati che si desidera rendere liberamente accessibili), una private: per i dettagli di implementazione che non devono essere visibili all’esterno, e una protected: qualora si preveda di gestire l’ereditarietà. Tuttavia, questa organizzazione è una convenzione, non un obbligo stretto. Il C++ consente di mescolare più sezioni public:, private: e protected: nell’ordine che si preferisce, anche se la maggior parte degli sviluppatori predilige una struttura ben definita per rendere il codice più leggibile.

Costruttori: l’inizializzazione di un oggetto

In C++, i costruttori rappresentano funzioni speciali che hanno il compito di inizializzare gli oggetti di una classe. Il costruttore porta lo stesso nome della classe e non restituisce alcun tipo, nemmeno void. Esistono diversi tipi di costruttori: il costruttore di default, il costruttore parametrico, il costruttore di copia e, a partire dal C++11, il costruttore di spostamento. Vediamo un esempio di costruttore parametrico:

class Punto {
private:
    double x, y;

public:
    // Costruttore parametrico
    Punto(double nx, double ny) : x(nx), y(ny) {}

    // Costruttore di default
    Punto() : x(0), y(0) {}
    
    void stampaCoordinate() const {
        std::cout << "(" << x << ", " << y << ")" << std::endl;
    }
};

Nell’esempio, si notano alcune caratteristiche salienti. In primo luogo, il costruttore parametrico Punto(double nx, double ny) utilizza una lista di inizializzazione (: x(nx), y(ny)) per assegnare i valori delle variabili membro. L’uso della lista di inizializzazione è un aspetto rilevante nella sintassi di una classe: permette di inizializzare i campi ancor prima che entri in esecuzione il corpo della funzione, e in molti casi è preferibile (o addirittura necessario) per motivi di efficienza o di correttezza.

In secondo luogo, il costruttore di default Punto() è definito per inizializzare x e y a zero. Se non lo avessimo specificato, il compilatore avrebbe potuto generare un costruttore di default di tipo implicito, ma soltanto a certe condizioni (per esempio, se non sono presenti altri costruttori definiti dall’utente o se i tipi membro lo consentono). Esplicitare un costruttore di default spesso aiuta a rendere più chiaro il comportamento della classe.

Distruttori: liberare le risorse

Se un costruttore crea o acquisisce risorse che necessitano di essere rilasciate, allora diventa importante definire un distruttore. Nella sintassi di una classe, il distruttore ha un nome che corrisponde a quello della classe preceduto dal simbolo ~. Un esempio ipotetico potrebbe essere:

class GestoreRisorsa {
private:
    int* dati;

public:
    // Costruttore
    GestoreRisorsa(int dimensione) {
        dati = new int[dimensione];
    }

    // Distruttore
    ~GestoreRisorsa() {
        delete[] dati;
    }
};

All’uscita dalla visibilità dell’oggetto, il distruttore viene chiamato automaticamente e si occupa di rilasciare l’area di memoria precedentemente allocata con new[]. Anche se in molti casi moderni si preferisce utilizzare costrutti di smart pointer (come std::unique_ptr o std::shared_ptr) per evitare di gestire la memoria manualmente, è fondamentale conoscere e padroneggiare la sintassi del distruttore, poiché rappresenta uno dei pilastri dell’approccio RAII (Resource Acquisition Is Initialization) su cui C++ fonda gran parte della sua filosofia di gestione delle risorse.

Metodi: funzioni membro e overload di operatori

Uno degli aspetti più distintivi della sintassi di una classe in C++ risiede nella possibilità di definire funzioni all’interno della dichiarazione o al di fuori di essa (tramite l’operatore di risoluzione dello scope ::). Per esempio, potremmo scrivere:

class Studente {
private:
    std::string nome;
    int eta;

public:
    Studente(const std::string& n, int e) : nome(n), eta(e) {}

    void saluta();  // Dichiarazione

    std::string getNome() const {
        return nome;
    }

    int getEta() const {
        return eta;
    }
};

// Definizione al di fuori della classe
void Studente::saluta() {
    std::cout << "Ciao, mi chiamo " << nome << " e ho " << eta << " anni." << std::endl;
}

La scelta di definire una funzione membro all’interno o all’esterno della classe dipende dalle preferenze di stile, dalla complessità della funzione o da esigenze di ottimizzazione. Scrivere la funzione inline, all’interno della classe, può talvolta portare a miglioramenti di performance grazie a possibili ottimizzazioni del compilatore, ma ciò non significa che sia sempre conveniente inserire codice molto lungo direttamente nel corpo della classe. Molti sviluppatori preferiscono mantenere solo la dichiarazione nella classe e rinviare la definizione a un file separato (tipicamente un file .cpp), in modo da alleggerire la lettura e favorire la manutenzione del codice.

Un altro elemento tipico della sintassi di una classe in C++ riguarda l’overloading degli operatori. C++ permette di ridefinire il comportamento di operatori come +, -, ==, = e molti altri. Questo avviene scrivendo funzioni con nomi speciali, per esempio operator+, operator==, etc.:

class Vettore3D {
private:
    double x, y, z;

public:
    Vettore3D(double nx, double ny, double nz) : x(nx), y(ny), z(nz) {}

    // Operatore di somma
    Vettore3D operator+(const Vettore3D& altro) const {
        return Vettore3D(x + altro.x, y + altro.y, z + altro.z);
    }

    // Operatore di confronto
    bool operator==(const Vettore3D& altro) const {
        return (x == altro.x) && (y == altro.y) && (z == altro.z);
    }
};

Questa caratteristica rende C++ molto expressivo, perché permette di usare la notazione con operatori in modo naturale anche con i propri tipi personalizzati.

Accesso ai membri: public, private e protected

Una delle domande più frequenti, quando si parla di classi, riguarda la scelta tra public, private e protected. Dal punto di vista sintattico, si tratta di specificatori di accesso che indicano chi può vedere e modificare i membri della classe. public indica che il membro è accessibile a tutti, private significa che è visibile e modificabile solo dall’interno della classe stessa o da funzioni amiche, mentre protected diventa rilevante soprattutto con l’ereditarietà, poiché rende i membri accessibili alle classi derivate, ma non al mondo esterno.

Vale la pena sottolineare che, se si omette qualsiasi specificatore, la visibilità di default per le classi in C++ è private. Di conseguenza, un costruttore non dichiarato come public: sarebbe inaccessibile all’esterno, rendendo impossibile la creazione di oggetti se non da funzioni o classi amiche. In molti casi, l’approccio preferibile è quello di rendere pubbliche solo le funzioni membro che costituiscono l’interfaccia esterna necessaria e mantenere privati i dettagli di implementazione, in modo da ridurre il rischio di accessi impropri o modifiche involontarie.

Ereditarietà: la sintassi per estendere una classe

C++ supporta l’ereditarietà, vale a dire la possibilità di creare una nuova classe (detta derivata) a partire da un’altra classe (detta base). Questo consente di condividere codice e di implementare meccanismi di polimorfismo. La sintassi essenziale per dichiarare una classe derivata è la seguente:

class Base {
public:
    void metodoBase() {}
};

class Derivata : public Base {
public:
    void metodoDerivata() {}
};

In questo esempio, Derivata estende Base in modalità pubblica, il che significa che tutto ciò che era pubblico in Base rimane pubblico in Derivata. Se avessimo scritto class Derivata : private Base, i membri pubblici di Base sarebbero diventati privati in Derivata. Questo meccanismo permette di controllare il livello di accesso ereditato.

All’interno della sintassi dell’ereditarietà, se la classe base ha un costruttore di default, la classe derivata lo eredita implicitamente. Se invece vogliamo chiamare un costruttore non di default della base, occorre farlo nella lista di inizializzazione del costruttore della derivata:

class Base {
protected:
    int valore;
public:
    Base(int v) : valore(v) {}
};

class Derivata : public Base {
public:
    // Richiama il costruttore di Base
    Derivata(int v) : Base(v) {}
};

La sintassi dell’ereditarietà si intreccia naturalmente con quella dei costruttori, dei distruttori e di tutti i meccanismi che fanno parte dell’uso delle classi.

Polimorfismo e funzioni virtuali

Uno dei motivi principali per cui l’ereditarietà viene utilizzata in C++ è il polimorfismo, grazie al quale una funzione virtuale definita in una classe base può essere ridefinita in una classe derivata. La sintassi prevede la parola chiave virtual prima del tipo di ritorno della funzione nella classe base:

class Animale {
public:
    virtual void faiVerso() {
        std::cout << "Verso generico" << std::endl;
    }
};

class Cane : public Animale {
public:
    void faiVerso() override {
        std::cout << "Bau!" << std::endl;
    }
};

Usando un puntatore o un riferimento alla classe base che in realtà punta a un’istanza della derivata, è possibile ottenere il comportamento ridefinito:

Animale* a = new Cane();
a->faiVerso();  // Stampa: "Bau!"
delete a;

Il concetto di polimorfismo illustra bene quanto la sintassi della classe in C++ sia versatile. Le funzioni virtuali consentono di creare gerarchie di classi in cui i metodi ridefiniti si comportano differentemente a seconda del tipo effettivo dell’oggetto, pur utilizzando un’interfaccia comune.

Classi astratte e funzioni pure virtuali

La possibilità di dichiarare funzioni come puramente virtuali (= 0) permette di definire classi astratte, ossia classi che non possono essere istanziate direttamente ma servono come base per classi concrete. La sintassi si presenta così:

class Forma {
public:
    virtual double area() const = 0;  // Funzione pura virtuale
};

In un caso come questo, Forma è una classe astratta, perché contiene almeno una funzione virtuale pura. Le classi derivate dovranno implementare area(), altrimenti rimarranno anch’esse astratte. Questo meccanismo diventa essenziale ogni volta che si vuole stabilire un’interfaccia comune che dovrà essere ereditata e implementata dalle sottoclassi, garantendo la coerenza del design.

Membri statici: condivisione tra tutte le istanze

All’interno della sintassi di una classe in C++, si possono definire membri statici, sia dati che funzioni. Un membro statico non appartiene a una singola istanza, bensì alla classe nel suo complesso. Un esempio semplice:

class Contatore {
private:
    static int totale;

public:
    Contatore() {
        totale++;
    }

    static int getTotale() {
        return totale;
    }
};

// È obbligatorio definire il membro static in un file .cpp
int Contatore::totale = 0;

In questo frammento, la variabile totale è condivisa da tutte le istanze di Contatore. Ogni volta che creiamo un oggetto di tipo Contatore, il costruttore incrementa totale. Per ottenere il numero complessivo di oggetti creati, basta chiamare Contatore::getTotale(), senza neanche dover avere un’istanza in mano. È un approccio spesso usato per contatori globali, costanti simboliche e altre risorse che devono essere condivise tra gli oggetti di quella classe.

Metodi const e mutable

Il C++ fornisce anche la possibilità di dichiarare metodi come const, il che significa che all’interno della funzione non si modificheranno i dati membri dell’oggetto (fatto salvo per quelli dichiarati mutable). Ecco un esempio:

class DatiImmutabili {
private:
    int valore;
    mutable int contatoreAccessi;

public:
    DatiImmutabili(int v) : valore(v), contatoreAccessi(0) {}

    // Metodo const: non modifica 'valore', ma può modificare 'contatoreAccessi' se è mutable
    int getValore() const {
        contatoreAccessi++;
        return valore;
    }
};

In questo esempio, getValore() è un metodo const e garantisce, quindi, che non ci saranno cambiamenti ai dati membro non mutable. Grazie alla parola chiave mutable, possiamo invece modificare contatoreAccessi anche in un metodo const. Si tratta di un meccanismo abbastanza avanzato, che viene utilizzato in particolari scenari in cui occorre tenere traccia delle statistiche di accesso o di altri dati di servizio, senza rompere la regola che un metodo const non deve alterare lo stato logico dell’oggetto.

Dichiarazioni friend: funzioni e classi amiche

La sintassi di una classe C++ include anche la facoltà di dichiarare funzioni o classi amiche (friend), consentendo loro di accedere ai membri privati e protetti. Si tratta di un meccanismo che va usato con cautela, perché rende più debole l’incapsulamento. Tuttavia, risulta utile in alcuni casi. Per esempio:

class MiaClasse {
private:
    int segreto;

public:
    MiaClasse(int s) : segreto(s) {}

    friend void stampaSegreto(const MiaClasse& obj);
};

void stampaSegreto(const MiaClasse& obj) {
    std::cout << "Il segreto è: " << obj.segreto << std::endl;
}

Grazie alla parola chiave friend nel corpo di MiaClasse, la funzione stampaSegreto può accedere al membro privato segreto. Nella pratica, l’uso di friend tende a rimanere limitato a situazioni particolari, spesso relative a sovraccarichi di operatori o a funzioni di utility che hanno effettivamente bisogno di accedere ai dettagli interni di una classe.

Differenze sintattiche tra class e struct

In C++, class e struct condividono pressoché la stessa sintassi, con la differenza che, in una struct, i membri sono pubblici di default, mentre in una class sono privati di default. A parte questo dettaglio, la gestione di costruttori, distruttori, funzioni membro, ereditarietà e tutto il resto segue le stesse regole. In contesti di programmazione orientata agli oggetti, la parola chiave class viene preferita per indicare l’intenzione di costruire un’entità incapsulata, mentre struct viene spesso utilizzata per oggetti più semplici, in cui si vogliono mantenere i dati come pubblici e in cui la presenza di metodi è ridotta all’essenziale. Ma non è affatto raro imbattersi in struct che funzionano quasi come classi, soprattutto in librerie e template, segno che la differenza è molto più di convenzione che di sostanza.

Esempio completo: una semplice classe “Banca”

Per chiudere la panoramica sulla sintassi della classe, può essere utile mostrare un esempio leggermente più ampio che metta insieme alcuni dei concetti finora illustrati. Immaginiamo di dover rappresentare un conto bancario, con la possibilità di depositare, prelevare e tenere traccia del saldo:

#include <iostream>
#include <string>

class ContoBancario {
private:
    std::string intestatario;
    double saldo;

public:
    // Costruttore parametrico
    ContoBancario(const std::string& nome, double importoIniziale) 
        : intestatario(nome), saldo(importoIniziale) {}

    // Funzione per depositare
    void deposita(double importo) {
        if (importo > 0) {
            saldo += importo;
            std::cout << "Depositati " << importo << " euro. Nuovo saldo: " << saldo << std::endl;
        } else {
            std::cout << "Importo non valido." << std::endl;
        }
    }

    // Funzione per prelevare
    void preleva(double importo) {
        if (importo <= saldo && importo > 0) {
            saldo -= importo;
            std::cout << "Prelevati " << importo << " euro. Nuovo saldo: " << saldo << std::endl;
        } else {
            std::cout << "Operazione non valida." << std::endl;
        }
    }

    // Getter per il saldo
    double getSaldo() const {
        return saldo;
    }

    // Getter per l'intestatario
    std::string getIntestatario() const {
        return intestatario;
    }
};

int main() {
    ContoBancario conto("Mario Rossi", 1000.0);
    std::cout << "Intestatario: " << conto.getIntestatario() 
              << ", Saldo iniziale: " << conto.getSaldo() << std::endl;

    conto.deposita(200.0);
    conto.preleva(150.0);
    conto.preleva(2000.0);

    return 0;
}

In questa classe ContoBancario, troviamo un costruttore parametrico, due funzioni membro per depositare e prelevare, e due metodi getter che forniscono accesso in sola lettura ai campi intestatario e saldo. La sintassi evidenzia come, con poche righe di codice, si riesca a definire un contenitore logico capace di racchiudere dati e comportamenti in modo coerente.

Considerazioni di stile: header e file di implementazione

Se il nostro progetto cresce, o se stiamo lavorando in un team, è comune adottare una suddivisione tra file di header (.h o .hpp) e file di implementazione (.cpp). La sintassi di una classe in un file header prevede solo le dichiarazioni di variabili membro e funzioni, lasciando che la loro implementazione venga inserita in un file .cpp corrispondente. È una scelta che aumenta la manutenibilità del codice e riduce i tempi di compilazione, poiché gli altri file che includono l’header non devono ricompilare l’intera logica.

Un’organizzazione tipica è la seguente:

// File: ContoBancario.h
#ifndef CONTO_BANCARIO_H
#define CONTO_BANCARIO_H

#include <string>

class ContoBancario {
private:
    std::string intestatario;
    double saldo;

public:
    ContoBancario(const std::string& nome, double importoIniziale);
    void deposita(double importo);
    void preleva(double importo);
    double getSaldo() const;
    std::string getIntestatario() const;
};

#endif // CONTO_BANCARIO_H

// File: ContoBancario.cpp
#include "ContoBancario.h"
#include <iostream>

ContoBancario::ContoBancario(const std::string& nome, double importoIniziale) 
    : intestatario(nome), saldo(importoIniziale) {}

void ContoBancario::deposita(double importo) {
    if (importo > 0) {
        saldo += importo;
        std::cout << "Depositati " << importo << " euro. Nuovo saldo: " << saldo << std::endl;
    } else {
        std::cout << "Importo non valido." << std::endl;
    }
}

void ContoBancario::preleva(double importo) {
    if (importo <= saldo && importo > 0) {
        saldo -= importo;
        std::cout << "Prelevati " << importo << " euro. Nuovo saldo: " << saldo << std::endl;
    } else {
        std::cout << "Operazione non valida." << std::endl;
    }
}

double ContoBancario::getSaldo() const {
    return saldo;
}

std::string ContoBancario::getIntestatario() const {
    return intestatario;
}

In questo modo, il codice risulta meglio suddiviso: l’header espone l’interfaccia pubblica della classe, mentre il file di implementazione contiene i dettagli di come le funzioni lavorano dietro le quinte.

Final e override

Con l’avvento di C++11 e successive versioni dello standard, sono stati introdotti alcuni elementi sintattici per rendere più sicuro e chiaro il polimorfismo. La parola chiave override posta dopo la firma di una funzione virtuale in una classe derivata segnala l’intento di ridefinire una funzione già presente nella classe base:

class Base {
public:
    virtual void metodo() {}
};

class Derivata : public Base {
public:
    void metodo() override {
        // Implementazione differente
    }
};

Se per errore il metodo nella classe derivata non corrisponde esattamente a quello della classe base, il compilatore mostrerà un avviso o un errore. Questo riduce i possibili fraintendimenti tipici della programmazione polimorfica.

L’ulteriore parola chiave final permette di indicare che una classe non può essere ulteriormente ereditata, oppure che una specifica funzione virtuale non può essere ulteriormente ridefinita. È un elemento facoltativo, ma utile per imporre vincoli precisi e chiarire le intenzioni di design.

Classi annidate e spazi dei nomi

La sintassi di C++ consente anche di annidare le classi, cioè di definire una classe all’interno di un’altra. Ci sono situazioni in cui ciò risulta comodo, magari quando una classe è strettamente legata all’implementazione interna di un’altra e non ha senso esporla direttamente all’utente esterno. Inoltre, si possono usare i namespace per organizzare le classi in un contesto logico, evitando collisioni di nomi:

namespace Libreria {
    class Analizzatore {
    public:
        void elabora() {}
    };
}

int main() {
    Libreria::Analizzatore a;
    a.elabora();
    return 0;
}

Questo esempio mostra la dichiarazione di una classe Analizzatore all’interno del namespace Libreria. Per istanziarla, si deve qualificare il suo nome con Libreria::. È un meccanismo essenziale per progetti di grandi dimensioni, dove la probabilità di avere nomi duplicati aumenta.

La sintassi della classe in C++ costituisce il fondamento della programmazione orientata agli oggetti nel linguaggio. Attraverso parole chiave come class, public:, private:, protected:, virtual, override e tante altre, il C++ offre un set di strumenti ricco e flessibile che permette di progettare sistemi software complessi senza rinunciare a controllo e performance. Proprio grazie a questa versatilità, le classi possono essere impiegate sia per strutture dati estremamente basilari sia per vere e proprie architetture polimorfiche.

La comunità di sviluppatori C++ ha sviluppato nel tempo una serie di buone pratiche intorno alla sintassi e all’organizzazione delle classi: tenere i dati privati, fornire metodi d’accesso (get e, se necessario, set), utilizzare costruttori chiari e un distruttore quando serve, evitare friend se non strettamente necessario, rendere i metodi cost const-correct e così via. L’insieme di queste convenzioni aiuta a scrivere codice più sicuro, leggibile e manutenibile.

Allo stesso tempo, è interessante notare come C++ non si fermi all’orientamento a oggetti tradizionale, ma accolga anche stili di programmazione generica e funzionale. Il concetto di classe rimane comunque un pilastro, perché anche quando si sfruttano template, lambda e altre funzionalità più moderne, si fa spesso ricorso a strutture dati e oggetti che vengono definiti attraverso la sintassi classica delle classi. Imparare a fondo questa sintassi, con tutte le sue sfaccettature, rappresenta quindi un passaggio inevitabile per chiunque desideri padroneggiare il C++ e sfruttarne al massimo le potenzialità.

Nel guardare al futuro, si notano miglioramenti continui del linguaggio, con l’obiettivo di renderlo più sicuro e più espressivo, ma la forma di base della classe e i suoi meccanismi fondamentali (costruttori, distruttori, metodi, override, ereditarietà) difficilmente subiranno cambiamenti radicali. Sono, di fatto, le basi su cui si costruisce un’enorme varietà di pattern e paradigmi.

Per concludere, la sintassi della classe in C++ è una vera e propria architettura in miniatura, in cui ciascun pezzo trova una collocazione precisa. Capire come dichiarare i membri, come gestirne la visibilità, come definire costruttori e distruttori, come attivare l’ereditarietà e il polimorfismo e come utilizzare gli operatori e i metodi statici è la chiave per scrivere codice orientato agli oggetti robusto e ben progettato. Una volta metabolizzata questa sintassi, ci si accorge che, dietro la ricchezza di regole e convenzioni, si apre una vasta prateria di possibilità creative: dagli oggetti più semplici a quelli più elaborati, la classe diventa un luogo di sintesi tra dati e comportamenti, un piccolo universo logico che rende il software più facile da organizzare e comprendere. Non resta che continuare a esplorare, con la certezza che la sintassi della classe è un compagno di viaggio insostituibile in qualunque percorso all’interno del mondo C++.