Newsgroup: it.comp.lang.c++
Titolo: static_cast e reinterpret_cast : qual'e' la differenza di fondo ?

Ciao a tutti ,
non riesco a capire la sottile differenza fra i 2 operatori in
oggetto(o perlomeno non mi e' del tutto chiara) .
Qualcuno potrebbe farmi qualche esempio molto ben dettagliato ?
grazie .

...

Uno static_cast viene normalmente usato per convertire a classe base in uno a
classe derivata. Il suo uso dovrebbe essere disciplinato a tutti e soli i casi
in cui ci sia una ragionevole sicurezza che il cast sia legittimo, in quanto
esso non esegue controlli a run-time. Se la conversione potrebbe fallire è
necessario usare un dynamic_cast. Talvolta viene static_cast viene usato anche
per esplicitare una conversione implicita, come la conversione puntatore a
classe derivata -> puntatore a classe base. E' importante usare static_cast solo
per le conversioni ben definite; in tutti gli altri casi il comportamento è
indefinito.
Riporto di seguito un esempio apparso in [1]
class Base { /* ... */ };
class Derived : public Base {
public:
  // ...
  // Automatic type conversion:
  operator int() { return 1; }
};
void func(int) {}
class Other {};
int main() {
  int i = 0x7fff; // Max pos value = 32767
  long l;
  float f;
  // (1) typical castless conversions:
  l = i;
  f = i;
  // Also works:
  l = static_cast<long>(i);
  f = static_cast<float>(i);
  // (2) narrowing conversions:
  i = l; // May lose digits
  i = f; // May lose info
  // Says "I know," eliminates warnings:
  i = static_cast<int>(l);
  i = static_cast<int>(f);
  char c = static_cast<char>(i);
  // (3) forcing a conversion from void* :
  void* vp = &i;
  // Old way produces a dangerous conversion:
  float* fp = (float*)vp;
  // The new way is equally dangerous:
  fp = static_cast<float*>(vp);
  // (4) implicit type conversions, normally performed by the compiler:
  Derived d;
  Base* bp = &d; // Upcast: normal and OK
  bp = static_cast<Base*>(&d); // More explicit
  int x = d; // Automatic type conversion
  x = static_cast<int>(d); // More explicit
  func(d); // Automatic type conversion
  func(static_cast<int>(d)); // More explicit
  // (5) Static Navigation of class hierarchies:
  Derived* dp = static_cast<Derived*>(bp);
  // ONLY an efficiency hack. dynamic_cast is. Always safer. However:
  // Other* op = static_cast<Other*>(bp); conveniently gives an error message,
  // while
  Other* op2 = (Other*)bp;
  // Does not.
} ///:~
Il reinterpret_cast ha un uso semanticamente diverso. Viene impiegato per
eseguire conversioni tra tipi scorrelati e non più tra tipi legati in un grafo
di ereditarietà. Si tratta di una "brutale reinterpretazione degli stessi bit
che compongolo lìargomento", in altre parole, "un'esplicita violazione del
type-system"
(citazione e codice seguente tratti da [2]).
int main ()    {
char*  charBuffer = new char [100];
int* intBuffer = reinterpret_cast<int*> (charBuffer);
return (0);
}
In [1] se ne dà la seguente definizione:
reinterpret_cast -
To cast to a completely different meaning. The key is that you’ll need to cast
back to the original type to use it safely. The type you cast to is typically
used only for bit twiddling or some other mysterious purpose. This is the most
dangerous of all the casts.
[1] "Thinking C++", Bruce Eckel, Prentice Hall
[2] "C++ Manuale di Stile", Carlo Pescio, Infomedia
AB
--
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Andrea Baruzzo
Via Circonvallazione, 26
Muzzana del Turgnano (UD) - Italy
e-mail: 
andrea....@ud.nettuno.it
~~~~~~~~~~~~~~~~~~~~~~~~~~~~

classe derivata.
... per convertire UN PUNTATORE a classe base in uno a classe derivata.
Mi è sfuggito il soggetto...
Scusate.


oggetto(o perlomeno non mi e' del tutto chiara) .
con static_cast<>  il compilatore esegue il cast *utilizzando gli
operatori di conversione di cui dispone*.
Con reinterpret_cast<> il compilatore semplicemente reinterpreta il
pattern di bit mappandovi sopra la struttura del tipo puntatore verso
cui si esegue il cast.
Questo tipo di conversioni e` plattaform depended (ad esempio una
configurazione di bit valida per un char* puo` non esserlo
per un int*) e corrisponde direttamente alle vecchie conversioni 
C-style.
Paolo
-----------------------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
-----------------------------------------------------------------