Specificatori di accesso in C++: public, private, protected

Chi può toccare i tuoi dati

Quando hai scritto la tua prima classe, probabilmente hai esposto ogni membro al mondo esterno. Funziona, ma butta via uno dei motivi principali per cui esistono le classi: l'incapsulamento, cioè nascondere lo stato interno di una classe in modo che il resto del programma possa interagire con essa solo attraverso un'interfaccia controllata. Gli specificatori di accesso sono lo strumento con cui tracci quel confine.

Sono esattamente tre: public, private e protected. Ognuno etichetta i membri che lo seguono, e l'etichetta decide quale codice può leggerli o scriverli. Se li usi bene, la tua classe fa rispettare le proprie regole; se li usi male, qualsiasi bug in qualsiasi punto può corrompere lo stato del tuo oggetto.

I tre specificatori

Uno specificatore è una parola chiave seguita dai due punti. Ogni membro dichiarato dopo di esso, fino allo specificatore successivo, ricade in quel livello di accesso.

#include <iostream>
using namespace std;

class Account {
public:
    void deposit(double amount) { balance += amount; }  // chiunque può chiamarlo
    double getBalance() const { return balance; }       // chiunque può leggerlo

private:
    double balance = 0.0;   // solo il codice di Account può toccarlo
};

int main() {
    Account a;
    a.deposit(100.0);
    cout << a.getBalance() << endl; // 100
    // a.balance = 999999;          // ERRORE: balance è private
    return 0;
}

Togli il commento dall'ultima riga e il compilatore si rifiuta di compilare: balance è private, quindi main non può metterci mano direttamente. È proprio questo lo scopo: l'unico modo per cambiare il saldo è passare da deposit, il che significa che in seguito puoi aggiungere controlli (niente depositi negativi, log, limiti) in un solo punto ed essere certo che vengano sempre applicati.

Ecco il quadro completo:

//             accessibile da...
// public      ovunque (qualsiasi codice che abbia l'oggetto)
// private     solo i membri della classe stessa (+ friend)
// protected   i membri della classe stessa E le classi derivate (+ friend)

class e struct: il default

Puoi scrivere quanti blocchi di specificatori vuoi, in qualsiasi ordine. L'accesso dei membri prima del primo specificatore dipende da se hai usato class o struct:

• In una class, i membri sono private per impostazione predefinita.
• In una struct, i membri sono public per impostazione predefinita.

Questo default è l'unica differenza a livello di linguaggio tra le due parole chiave. Una struct può avere metodi, costruttori e sezioni private esattamente come una class.

#include <iostream>
using namespace std;

class Locked {
    int secret = 42;   // private di default, nessuno specificatore necessario
};

struct Open {
    int value = 7;     // public di default
};

int main() {
    Open o;
    o.value = 99;           // ok: public
    cout << o.value << endl; // 99

    // Locked l;
    // l.secret = 1;         // ERRORE: secret è private
    return 0;
}

Per convenzione si usa struct per semplici raggruppamenti di dati pubblici e class quando vuoi comportamento e stato nascosto, ma il compilatore non lo impone: cambia solo il default.

Incapsulamento con getter e setter

Lo schema di tutti i giorni è questo: i dati vanno in una sezione private e un metodo public ne offre un accesso controllato. Un getter di sola lettura restituisce il valore; un setter lo valida prima di assegnarlo. È qui che private ripaga.

#include <iostream>
using namespace std;

class Temperature {
public:
    void setCelsius(double c) {
        if (c < -273.15) {          // la fisica dice che non puoi scendere oltre
            cout << "Ignoring impossible temperature\n";
            return;
        }
        celsius = c;
    }
    double getCelsius() const { return celsius; }
    double getFahrenheit() const { return celsius * 9.0 / 5.0 + 32.0; }

private:
    double celsius = 0.0;
};

