Conversione implicita in duplicato

Quindi, sono un po ‘confuso. Ho avuto l’impressione che questo dovrebbe funzionare: in questo caso, sia a che b sono inte (contatori per essere esatti).

Poiché il risultato di a / b può contenere eventualmente posizioni decimali, ints ovviamente non funzionerà. Pertanto, ho delarato un nuovo doppio ed eseguito il calcolo al suo interno in questo modo:

double texturefactor = ((a / b) * 10); 

Questo non funziona come mi aspettavo, e il risultato di a / b è sempre quello che otterrei se eseguissi il calcolo usando un int per memorizzare i risultati. D’altra parte, questo funziona:

 double calculate1 = a; double calculate2 = b; double texturefactor = ((calculate1 / calculate2) * 10); 

Un paio di domande forse stupide- 1. Sono sicuro che questo dovrebbe funzionare- So che in certe situazioni VS si lamenterà che ho provato a convertire implicitamente da un tipo a un altro- Questo è quello che sto cercando di fare! Perché non lo fa, e ho perso qualcosa? 🙂 2. Devo solo convertire i contatori a e b in doppio e salvare me stesso il problema della conversione, o è un problema?

L’espressione, compresi i tipi di sottoespressioni, viene valutata dall’interno all’esterno:

 double texturefactor = ((a / b) * 10); 

Quando il compilatore analizza a / b , non ha idea che il risultato verrà successivamente convertito in double , quindi compila il calcolo come una divisione intera.

Lanciare esplicitamente uno dei due operandi per double destra è sufficiente per evitare quella confusione:

 double texturefactor = (((double)a / b) * 10); 

Il risultato di a / b è un altro numero intero, quindi anche se lo fai, il danno è già stato fatto:

 double texturefactor = ((a / b) * 10); 

Prova a convertire una delle tue variabili interne in una double :

 var texturefactor = (( (double)a / b) * 10); 

Il risultato di (double)a / b sarà un doppio e non perderai la tua frazione.

Per rispondere alla tua seconda domanda:

Dovrei solo convertire i contatori a e b in doppio

Anche quello funzionerebbe. Se modifichi quelli per double , allora non dovresti eseguire il cast precedente.

Quando hai l’espressione (a / b) , il compilatore C # ignora che verrà successivamente assegnato a un double . Si concentra solo su quella espressione e vede int / int , quindi usa la divisione intera . Ciò significa che il risultato viene arrotondato al numero intero successivo prima che sia mai convertito in double .

È necessario assicurarsi che C # tratti la divisione come una divisione di double s, non int s, ad esempio:

 double texturefactor = (((double)a / b) * 10); // or double texturefactor = 10d * a / b; // or double texturefactor = 10.0 * a / b; 

La ragione per questo double texturefactor = ((a / b) * 10); non funziona è che tutti i parametri sul lato destro sono di tipo int quindi i calcoli vengono eseguiti in int non double come pensi.

Puoi esplicitamente trasmettere a o b per raddoppiare. Piace

 double texturefactor = (((double) a / b) * 10); 

Nel tuo secondo codice da quando hai definito a e b come doppio, ora i calcoli sono fatti in doppio tipo.

Devi castare i valori int per raddoppiare:

 int a = some_value; int b = some_value; double texturefactor = (double)a / b * 10; 

La divisione intera non avrà valori decimali solo perché stai assegnando i loro valori a una double variabile.

Se vuoi precisione, il tuo secondo metodo è abbastanza buono.

 double calculate1 = a; double calculate2 = b; double texturefactor = ((calculate1 / calculate2) * 10); 

Quanto sopra è buono.

Non ti consiglierò di doppiarlo perché c’è un sovraccarico da pagare.

Il risultato della divisione di due interi è sempre un numero intero. Quindi è necessario

 double texturefactor = (((double)a / b) * 10); 

Pertanto, ho delarato un nuovo doppio ed eseguito il calcolo al suo interno in questo modo:

Ah no.

double texturefactor = ((a / b) * 10);

Sintassi di base Si dichiara un doppio (fattore di trama). Assegnagli il risultato di una pura ope- razione intera – (a / b) * 10

A causa delle precedenze questo è a / b (numeri interi, cifre buttate via) volte 10. THEN implicita convergenza.

Tipico errore da principiante – ma molti lo fanno.

Vuoi una doppia aritmetica, assicurati che uno qualsiasi degli elementi sia un doppio, ad esempio:

((doppio) a / b) * 10

eseguirà una conversione piont floating per tutti gli elementi.