Newsgroup: it.comp.lang.c++
Titolo: su static_cast, dynamic_cast, ecc.

io sono "nato" con il c e mi sono convertito in maniera convinta al
c++...
ma c'è una cosa del c++ che proprio non mi va giù, lo static_cast!!
allora, premettendo che non conosco l'utilizzo di dynamic_cast e degli
altri (lessical_cast??!?), mi ricordo di aver letto da qualche parte
che la sintassi del cast era stata complicata nel c++ perché i
programmatori usassero i cast il meno possibile...
però per calcolare il resto di una divisione (è un esempio!! lo so che
esiste %!!) a me viene molto semplice scrivere
r = (a / b - (int) (a / b)) * b;
piuttosto che
r = (a / b - static_cast<int>(a / b)) * b;
sbaglio? lo stesso se dovessi fare una divisione e castarla in float
da due interi:
c = (float) a / b;
no?
-- 
]\/[ad]\/[age (
www.mindreamz.net
)
"Un Maestro insegue semplicemente la sua visione di Eccellenza in
qualunque cosa sta facendo e lascia agli altri decidere se sta 
lavorando o giocando. A lui sembra sempre di fare entrambe." - Anonimo

 no?
Be', per me hai ragione. 
Anche perche', non mi sono mai trovato bene nemmeno io con i cast del C++.
Molte volte mi e' servito leggere ciascuno dei singoli 4 byte di un intero
e l'reinterpret_cast<char*>(intero) mi ha dato problemi, infatti non
funzionava correttamente e mi dava risultati diversi dal solito.
Qualcuno ci potrebbe spiegare la differenza precisa fra:
static_cast
dynamic_cast
const_cast
reinterpret_cast
e C like cast ()
(Facendo magari qualche esempio)
Grazie a tutti voi.
-- 
Vladislav Valtchev

 no?
Nei questi casi, non e evidente la raggione per static_cast.
Podarsi questo essempio ti aiuta.
class A
{
     public:
     int     m_a;
};
class oA
{
     public:
     double  m_a;
};
class B : public A
{
     public:
};
class oB : public oA
{
     public:
};
int main()
{
     B       b;
     oB      ob;
     A     * a = & b;
     oA    * oa = & ob;
     B     * pb = static_cast<B *>( a );
     oB    * pob = static_cast<oB *>( oa );
     oB    * errore = static_cast<oB *>( a );
     oB    * sbaglio = ( oB * )( a ); // sbaglio qui ma il compilatore 
lo acceta
     // Altri essempii dei sbagli
     float * f = (float *) "a";
}
I operatori dei cast in C++ sono piu definiti e "narrow" in funzione de 
if cast in C.  Anche che non e "semplice" come in C, il consiglio e che 
e piu corretto a usare i C++ cast.
(Scusa come scrivo il italiano, non e la mia lingua maggiore.)
Ciao

 e C like cast ()
Una tra const_cast, static_cast o reinterpret_cast :(
La cosa brutta e' che andando a modificare il programma, alterando ad
esempio la definizione di un tipo, poi un cast di questo tipo puo'
cambiare pesantemente significato. Es (non dei migliori, forse, ma non
mi viene altro al momento):
const int a=3;
int funz(int&);
funz(const_cast<int>(a)); //Versione corretta
funz(int(a)); //Versione con cast C, funziona uguale, infatti il cast C
e' in questo caso un const_cast
Se pero ora cambio la prima riga in:
const float a=3;
La versione C++ (3a riga) mi dara' un errore, di fatto segnalandomi un
problema che avevo trascurato, mentre alla 4a riga il cast C non e' piu'
un const_cast, ma diventa un const_cast+static_cast (di fatto
cambiandomi in silenzio il significato del programma).
 bye
	av.

 e C like cast ()
AFAIK e` come reinterpret_cast, ma magari ha qualche particolarita` che
mi sfugge.
E` comunque  da evitare. Gli  altri cast  forniscono un'idea  precisa di
quello che  il programmatore voleva fare,  il cast C invece  non ci dice
nulla.
Kronos
-- 
Home: 
http://kronoz.cjb.net
Windows NT crashed.
I'm the Blue Screen of Death.
No one hears your screams.

 ma c'è una cosa del c++ che proprio non mi va giù, lo static_cast!!
"What good is static-cast?"
http://www.research.att.com/~bs/bs_faq2.html#static-cast
_dave_

r = (a / b - (int) (a / b)) * b;
Puoi però usare:
r = ( a/b - int(a/b) ) * b;
-- 
Saluti,
Andrea (uno dei tanti)
mailto:
acola...@bigfoot.com

 r = ( a/b - int(a/b) ) * b;
Non e' esattamente la stessa cosa?
 bye
	av.

allora mi sembra di capire che se si casta tra classi è bene usare
static_cast, dynamic_cast e compagnia, se si casta tra tipi (non
costanti) primitivi (ad esempio int, long, float, ecc.), passi pure la
sintassi c, dico bene?
