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

Ciao a tutti,
ho compilato il seguente programma:
int main ()
{
   int a = 76543;
   short b;
   b = a;
   return 0;
}
Pensavo di ricevere un Warning dal compilatore ed invece niente. 
Ho compilato sia con Visual C++ 6.0 (con l'opzione Warning level = 4)
sia con gcc (con l'opzione -Wall). Entrambi non hanno segnalato il
Warning.
Non penso che si tratti di un bug, qualcuno mi sa dire perchè non
ricevo un warning?
Grazie
Stefano

 ha scritto nel messaggio
news:618f713f.0307...@posting.google.com...

io penso che i compilatori comincino a rendersi conto che e' inutile
segnalare dei "warnings"
in quanto l'utente li ignora tutti :)

Compilato con VC6, Warning level 4, Rebuild all:
c:\...\bo.c(8) : warning C4244: '=' : conversion from 'int ' to 'short ',
possible loss of data
A proposito della battuta di renzo, ci sono persone che non lasciano perdere
neanche un solo warning, come il sottoscritto :))
E' bellissimo vedere compilare un programma con "0 errors, 0 warnings"...
Ciao,
Paolo PAL

 E' bellissimo vedere compilare un programma con "0 errors, 0 warnings"...
Salvo poi accorgersi che con il livello di warning piu' alto, VC++
genera warning con I SUOI FILE.
C:\>iao Angelo
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 genera warning con I SUOI FILE.
Non riesco a capire cosa intendi dicendo "i suoi file".
Ciao,
Paolo PAL

"Paolo PAL" <pc...@tiscaliNienteRobaccia.it> wrote in message
news:bejls2$er3$
1...@lacerta.tiscalinet.it

winnt.h(199) :
   warning C4201: nonstandard extension used : nameless struct/union
winbase.h(481) :
   warning C4201: nonstandard extension used : nameless struct/union
mmsystem.h(1623) :
   warning C4201: nonstandard extension used : nameless struct/union
wtypes.h(1039) :
   warning C4201: nonstandard extension used : nameless struct/union
oaidl.h(394) :
   warning C4201: nonstandard extension used : nameless struct/union
Tutti file di include di VC++
:-)


ricevo un warning?
Perché il compilatore non esegue controlli sul contenuto effettivo
della memoria.  Il sistema sa che i tipi interi sono compatibili e
quindi un'assegnazione di quel tipo è lecita;  il compilatore non ti
da un warning perché dovrebbe dartelo anche per una situazione del
tipo:
int main()
{
    int a = 4;
    short b;
    b = a;
}
è bene, invece, che tu sappia, che assegnazioni di quel tipo possono
produrre risultati indefiniti (nel senso, ad esempio, che potrebbe
esserci o meno un "wrap-around" del valore).
-- 
Andrea Laforgia - a.laforgia(at)
libero.it
"There are three kinds of people in this world; 
 those who are good at maths and those who aren't".

Tutti file di include di VC++
Sono alcuni degli header dell'SDK di Windows.  Probabilmente non si
sono voluti prendere la briga di tradurli perché VC++ li digerisse
senza problemi.


 Tutti file di include di VC++
Perfetto, tutto chiaro e *tutto confermato*  :))
Ciao,
Paolo PAL.


È chiaro che il compilatore non esegue un controllo sui valori, come
potrebbe fare. Ma io mi aspetto un warning, mi deve dire stai attento che
potresti avere dei problemi (possible loss of data). Come tu stesso scrivi
puoi avere problemi numerici. Se a = 0x12345678 b sarà uguale a 0x5678.
Facendo un cast implicito, vengono considerati solo gli ultimi 4 nibble.
Se compili il seguente programma ottieni un warning (anche con livello 3)
int main()
{
    double a = 76543.;
    float b;
    b = a;
  return 0;
}
Anche compilando :
int main()
{
    long a = 76543;
    short b;
    b = a;
  return 0;
}
ottieni un warning.
A me sembra il comportamento del compilatore (Visual C) poco consistente.
Gcc almeno è consistente non produce warning, ma forse usato le opzioni
sbagliate (solo -Wall). C'è qualche esperto coi in gcc che mi sa aiutare?
Forse devo settare il livello 4 per i warning come dice Paolo e poi
ignorarli come dice Renzo :-)
Ciao e grazie
Stefano

