Newsgroup: it.comp.lang.c++
Titolo: Conversione da double a int

Aiuto!
Ho un grave problema. non riesco a trovare il modo di convertire un calcolo
da double a int.
Dovrei riuscire ad eseguire il seguente passaggio che era stato progettato
in basic:
d=sin(differenza/23)-int(sin(differenza/23))
com'è in C++?
L'help non mi è molto utile.
Diego Pettenò

]

 d=sin(diff/23)-(int)sin(diff/23)
Guarda che scrivere
int( ... )
o
(int) ...
è la stessa cosa.
EMG


Beh.. allora non capisco il suo problema...


come venga arrotondato)
....
direi che, a meno di grandi colpi di c***, varra' sempre 0.
tiberio


M'e' venuto un dubbio (perche' in C solo il secondo e' consentito):
semanticamente non sono due cose differenti? Nel primo caso viene
costruito un oggetto di tipo int a partire da un double, il secondo si
tratta di un effettivo cast. Sbaglio?


com'č in C++?
Non capisco cosa tu voglia calcolare (apparentemente
la parte frazionaria di sin(...)) comunque quello che
hai scritto e` corretto, solo che la 2 parte dell'espressione
sara` praticamente sempre 0 perche` in C++ la
conversione a int avviene per troncamento.
Paolo
-----------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
-----------------------------------------------

come venga arrotondato)
Si usa il troncamento. Per convertire usando l'arrotondamento
basta scrivere static_cast<int>(f+0.5)


(int) ...
esatto, aggiungo solo che la prima notazione
non puo` essere utilizzata con identificatori di tipo
formati da piu` token.
non si puo` cioe` scrivere int*(qualcosa)...
ma necessariamente (int*)qualcosa
Ovviamente sarebbe bene usare i cast new-style
(ecco un'altra domanda da faq... perche` usare i
cast new style e non quelli stile C?)


Beh.. allora non capisco il suo problema...
Probabilmente la domanda era un'altra ma non c'e`
ancora arrivato. Intendo dire che probabilmente la
causa dei suoi problemi non e` quella che crede lui.
Mi sa tanto che ci arrivera` presto una domanda in
stile "calcolo numerico"...
Nota... altra faq!   Ormai sta diventando un vizio (quello
di trovare faq...:)


 tratta di un effettivo cast. Sbaglio?
Da quanto ne so io non ci dovrebbe essere differenza. Comunque sentiamo
altri pareri...
EMG

tratta di un effettivo cast. Sbaglio?
Sono la stessa cosa...
Il compilatore usa un operatore di conversione al tipo destinazione
se questo e` stato dichiarato nella classe del tipo iniziale,
altrimenti cerca un costruttore idoneo tra le definizioni
del tipo finale (se non erro...).
Paolo
Nota.
  I costruttori unari sono anche operatori di conversione ed
  il compilatore li tratta come tali. Oltretutto e` l'unico modo
  per convertire da tipo preesistente.


E con questo, Paolo Marotta mi salva! Per puro caso mi ha dato la soluzione:
dopo poco dalla pubblicazione del messaggio mi sono accorto che il problema
era che arrotondava e mi dava un intero anche dove doveva essere un double e
cosě mi dava errore!
Grazie.
Diego Pettenň

 tratta di un effettivo cast. Sbaglio?
Non capisco dove possa notarsi una differenza. La trasformazione da float ad
int *credo* sia comunque una allocazione di un nuovo oggetto, magari previa
deallocazione dell'oggetto float.
Se poi supponiamo che il tutto avvenga nei registri, credo si debbano
comunque usare registri diversi.
Intendo dire: per passare da int a char si può semplicemente ignorare il
tipo e usare le istruzioni macchina sulle stesse locazioni di memoria, per
passare da float a int servono invece funzioni di conversione in entrambi i
casi, no?
--
Alessandro Monti