int main() {
    Temperature t;
    t.setCelsius(25);
    cout << t.getCelsius() << " C = " << t.getFahrenheit() << " F\n";

    t.setCelsius(-500);             // rifiutato, lo stato resta valido
    cout << t.getCelsius() << " C\n"; // ancora 25
    return 0;
}

Dato che celsius è private, non c'è modo di infilarci un valore non valido: ogni scrittura deve passare da setCelsius, che protegge l'invariante. Nota che i getter sono marcati const: promettono di non modificare l'oggetto, quindi puoi chiamarli anche su oggetti const Temperature.

protected ed ereditarietà

protected conta solo quando entra in gioco l'ereditarietà. Per il codice esterno si comporta come private, ma una classe derivata può raggiungerlo. Usalo per i membri di cui una sottoclasse ha davvero bisogno ma che il resto del programma non dovrebbe comunque vedere.

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

class Animal {
protected:
    string name = "unknown";   // le sottoclassi possono usarlo...

public:
    void setName(const string& n) { name = n; }
};

class Dog : public Animal {
public:
    void speak() const {
        // 'name' è protected, quindi Dog può leggerlo direttamente
        cout << name << " says Woof!\n";
    }
};

int main() {
    Dog d;
    d.setName("Rex");
    d.speak();            // Rex says Woof!
    // cout << d.name;    // ERRORE: protected resta fuori dalla portata del codice esterno
    return 0;
}

Un errore comune da principianti è usare protected su ogni membro dati "nel caso una sottoclasse ne abbia bisogno". Così allarghi silenziosamente il contratto della classe: ora ogni sottoclasse può dipendere da quel campo e tu non puoi più cambiarlo liberamente. Preferisci private e passa a protected solo quando una classe derivata ha davvero bisogno di quell'accesso.

La via d'uscita friend

A volte una singola funzione o classe esterna ha legittimamente bisogno di vedere i tuoi dettagli interni: un caso classico è l'overloading dell'operatore <<, che non puoi rendere un membro. La parola chiave friend concede a quella specifica entità l'accesso ai tuoi membri private e protected, e a nessun altro.

#include <iostream>
using namespace std;

class Point {
public:
    Point(int x, int y) : x(x), y(y) {}

    // concede a questa funzione specifica l'accesso ai membri privati
    friend ostream& operator<<(ostream& os, const Point& p);

private:
    int x, y;
};

ostream& operator<<(ostream& os, const Point& p) {
    return os << "(" << p.x << ", " << p.y << ")"; // può leggere i privati x, y
}

int main() {
    Point p(3, 4);
    cout << p << endl; // (3, 4)
    return 0;
}

friend è un'eccezione voluta e chirurgica: è la classe stessa a indicare esattamente di chi si fida, quindi nessuno può concedersi l'accesso dall'esterno. Usalo con parsimonia; se ti ritrovi ad aggiungere tanti friend, probabilmente quei membri non avrebbero dovuto essere private fin dall'inizio, oppure il tuo design va ripensato.

Errori comuni da evitare

• Rendere public ogni membro. Sembra comodo, ma perdi tutti i controlli e le invarianti che l'incapsulamento ti garantisce. Parti da dati private con metodi public.
• Dimenticare il default di class. class Foo { int x; }; rende x private, quindi foo.x = 5 non compila. Se volevi un semplice raggruppamento di dati, usa struct o aggiungi un'etichetta public:.
• Abusare di protected. È un confine più debole di private e ha senso solo con l'ereditarietà. Usarlo ovunque lega le sottoclassi a campi che potresti voler cambiare.
• Aspettarsi che private sia una misura di sicurezza. È una regola in fase di compilazione che impedisce accessi accidentali, non una cifratura. I byte restano in memoria; private riguarda un design pulito, non la segretezza.

Prossimo: Struct

Hai visto che una struct è in realtà solo una class i cui membri sono public di default. La prossima pagina, sulle struct, approfondisce quando quel default pubblico è esattamente ciò che ti serve, cioè aggregati leggeri per raggruppare valori correlati, e come struct si usa nel C++ idiomatico accanto a classi complete.