Newsgroup: it.comp.programmare.win32
Titolo: warnig di conversione con i LONG

Per memorizzare un "qualcosa" specifico della finestra (come un puntatore
ad una struttura) ho sempre usato SetWindowLong e GetWindowLong con
GWL_USERDATA, come fa anche molto codice scritto da Microsoft.
Con VC++ 7 però ottengo un warning:
warning C4311: 'type cast' : pointer truncation from 'XXX *' to 'LONG'
warning C4312: 'type cast' : conversion from 'LONG' to 'XXX *' of greater size
Perché considerando che sizeof(LONG)==sizeof(XXX*)==4?
-- 
Marco Barisione
http://spazioinwind.libero.it/marcobari/

 Perché considerando che sizeof(LONG)==sizeof(XXX*)==4?
Forse perche` LONG e` signed mentre i puntatori sono unsigned? Da un
punto di vista "di principio" e` vero che c'e` perdita di dati, anche se
poi dal punto di vista "dei bit" non e` cosi`.
-- 
Lorenzo

 poi dal punto di vista "dei bit" non e` cosi`.
Trovato il problema, nel progetto (che ho creato da 0 al contrario dei
vecchi che ho convertito dai file di progetto di VC++6) c'è abilitata
l'opzione "Detect 64-bit Protability Issues".
Ma poi anche su processori s 64 bit non dovrebbe essere
sizeof(LONG)==sizeof(void*)? Penso che una parte enorme dei programmi
scritti per windows faccia queste assunzioni visto che MSDN stessa le
consiglia.



Certo, altrimenti se bastava cambiare un switch di compilazione per avere le
applicazioni a 64 bits, che facevano tutti i programmatori della Microsoft
;-)
Ciao

 Le macchine Intel, AMD possono eseguire anche codice a 32).
Io sapevo che sizeof(long) == sizeof(void*) anche sugli Itanium.
Almeno sul sito HP dicono così, anche per il gcc per linux a 64 bit è così.
In MSDN invece non sono riuscito a trovare niente di preciso, anche se
consiglia di usare LONG_PTR invece di LONG.
Ho anche scoperto che esiste la funzione GetWindowLongPtr ma ne ignoravo
l'esistenza visto che MS nel codice d'esempio usa sempre GetWindowLong.


 Io sapevo che sizeof(long) == sizeof(void*) anche sugli Itanium.
Significa che l'Itanium a i puntatori a 32 bits, vero.
Può eseguire codice a 32 bits, vero.
Quindi tu stati sfruttando queste possibilità, i futuri SO a 64 bits, non
l'ammetteranno.
L'opzione ti garantisce una portabilità per il futuro.
Ciao!!

sizeof(LONG)==sizeof(void*)? 
Dipende.
In generale non è possibile fare assunzioni precise sulla lunghezza
dei tipi, siano essi interi o puntatori.

 l'ammetteranno.
Io intendevo sizeof(long) == sizeof(void*) == 8.
Almeno delle presentazioni trovate sul sito HP sostengono che per l'Itanium
sia così.
Per quanto riguarda lunux e gcc ho trovato qualche messaggio su una ml di
sviluppatori che dicevano che sizeof(long) == sizeof(void*).
Questa era una delle poche assunzioni che facevo sulle dimensioni dei vari
tipi, ma la facevo proprio perché su MSDN moltissimi esempi fanno così :-(


 l'opzione "Detect 64-bit Protability Issues".
Altro problema simile, WinMain deve tornare un int, e in MSDN c'è scritto:
| it should return the exit value contained in that message's wParam parameter
Ma VC++ si lamenta se lo faccio.
VC++ si lamenta anche se uso SetWindowLongPtr, come consiglia MSDN.
A questo punto a cosa serve l'opzione sulla compatibilità se si lamenta se
faccio ciò che è scritto in MSDN?


 VC++ si lamenta anche se uso SetWindowLongPtr, come consiglia MSDN. 
vediamo il codice-2
-- 
  < 
http://www.reactos.com/
 >  Open source clone of Windows NT. Current
      Don't stand, REACT!      version 0.1.4. C, C++ and ASM developers
                               and beta testers are welcome!

 queste assunzioni visto che MSDN stessa le consiglia.
dimmi dove, chè so già che non è vero


 dimmi dove, chè so già che non è vero
Adesso non ho voglia di cercare, quindi per ora porto solo un esempio. Sai
la mia domanda dell'altro giorno sulle desk band? Nell'esempio c'è questo:
CDeskBand  *pThis = (CDeskBand*)GetWindowLong(hWnd, GWL_USERDATA);


 vediamo il codice-2
S * s = (S*)GetWindowLongPtr(0, GWL_USERDATA);


 sviluppatori che dicevano che sizeof(long) == sizeof(void*).
Credo che bisogna distinguere tra windows attuale e quello a 64 bit del
futuro, adesso i processori a 64 bits stanno eseguendo codice a 32, e lo
sanno fare, noi tutti usiamo un compilatore che produce codice dove
sizeof(long) == sizeof(void*) == 4 ed è quello che win32 si aspetta - non mi
meraviglia che le librerie della MS lo diano per scontato. Quella pagina di
convenzioni che ti ho postato serve ad evitare errori quando si ricompilerà
lo stesso codice per win64, ma allora dovremo fare il port di tutto il ng su
"it.programmare.win64" ;-)

 S * s = (S*)GetWindowLongPtr(0, GWL_USERDATA);