Caro Stefano,
dopo aver riflettuto tutto il pomeriggio (o quasi:) sulla tua domanda e dopo
aver verificato che anche
questo morto di sonno del  mio compilatore( Dev-C++  ) non si scomponeva di
1 mm  se assegnavo un int a uno short, ho cercato aiuto nella "rete delle
reti" e ho trovato che non siamo i soli ad avere questi  2B |^2B ?
o meglio, per questo newsgroup e anche x il sottoscritto  2C|^2C  ?
infatti su:
http://gcc.gnu.org/ml/gcc-help/2003-06/msg00086.html
Sar chiede:   "I want to know about which gcc command line option will give
the warning when
downcasting of integer variables to short/char etc."
e Eljan risponde:
" None. Implicit "downcasting" from int to short or char is part of C/C++.
So such
code is completely legal and legit. Unfortunately."
... e quindi: chi glielo fa' fa' al compilatore di scomodarsi
 se tutto rientra nella completa legalita' ????
mmmmmmmmm  poveri noi ... se dimentico un ";" e' -------->'na tragedia
se invece gli chiedo di far entrare un TIR nella PUNTO -->tutto OK!

 ha scritto nel messaggio
news:tkmPa.163949$Ny5.4...@twister2.libero.it...
ora non per andare molto ot mi chiedevo se facendo i cast con perdita si
perde o si generano segni sbagliati ???
cioe' un 63000 int in un short che diventa ??? 30mila o -1 ???
cioe' pui' che altro volevo sapere se tutti i cast fanno
prendiamo bit segno []
poi prendiamo gli n bit meno significativi che arrivano a riempire il cast
fino all'n-1 bit e poi ci piazziamo il segno cosi anche se si perde data non
si perde coerenza
o se solo brutalmente prendono le prime n cifre le sbattono nel contenitore
e chi si e' visto si e' visto e tu quello che ottieni sono cassi tuoi ???
mi chiarite questo ??? farei un po di prove con il compilatore ma sono
giorni di cacca e non ho 10 minuti per scrivermi i case tnx
ciao

potresti avere dei problemi (possible loss of data). 
No.  Lo standard, che io sappia, non richiede che vengano sollevati
dei warning. 


cioe' un 63000 int in un short che diventa ??? 30mila o -1 ???
Dipende dal sistema.


 se invece gli chiedo di far entrare un TIR nella PUNTO -->tutto OK!
LOL
Ciao Stefano

 ciao
Ciao

-2536 (63000 int == 0x0000F618 / 0xF618 == -2536 short)
Non è detto, dipende dal sistema.


 dei warning.
Hai ragione. Il compilatore č libero di sollevare i warning come
meglio crede.
Dopo lunghe riflessioni e discussioni con altri colleghi, sono
arrivato alla seguente conclusione:
consideriamo il prog
int main()
{
   short a, b, c;
   c = a + b;
   return 0;
}
Il compilatore prima di eseguire la somma a+b converte i numeri in
integer (integral promotion). Poi dovrebbe convertire l'int (a+b) in
un short (c).
Se il compilatore funtionasse come da me auspicato, dovrebbe sollevare
un warning anche in questo caso.
Dato che gran parte del mondo funziona a 16bit, la compilazione di
alcuni programmi produrrebbe una infinitą di warning inutili.
Per non annoiare il programmatore, penso che il compilatore ha deciso
di non sollevare warning nel caso di conversione da int a short.
Ciao e grazie a tutti
Stefano

integer (integral promotion). 
Non sono del tutto convinto di questo.  E`, anche questa, una
caratteristica dipendente dalla piattaforma.  Non ci farei troppo
affidamento.



Non dipende dal sistema. È definito dallo standard. L'operazione viene
chiamata integral promotion.
saluti
Stefano


Francamente non vedo quali altre possibilità ha il sistema. Puoi farmi un
esempio?

 
Forse non centra niente, ma la STL del VC   6.0 mi ha provato a
dare 1046 warning, tutti nell'implementazione M$ delle STL. E
la M$ si limita a consigliare di disattivare i warning !
Ciao
   hammer

 ha scritto nel messaggio
news:ben4u3$t81$1...@gossip.excite.it...

e poi ci chiediamo da dove escono i bug :-p
ciao ciao

 farmi un esempio?
Uno short int in DOS e' equivalente a 8 bit signed. E anche sul C64 ^_^
-- 
-=[]=---iAN CooG---=[]=-
echo gv.berovy@2017anv | rot13 | reverse


Hai ragione. Io mi riferivo al modo in cui viene effettuetato il casting.
Passando da int ad un short la parola viene semplicemente troncata, senza
considera il bit di segno. (Nel posting veniva chiesto con veniva effettuato
un cast con perdita)
Che in diversi sistemi uno short possa avere un diverso numero di byte mi
era chiaro.
Per chiarezza, nel mio esempio vale: int --> 4 byte / short --> 2 byte
Ciao Stefano