Perché usare static_cast <int> (x) invece di (int) x?

Ho sentito che la static_castfunzione dovrebbe essere preferita al casting in stile C o semplice. È vero? Perché?

La ragione principale è che classici calchi C non fanno distinzione tra ciò che noi chiamiamo static_cast<>(), reinterpret_cast<>(), const_cast<>(), e dynamic_cast<>(). Queste quattro cose sono completamente diverse.

A static_cast<>()è di solito sicuro. Esiste una conversione valida nella lingua o un costruttore appropriato che lo rende possibile. L'unica volta che è un po 'rischioso è quando ti abbassi a una classe ereditata; devi assicurarti che l'oggetto sia effettivamente il discendente che asserisci di essere, in modo esterno al linguaggio (come una bandiera nell'oggetto). A dynamic_cast<>()è sicuro fintanto che il risultato è selezionato (puntatore) o viene presa in considerazione una possibile eccezione (riferimento).

Una reinterpret_cast<>()(o una const_cast<>()) d'altra parte è sempre pericolosa. Dici al compilatore: "fidati di me: so che questo non sembra un foo(sembra che non sia mutabile), ma lo è".

Il primo problema è che è quasi impossibile dire quale accadrà in un cast in stile C senza guardare pezzi di codice grandi e dispersi e conoscere tutte le regole.

Supponiamo che:

class CDerivedClass : public CMyBase {...};
class CMyOtherStuff {...} ;

CMyBase  *pSomething; // filled somewhere

Ora, questi due sono compilati allo stesso modo:

CDerivedClass *pMyObject;
pMyObject = static_cast<CDerivedClass*>(pSomething); // Safe; as long as we checked

pMyObject = (CDerivedClass*)(pSomething); // Same as static_cast<>
                                     // Safe; as long as we checked
                                     // but harder to read

Tuttavia, vediamo questo codice quasi identico:

CMyOtherStuff *pOther;
pOther = static_cast<CMyOtherStuff*>(pSomething); // Compiler error: Can't convert

pOther = (CMyOtherStuff*)(pSomething);            // No compiler error.
                                                  // Same as reinterpret_cast<>
                                                  // and it's wrong!!!

Come puoi vedere, non esiste un modo semplice per distinguere tra le due situazioni senza sapere molto su tutte le classi coinvolte.

Il secondo problema è che i cast di tipo C sono troppo difficili da individuare. In espressioni complesse può essere molto difficile vedere i cast in stile C. È praticamente impossibile scrivere uno strumento automatizzato che deve individuare i cast in stile C (ad esempio uno strumento di ricerca) senza un front-end del compilatore C ++ completo. D'altra parte, è facile cercare "static_cast <" o "reinterpret_cast <".

pOther = reinterpret_cast<CMyOtherStuff*>(pSomething);
      // No compiler error.
      // but the presence of a reinterpret_cast<> is 
      // like a Siren with Red Flashing Lights in your code.
      // The mere typing of it should cause you to feel VERY uncomfortable.

Ciò significa che non solo i cast in stile C sono più pericolosi, ma è molto più difficile trovarli tutti per assicurarsi che siano corretti.

Un consiglio pragmatico: puoi cercare facilmente la parola chiave static_cast nel tuo codice sorgente se prevedi di riordinare il progetto.

In breve :

1. static_cast<>() ti dà la possibilità di compilare il tempo di verifica, il cast di C-Style no.
2. static_cast<>()può essere individuato facilmente ovunque all'interno di un codice sorgente C ++; al contrario, il cast di C_Style è più difficile da individuare.
3. Le intenzioni vengono trasmesse molto meglio usando i cast C ++.

Più spiegazione :

Il cast statico esegue conversioni tra tipi compatibili . È simile al cast in stile C, ma è più restrittivo. Ad esempio, il cast in stile C consentirebbe a un puntatore intero di puntare a un carattere.

char c = 10;       // 1 byte
int *p = (int*)&c; // 4 bytes

Poiché ciò comporta un puntatore a 4 byte che punta a 1 byte di memoria allocata, la scrittura su questo puntatore provocherà un errore di runtime o sovrascriverà della memoria adiacente.

*p = 5; // run-time error: stack corruption

Contrariamente al cast in stile C, il cast statico consentirà al compilatore di verificare la compatibilità dei tipi di dati puntatore e puntatore, il che consente al programmatore di rilevare questa assegnazione errata del puntatore durante la compilazione.

int *q = static_cast<int*>(&c); // compile-time error