stesso warning?


 Nell'esempio c'è questo: 
[...]
ma soprattutto questo:
"[...]
Copyright 1997 Microsoft Corporation. [...]"
E comunque, se sai che è sbagliato che problema c'è? mica devono essere 
vere entrambe le affermazioni solo perchè provengono dalla stessa fonte



La novità sono le dimensioni dei puntatori che adesso possono essere a 64
bits e gli  int saranno a 64 bits.
Problemi grossi ci sono con gli allineamenti delle strutture, che dovranno
essere sulla quadrupla word.
I tipi precedenti ovviamente hanno lo stesso significato, ma non
allineamento..

 vere entrambe le affermazioni solo perchč provengono dalla stessa fonte
Ma il problema č che all'inizio non lo sapevo :-)


maggior parte dei dati sta benissimo a 32 bit.
E questo chi te l'ha detto ? non è affatto vero, in generale.  
Dipende.  Su una macchina a 64 bit, un long può essere benissimo lungo
64 bit.  Addirittura, TUTTI i tipi interi (compresi i char) potrebbero
essere lunghi 64 bit.

significato che avevano
E cioč QUALE, di grazia ?
Gli standard dei linguaggi C e C++ non fanno ALCUNA assunzione sulla
lunghezza dei tipi base.  L'unica convenzione valida č che
sizeof(char) = 1 su tutte le piattaforme (e che vuol dire, tra
l'altro, che un "char" occuperŕ SEMPRE e COMUNQUE 1 solo byte, fosse
lungo anche 256 bit) e che sizeof(long) >= sizeof(int) >=
sizeof(short).  A quanto, poi, corrispondano questi tipi in bit č
lasciato alla piattaforma.  Ribadisco che su una macchina a X bit,
TUTTI i tipi potrebbero benissimo essere lunghi X bit, senza violare
alcuna regola.

 alcuna regola.
Questo e` verissimo, ad esempio io lavoro spesso su DSP in cui
sizeof(char)=1 e sizeof(int)=1, e in entrambi i casi si tratta di parole
a 16 bit.
-- 
Lorenzo

 Su una macchina a 64 bit,
"una"? "una" quale? perchè quasi mai è così


 E cioč QUALE, di grazia ?
quello che Intel e AT&T avevano specificato nelle rispettive ABI


Con "byte" si intende sempre un numero a otto bit, 
Non č vero.  "byte" NON sottointende *SEMPRE* otto bit.  
Il numero di bit di un byte č *normalmente* 8 bit sulle moderne
piattaforme, ma lo standard C e C++, ad esempio, definiscono il byte
come di *ALMENO* otto bit.

quello che Intel e AT&T avevano specificato nelle rispettive ABI
Che non č quello standard.  Per questo tipo di discussioni bisogna
considerare gli standard, non ciň che vale per specifiche piattaforme.

"una"? "una" quale? perchè quasi mai è così
Leggi meglio quanto scrivo e vedi sopra.  Le possibilità che UNA
macchina a 64 bit abbia tutti i tipi a 64 bit prescindono dalla tua
esperienza personale.

nella tua frase e` "parola minima indirizzabile".
In aggiunta al mio ultimo messaggio e come completamento ad esso,
aggiungo che il termine giusto č "byte".