Newsgroup: it.comp.lang.c++
Titolo: Cast

Ciao. Rieccomi dopo tanto tempo passato nell'ombra ad osservare.
Che differenza c'è tra due conversioni di questo tipo:
double d;
int    i;
i=(int)d;  /*Come da manuale*/
e
i=int(d);  /*Come secondo me e' piu' intuitiva*/

E' una domanda chiaramente...... :)

Devil Inside,
anch'io attendevo trepidante una risposta esaustiva, poiché non sono un
profondo conoscitore del C++ e dei suoi meccanismi (talvolta subdoli :).
Provo a toglierti dallo stato di ansia nell'attesa della risposta, fermo
restando che sono molto ben accette risposte piů esaustive (e magari piů
esatte) di quella che sto per darti.
Nel primo caso 
  i = (int)d;
effettui un forzamento nel tipo della variabile d, chiedendo al
compilatore di trattarlo "come se fosse un intero" ed eventualmente
richiedendone la conversione della rappresentazione interna.
Nel secondo caso
  i = int(d);
quello che fai č chiamare il costruttore per gli interi nella forma  che
lo inizializza anche. All'interno di esso passi, per l'inizializzazione,
come parametro un double. E' il C++ che in questo caso effettua quindi
la conversione implicita ad un intero... proprio come se avessi scritto
  i = int( (int)d );
il risultato restituito dal costruttore č un intero e tu non ti accorgi
di niente, ottenendo lo stesso risultato (probabilmente l'efficienza č
compromessa).
Il mio dubbio č relativo a quando venga distrutto il valore creato e
come il compilatore capisca di doverlo fare.
Spero di non aver scritto abomini. :)
Salutoni,
Marcello.

La sostanziale differenza è che la seconda sintassi
        nuovo tipo (valore) 
funziona solo con tipi semplici, ma non con char* e simili. Per il resto
entrambe le sintassi sono identiche. 
Cmq l'utilizzo di una o l'altra è soggettivo. Basta tener presente queste
piccole differenze.
PS: Io consiglio di usare (nuovo tipo) valore perché così non devi sempre
chiederti "funzionerà con questo tipo?" 

i=int(d);  /*Come secondo me e' piu' intuitiva*/
Entrambi sono cast c-style (da evitare in C++),
la differenza e` che la seconda sintassi non e`
applicabile con nomi di tipi complessi
(tipo T*...)
Paolo
--------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
--------------------------------------------------

quello che fai è chiamare il costruttore per gli interi
I tipi primitivi non sono classi e non hanno costruttori...
Anche se la scrittura puo` fuorviare.


 Anche se la scrittura puo` fuorviare.
Allora l'ho scritta proprio grossa! ;-)

 i=int(d);  /*Come secondo me e' piu' intuitiva*/
No, nessuna differenza. Sono comunque due tipi di cast obsoleti. In C++
dovresti utilizzare
i=static_cast < int > ( d );
EMG

Grazie a tutti (anche per la rapidita')  :)
Nota per Paolo Marotta: Mi dai il permesso di mettere il tuo tutorial C++
"integrale" zippato sul mio sito ? Senza possibilita' di consultarlo online:
non vorrei attribuirmene il merito... ma disponibile solo zippato per il
download.
Nota per Paolo Marotta 2: Mi hanno riferito, ma non ho verificato, che
sempre lo stesso tutorial te lo hanno plagiato, e messo sul sito della
L.i.s.a. Lo sapevi? E' vero?
Scusate per lo spreco di banda, ma e' anche una ottima occasione per
segnalare ai nuovi arrivati l'ottimo tutorial sopra citato.
(
www.programmazione.it
)

L.i.s.a. Lo sapevi? E' vero?
Si... e nonostante le mie e-mail a tripod non ho ottenuto molto.
Se non fosse per la perdita di tempo e soldi, avrei preso altri
provvedimenti...
Cmq in realta`  il responsabile del sito ha ammesso pubblicamente la 
cosa, anche se cio` non toglie il fastidio. Ad ogni modo sto
prendendo le iniziative del caso per evitare un replay della faccenda.


Non del tutto, l'espresstione di conversione tipo(valore) e' valida
anche per i tipi built-in in modo che ad esempio il seguente 
template <typename T> T crea() { return T(); }
sia valido anche per essi.
Ciao,
Nicola