Maggiori informazioni su:
Qual è la differenza tra static_cast <> e il cast in stile C
e il
cast regolare rispetto a static_cast vs. dynamic_cast

La domanda è più grande del semplice utilizzo di wither static_cast o casting in stile C perché ci sono diverse cose che accadono quando si usano i cast in stile C. Gli operatori di casting C ++ intendono rendere più esplicite queste operazioni.

In superficie, i cast di static_cast e C style sembrano la stessa cosa, ad esempio quando si lancia un valore su un altro:

int i;
double d = (double)i;                  //C-style cast
double d2 = static_cast<double>( i );  //C++ cast

Entrambi eseguono il cast del valore intero in un doppio. Tuttavia, quando si lavora con i puntatori, le cose si complicano. qualche esempio:

class A {};
class B : public A {};

A* a = new B;
B* b = (B*)a;                                  //(1) what is this supposed to do?

char* c = (char*)new int( 5 );                 //(2) that weird?
char* c1 = static_cast<char*>( new int( 5 ) ); //(3) compile time error

In questo esempio (1) forse OK perché l'oggetto indicato da A è in realtà un'istanza di B. Ma cosa succede se a quel punto nel codice non si sa a cosa effettivamente indica? (2) forse perfettamente legale (vuoi solo guardare un byte dell'intero), ma potrebbe anche essere un errore nel qual caso un errore sarebbe carino, come (3). Gli operatori di casting C ++ intendono esporre questi problemi nel codice fornendo errori di compilazione o di runtime quando possibile.

Quindi, per un rigoroso "casting di valore" puoi usare static_cast. Se si desidera eseguire il casting polimorfico di runtime dei puntatori, utilizzare dynamic_cast. Se vuoi davvero dimenticare i tipi, puoi usare reintrepret_cast. E per lanciare const dalla finestra c'è const_cast.

Rendono solo il codice più esplicito in modo che sembri che tu sappia cosa stavi facendo.

static_castsignifica che non puoi accidentalmente const_casto reinterpret_cast, il che è una buona cosa.

1. Permette di trovare facilmente i cast nel tuo codice usando grep o strumenti simili.
2. Rende esplicito il tipo di cast che stai facendo e coinvolge l'aiuto del compilatore per applicarlo. Se vuoi solo eliminare la costanza, puoi usare const_cast, che non ti permetterà di fare altri tipi di conversioni.
3. I cast sono intrinsecamente brutti: tu come programmatore stai annullando il modo in cui il compilatore tratterebbe normalmente il tuo codice. Stai dicendo al compilatore "lo so meglio di te". Stando così le cose, ha senso che eseguire un cast dovrebbe essere una cosa moderatamente dolorosa da fare e che dovrebbero sporgere nel tuo codice, poiché sono una probabile fonte di problemi.

Vedi Introduzione al C ++ efficace

Si tratta di quanta sicurezza del tipo vuoi imporre.

Quando scrivi (bar) foo(il che equivale a reinterpret_cast<bar> foose non hai fornito un operatore di conversione del tipo) stai dicendo al compilatore di ignorare la sicurezza del tipo, e fai solo come è stato detto.

Quando scrivi static_cast<bar> foostai chiedendo al compilatore di controllare almeno che la conversione del tipo abbia senso e, per i tipi integrali, di inserire un codice di conversione.

MODIFICA 26/02/2014

Ho scritto questa risposta più di 5 anni fa e ho sbagliato. (Vedi commenti.) Ma ottiene ancora voti!

I cast di stile C sono facili da perdere in un blocco di codice. I cast in stile C ++ non sono solo buone pratiche; offrono un grado di flessibilità molto maggiore.

reinterpret_cast consente integrali conversioni di tipo puntatore, tuttavia può essere pericoloso se utilizzato in modo improprio.

static_cast offre una buona conversione per tipi numerici, ad es. da enum a ints o ints a float o qualsiasi tipo di dato di cui si è certi del tipo. Non esegue alcun controllo del tempo di esecuzione.

dynamic_cast, d'altra parte, eseguirà questi controlli segnalando eventuali assegnazioni o conversioni ambigue. Funziona solo su puntatori e riferimenti e comporta un sovraccarico.

Ce ne sono un paio, ma questi sono i principali che incontrerai.

static_cast, oltre a manipolare i puntatori alle classi, può anche essere utilizzato per eseguire conversioni esplicitamente definite nelle classi, nonché per eseguire conversioni standard tra tipi fondamentali:

double d = 3.14159265;
int    i = static_cast<int>(d);