Risposte:
I cast in stile C ++ vengono controllati dal compilatore. I cast in stile C non sono e possono fallire in fase di esecuzione.
Inoltre, i cast in stile c ++ possono essere cercati facilmente, mentre è davvero difficile cercare i cast in stile c.
Un altro grande vantaggio è che i 4 diversi cast in stile C ++ esprimono più chiaramente l'intento del programmatore.
Quando scrivo C ++, userei quasi sempre quelli C ++ rispetto allo stile C.
dynamic_casts.
(int)somethingnon può fallire - si ottiene cast per int o errore del compilatore.
In breve :
static_cast<>() ti dà la possibilità di compilare il tempo di verifica, il cast di C-Style no.static_cast<>() è più leggibile e può essere individuato facilmente ovunque all'interno di un codice sorgente C ++, il cast di C_Style non è.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 bytesPoiché ciò comporta un puntatore a 4 byte (un puntatore al tipo di dati 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 corruptionContrariamente 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 errorPuoi anche controllare questa pagina per ulteriori spiegazioni sui cast C ++: fai clic qui
Vedi Un confronto tra gli operatori di casting C ++ .
Tuttavia, l'utilizzo della stessa sintassi per diverse operazioni di casting può rendere poco chiaro l'intento del programmatore.
Inoltre, può essere difficile trovare un tipo specifico di cast in una base di codice di grandi dimensioni.
la generalità del cast in stile C può essere eccessiva per le situazioni in cui tutto ciò che serve è una semplice conversione. La possibilità di selezionare tra diversi operatori di casting con diversi gradi di potenza può impedire ai programmatori di lanciare inavvertitamente un tipo errato.
struct A {};
struct B : A {};
struct C {};
int main()
{
A* a = new A;
int i = 10;
a = (A*) (&i); // NO ERROR! FAIL!
//a = static_cast<A*>(&i); ERROR! SMART!
A* b = new B;
B* b2 = static_cast<B*>(b); // NO ERROR! SMART!
C* c = (C*)(b); // NO ERROR! FAIL!
//C* c = static_cast<C*>(b); ERROR! SMART!
}Un ottimo post che spiega diversi cast in C / C ++ e cosa fa realmente il cast in stile C: https://anteru.net/blog/2007/12/18/200/index.html
Casting in stile C, usando la sintassi della variabile (tipo). Il peggio mai inventato. Questo tenta di eseguire i seguenti cast, in questo ordine: (vedi anche C ++ Standard, 5.4 expr.cast paragrafo 5)
- const_cast
- static_cast
- static_cast seguito da const_cast
- reinterpret_cast
- reinterpret_castSeguito da const_cast
static_castcontrolla al momento della compilazione che la conversione non sia tra tipi ovviamente incompatibili. Al contrario dynamic_cast, nessun controllo per la compatibilità dei tipi viene eseguito in fase di esecuzione. Anche,static_cast conversione non è necessariamente sicura.
static_cast viene utilizzato per convertire da puntatore a classe base in puntatore a classe derivata o tra tipi nativi, come enum in int o float in int.
L'utente di static_cast deve assicurarsi che la conversione sia sicura.
Il cast in stile C non esegue alcun controllo, né in fase di compilazione né in fase di esecuzione.
Poiché esistono diversi tipi di casting, ciascuno con una semantica diversa, static_cast <> ti consente di dire "Sto facendo una conversione legale da un tipo a un altro" come da int a double. Un semplice cast in stile C può significare molte cose. Sei su / giù casting? Stai reinterpretando un puntatore?