Newsgroup: it.comp.java
Titolo: Riguardo al Casting !

er favore , qualcuno è in grado di farmi comprendere le righe
sottostanti ?
Soprattutto le ultime ...riguardo il numero 128 ...
"C’è da fare però una precisazione. Facciamo un esempio:
byte b = 50;
Questo statement è corretto. Il numero intero 50 è tranquillamente
compreso
nell’intervallo di rappresentazione di un byte che va da –128 a +127.
Il compilatore
determina la grandezza del valore numerico, e controlla se è
compatibile con il tipo di
dato dichiarato. Allora, consideriamo quest’altro statement:
b = b * 2;
Ciò darà luogo ad un errore in compilazione! Infatti, il compilatore
non eseguirà
l’operazione di moltiplicazione per controllare la compatibilità con
il tipo di dato
dichiarato, bensì, promuoverà automaticamente la cifra che si trova
alla destra
dell’espressione di assegnazione ad int, dato che di default assumerà
che 2 sia un
int. Quindi, se 50*2 è un int, non può essere immagazzinato in b che è
un byte.
Il fenomeno appena descritto è conosciuto sotto il nome di "promozione
automatica
nelle espressioni". Ma, evidentemente, 50*2 è immagazzinabile in un
byte. Esiste una
tecnica per forzare una certa quantità, ad essere immagazzinata in un
certo tipo di dato.
Questa tecnica è nota con il nome di "cast" (o "casting"). La sintassi
da utilizzare per
risolvere il nostro problema è:
b = (byte)(b * 2);
In questo modo, il compilatore sarà avvertito che un’eventuale perdita
di precisione, è
calcolata e sotto controllo.
Bisogna essere però molto prudenti nell’utilizzare il casting in modo
corretto. Infatti se
scrivessimo:
b = (byte)128;
il compilatore non segnalerà nessun tipo d’errore. In realtà, siccome
il cast agisce
troncando i bit in eccedenza (nel nostro caso, siccome un int utilizza
32 bit, mentre un
byte solo 8, saranno troncati i primi 24 bit dell’int), la variabile b
avrà il valore di
–128 e non di 128! "
grazie a tutti...ciao

 grazie a tutti...ciao
La prima parte del testo mi sembra abbastanza chiara da se magari devi solo
rileggerla con più attenzione, per quanto riguarda l'ultimo cast quello di
128 da int a byte basta considerare la rappresentazione in binario
128 in 32 bit si scrive così
00000000 00000000 00000000 10000000
convertendelo in byte elimini i primi 24 bit quindi ottieni
10000000
che è uguale a
(-1)*1*128 + 0*64 + 0*32 + 0*16 + 0*8 + 0*4 + 0*2 + 0*1 = -128
questo perchè il valore del primo bit prima di essere sommato va
moltiplicato per -1
invece 50 è rappresentato in 32 bit come
00000000 00000000 00000000 00110010
troncandolo in byte ottieni
00110010
che equivale a
(-1)*0*128 + 0*64 + 1*32 + 1*16 + 0*8 + 0*4 + 1*2 + 0*2 = 32 + 16 + 2 = 50
spero di esserti stato utile
ciao gigabyte

ciao gigabyte
ciao e grazie di nuovo !
raffaele

 grazie a tutti...ciao
I Byte hanno 256 valori che nel caso si stia parlando di Signed vanno
da -128 a 127 e vengono scritti rappresentati in una sucessione di 1 e 0
chiamata in complemento a 2, che non corrisponde alla loro rappresentazione
in base 2. Il 127 è 111111111, se a tale numero aggiungi un bit (per avere
128), otterrai 100000000, ma non potendo scrivere da nessuna parte quell'uno
su un byte in realtà dovrai tenere gli 8 zeri che corrispondono alla primo
numero rappresentabile con un byte:-128.


Adesso non so se Java funziona in modo strano, ma normalmente
"complemento a 2" non significa quello che hai descritto.
Normalmente si intende che i numeri negativi vengono rappresentati
prendendo il valore assoluto, invertendo tutti i bit della
rappresentazione binaria e aggiungendo 1. I numeri positivi e lo zero
vengono rappresentati normalmente
Il bit piu' a sinistra, in questo modo, sara' sempre 1 per i numeri
negativi e zero per quelli positivi. Nel caso in esame si avrebbe:
127    -> 01111111
127+1  -> 10000000
Ma
-128   -> -(10000000) -> 01111111+1 -> 10000000
11111111 è invece la rappresentazione di un numero negativo. In
particolare:
11111111 -> -(00000000 + 1) -> -1
Alcune particolarità di questa notazione:
A) -0 -> 11111111 + 1 -> 00000000 (si scartano i bit eccedenti quelli
rappresentabili)
B) sommando la rappresentazione di due numeri (siano essi positivi o
negativi) il risultato è corretto. Es:
2 + (-3) 
   -> 00000010 + -(00000011) 
   -> 00000010 + (11111100 + 1) 
   -> 00000010 + 11111101 
   -> 11111111 
   -> -1   corretto
Andrea