Newsgroup: it.comp.dotnet
Titolo: differenza tra short

ho il seguente codice:
lsDelta.Add((lsRitardi[idx] - lsRitardi[idx -1]));
lsRitardi sono short.
Mi aspettavo che la differenza fra due short desse ancora uno short 
invece mi ritorna un int, da qui l'erore di compilazione:
Errore	1	Impossibile convertire in modo implicito il tipo 'int' in 
'short'. È presente una conversione esplicita. Probabile cast mancante. 
D:\Visual studio 2010\Projects\Lotto\Analisi.cs	65	27	Lotto
Vorrei capire il perchè?
Forse c'entra il boxing che converte i termine di una opErazione in int?
Grazie Ferradini

 Vorrei capire il perchè?
mi vengono in mente alcuni motivi ma la "regola" è nelle specifiche di 
C#
The integral-type unary and binary operators always operate with signed 
32-bit precision, unsigned 32-bit precision, signed 64-bit precision, 
or unsigned 64-bit precision:
For the unary – operator, the operand is converted to type T, where T 
is the first of int and long that can fully represent all possible 
values of the operand. The operation is then performed using the 
precision of type T, and the type of the result is T. The unary – 
operator cannot be applied to operands of type ulong.
Pagina 80 (in fondo)
.m
-- 
Mauro Servienti
{C67C0157-5D98-4733-A75E-93CAEE4BADC8}
Microsoft MVP - Visual C# / MCTS
http://mvp.support.microsoft.com/profile/mauro
blog @ 
http://milestone.topics.it
whynot [ at ] topics [ dot ] it


La risposta è ovviamente quella che ha scritto Mauro.
La motivazione credo sia intuitiva. Sia la somma che la differenza tra 
due short può diventare più grossa di uno short, provocando un 
overflow.
La soluzione ovvia è quindi di usare un int per poter contenere il 
risultato in tutta sicurezza.
-- 
Raffaele Rialdi  
http://www.iamraf.net
Weblog: 
http://blogs.ugidotnet.org/raffaele
Microsoft MVP profile 
https://mvp.support.microsoft.com/profile/raffaele
UGIdotNET - 
http://www.ugidotnet.org/

 risultato in tutta sicurezza.
La motivazione non e' quella, tant'e' che secondo quella logica un'addizione 
per esempio fra int dovrebbe tornare long, ecc., il che ovviamente non e'.
La motivazione penso sia legata al fatto che l'architettura sottostante 
converte comunque a int gli operandi (piu' piccoli) prima di effettuare 
un'operazione. La stessa cosa avviene in C/C++. Questo perche' int sono i 
registri al livello di CPU (non so nei dettagli cosa avviene sulle macchine 
a 64 bit, ma la situazione non cambia).
Un consiglio e': se si tratta di fare calcoli, non usare short o byte bensi' 
direttamente int, le performance ci guadagnano sensibilmente.
-LV
 
--- Posted via news://
freenews.netfront.net/
 - Complaints to 
ne...@netfront.net
 ---

 Forse c'entra il boxing che converte i termine di una opErazione in int?
Gli operandi vengono convertiti a int perche' cosi' funzionano gli operatori 
aritmetici (una spiegazione leggermente piu' dettagliata nel mio altro 
post): ma non c'e' boxing di mezzo, hai boxing quando un value-type viene 
convertito a reference-type...


 64 bit, ma la situazione non cambia).
Le specifiche di C# evitano volutamente qualsiasi dipendenza 
dall'architettura hardware cosa che ovviamente C++ non può fare.
Infatti int in C++ cambia a seconda della CPU mentre int in C# è sempre 
lo stesso.


 stesso.
E' quello che ho detto: la situazione non cambia. Non mi riferivo a 
dipendenze effettive dall'architettura, cercavo di spiegaro la motivazione 
all'origine di quella scelta nel disegno del framework. Sul fatto che "cosi' 
funzionano gli operatori, punto" siamo d'accordo.
