Risposta.

Nel linguaggio C++, la conversione dei tipi consente di indicare esplicitamente al compilatore come convertire un oggetto da un tipo a un altro. Nelle prime versioni di C++ (C++98) si utilizzava il C-style cast ((int)x). Tuttavia, questo approccio è implicito e spesso porta a errori, poiché il compilatore non può controllare la correttezza o la sicurezza della conversione. Per aumentare la sicurezza sono stati introdotti operatori di conversione dei tipi specializzati, tra cui static_cast svolge un ruolo importante.

Storia della questione:

Fino all'introduzione della parola chiave static_cast, gli sviluppatori si trovavano spesso di fronte a errori a causa di conversioni implicite. Con l'introduzione di static_cast in C++98 è diventato possibile distinguere esplicitamente le diverse intenzioni e garantire che la conversione venga eseguita solo dove ha senso a tempo di compilazione.

Problema:

Spesso è necessario convertire tipi compatibili (ad esempio, valori numerici o puntatori a classi correlate tramite ereditarietà), ma farlo in modo trasparente e sicuro. La conversione standard in stile C mescola implicitamente le conversioni controllate dal compilatore e quelle potenzialmente pericolose.

Soluzione:

static_cast è progettato per una conversione esplicita, ma statica, di tipi compatibili. È più sicuro rispetto alla normale conversione in stile C e non consente di eseguire conversioni di tipi completamente incompatibili a tempo di compilazione.

Esempio di codice:

class Base { };
class Derived : public Base { };

Base* b = new Derived();
Derived* d1 = static_cast<Derived*>(b); // corretto, se b punta effettivamente a Derived
int x = 10;
double y = static_cast<double>(x); // funziona

Caratteristiche principali:

Consente solo quelle conversioni che sono valide a tempo di compilazione
Non esegue controlli a tempo di esecuzione (a differenza di dynamic_cast)
Viene utilizzato per conversioni "normali" tra classi base e derivate, tipi numerici, puntatori, void*

Domande trabocchetto.

È possibile utilizzare static_cast per convertire tra tipi completamente non correlati, ad esempio int e double**

No, il compilatore non consentirà tale conversione senza un esplicito passaggio intermedio tramite void*, poiché i tipi non sono direttamente correlati. Ad esempio:

int* p1;
double* p2 = static_cast<double*>(p1); // errore di compilazione

È possibile utilizzare static_cast per un cast "discendente" sicuro da una classe base a una derivata? Cosa succede se il puntatore non punta a un oggetto del tipo derivato?

static_cast può eseguire tale conversione, ma non verifica il tipo reale a tempo di esecuzione. Se il puntatore base non punta a un oggetto della classe derivata necessaria, il risultato sarà un comportamento indefinito:

Base* base = new Base;
Derived* wrong = static_cast<Derived*>(base); // UB! Tipo errato

Come si comporta static_cast con l'ereditarietà privata?

static_cast non consentirà di convertire un puntatore o un riferimento alla classe base in una derivata attraverso un'ereditarietà privata o protetta al di fuori della classe derivata o dei suoi amici, generando un errore a tempo di compilazione.

Errori tipici e anti-pattern

Utilizzare static_cast per conversioni tra tipi non correlati
Utilizzare static_cast per una conversione "discendente" senza controlli di tipo a tempo di esecuzione
Tentare di aggirare le restrizioni di accesso (ereditarietà pubblica/protetta/privata)

Esempio dalla vita reale

Caso negativo

Un programmatore utilizza static_cast senza riflettere per convertire qualsiasi puntatore da una classe base a una derivata, senza controllare il reale tipo sottostante (ad esempio, per ottimizzare la velocità).

Vantaggi:

Il codice si compila e funziona nei test
Non c'è overhead a tempo di esecuzione (come per dynamic_cast)

Svantaggi:

Con l'arrivo di nuovi eredi o di una logica diversa, si verifica immediatamente un comportamento indefinito
È difficile rintracciare la causa di un crash del programma

Caso positivo

Utilizzare static_cast solo dopo aver verificato il tipo dell'oggetto tramite metadati aggiuntivi o design (o per conversioni sicure tra tipi numerici).