Newsgroup: it.comp.programmare.win32
Titolo: Funzione di callback passata come DWORD?

Questo č il prototipo della waveOutOpen:
MMRESULT waveOutOpen(
  LPHWAVEOUT phwo,           
  UINT uDeviceID,            
  LPWAVEFORMATEX pwfx,       
  DWORD dwCallback,          
  DWORD dwCallbackInstance,  
  DWORD fdwOpen              
);
E questa č la descrizione del 4° parametro:
dwCallback
Pointer to a fixed callback function [per completezza, la descrizione
continua cosě: "..., an event handle, a handle to a window, or the
identifier of a thread to be called during waveform-audio playback to
process messages related to the progress of the playback. If no
callback function is required, this value can be zero. For more
information on the callback function, see waveOutProc."]
La domanda č semplice: come faccio ad infilare in un DWORD un
puntatore a funzione?
Grazie,
Francesco Napolitano

 puntatore a funzione?
Un puntatore E' una DWORD.
Un puntatore è lungo 32 bit e quindi è una DOUBLE WORD dove una WORD è un
doppio BYTE (insomma 4 BYTE).
Prova a usare un casting: ((DWORD)MyOpenProc)
Kiuhnm

 puntatore a funzione?
Con il cast.  Se la funzione e' "pippo" gli passi (DWORD)pippo.
Bada che, contrariamente a quanto ti e' stato detto, i puntatori NON
SONO DWORD, ma sono, appunto, puntatori, nel senso che conservano un
valore e un tipo associato a quel valore.  Le operazioni aritmetiche,
ad esempio, sui puntatori non sono equivalenti alle operazioni
aritmetiche compiute sui loro valori "castati".

 Kiuhnm
Nota che, contrariamente a quanto ti è stato detto in seguito, i puntatori
sono DWORD ovvero valori a 32 bit.
Kiuhnm

, 
walkie...@libero.it
 says...

Un puntatore è un tipo concettualmente (e sintatticamente) diverso da un DWORD, 
ma entra effettivamente in 4 byte. Il problema, come ho scritto prima, rimane 
=/.
Francesco Napolitano

, 
kiu...@softhome.net
 says...

Sì, lo so. Ma anche un char e uno short in genere sono un byte, il problema è 
che il compilatore non ti consente di confonderli. Oltretutto, mentre esiste 
una conversione tra int e char, non ne esiste una tra puntatori e DWORD: 
insomma il casting ce lo metto, ma il compilatore se ne frega abbastanza=).
Francesco Napolitano

 insomma il casting ce lo metto, ma il compilatore se ne frega abbastanza=).
non capisco dove sia il tuo problema :)
voglio dire, se hai una funzione che si trova all'indirizzo 0xAABBCCDD, 
qual e' il problmea di avere una variabile: 
DWORD myFunction = 0xAABBCCDD;
DWORD o puntatori...sono sempre 32 bit...
:)
...posso invece capire, ovviamente, lo "sconcerto" se tu volessi 
"castare" l'indirizzo di una funzione (32 bit) su un char (8 bit)... :)

 wrote in message
news:M5F29.178665$vm5.5...@news2.tin.it...

Prova a usare un multi-puntatore :-)))
typedef union
{
    BYTE *b;
    WORD *w;
    DWORD *d;
    void *v;
    DWORD dd;
} mptr;
mptr ptr;
ptr.v = MyProc;
(...., ptr.dd, ......)
Kiuhnm

 (...., ptr.dd, ......)
Forte questa!! :)

 sono DWORD ovvero valori a 32 bit.
Kiuhnm fa un favore a tutti quanti e piantala di dire cazzate:
I puntatori NON SONO DWORD, ne' e' detto che il loro valore sia a 32
bit ma il loro valore e' CASTABILE (sotto Windows) per rientrare in
una DWORD.  Questi concetti sono MOLTO diversi tra loro, evita di
fuorviare chi sta cercando soluzioni ai propri problemi.  La somma tra
due valori PUNTATORI tiene in conto anche della dimensione del valore
PUNTATO.  Un puntatore e' un puntatore, NON UNA DWORD, ovvero un
indirizzo a un oggetto DI UN CERTO TIPO.
Ribadisco: piantala di dire cazzate.

 DWORD, ma entra effettivamente in 4 byte. 
Cio' che tenevo a sottolinearti e' che un puntatore NON e' una DWORD.
Che il suo valore, su determinati sistemi, sia "castabile" in 4 byte,
e' un altro discorso.  Non e' affatto detto, tra l'altro, che, in
generale, gli indirizzi siano lunghi 4 byte (e quindi una DWORD).
A chi ha fatto quella affermazione, e' stato fatto notare sovente sui
diversi ng in cui (purtroppo) gira che spara un bel po' di cazzate
(tra l'altro gli e' sfuggita la sezione del K&R in cui e' scritto a
caratteri cubitali "I puntatori NON sono interi") ;)
La dimostrazione e' nel codice seguente:
#include <stdio.h>
typedef unsigned long DWORD;
int main()
{
    DWORD a = 3;
    DWORD *p;
    DWORD dw;
    p = &a;
    dw = (DWORD)p;
    printf("%p\n", p+3);
    printf("%08X\n", dw+3);
    return 0;
}

 wrote in message
news:bfaaa329.02080...@posting.google.com...

*plonk*
Kiuhnm

 > Un puntatore č un tipo concettualmente (e sintatticamente) diverso da un

Hai scoperto l'acqua calda!
Non voglio neanche _sporcarmi_ a risponderti. Vorrei solo ricordarti che il
prototipo era:
MMRESULT waveOutOpen(
  LPHWAVEOUT phwo,
  UINT uDeviceID,
  LPWAVEFORMATEX pwfx,
  DWORD dwCallback,
  DWORD dwCallbackInstance,
  DWORD fdwOpen
);
......ma perchč perdo tempo cosě? Ho un multitasker da finire...
*plonk*
Kiuhnm

 insomma il casting ce lo metto, ma il compilatore se ne frega abbastanza=).
Io ho scritto il seguente codice con C++Builder e funziona
perfettamente:
void CALLBACK waveOutProc(HWAVEOUT hwo,
                          UINT uMsg,
                          DWORD dwInstance,
                          DWORD dwParam1,
                          DWORD dwParam2)
{
     /* ... */
};
...
     waveOutOpen(&ph, WAVE_MAPPER, &wfe,
                 (DWORD)waveOutProc, 0, CALLBACK_FUNCTION);
Che compilatore usi ?

 ......ma perchč perdo tempo cosě? Ho un multitasker da finire...
Esatto, vai a giocare coi trenini ;)
--------------------------------
Inviato via 
http://usenet.libero.it

 DWORD o puntatori...sono sempre 32 bit...
Ecco un altro allievo del Kiuhnmismo, sei ancora in tempo per salvarti ;)


 Ecco un altro allievo del Kiuhnmismo, sei ancora in tempo per salvarti ;)
non sono allievo di nessuno :)
:) so bene che un puntatore ha tutta una sua "aritmetica" che le 
semplici DWORD non hanno, e penso anche che su una macchina a 64 bit un 
puntatore potrebbe probabilmente essere "ampio" 64 bit (quindi due 
DWORD)...
mi riferivo semplicemente al fatto che, su Win32, un puntatore *occupa* 
32 bit, e quindi puo' tranquillamente essere castato a DWORD.
tutto qui :)

puntatore a funzione?
Miseriaccia, ragazzi, penso che lo sappiamo cosa sono un puntatore e una 
dword, no? =). Sono semplicemente due cose totalmente diverse che sotto win 
occupano lo stesso spazio: punto! =) Non vi starete un po' beccando come i 
galli nel pollaio? =)
Cmq ho risolto il prob.: il cast da voi suggerito funziona. Avevo detto che 
l'avevo provato e che non funzionava, ma l'inghippo era semplice: stavo 
puntando ad una funzione membro e quindi la conversione andava a farsi 
benedire. Visto che insistevate che doveva funzionare ho insistito anch'io e 
ualà!
Certo dovevo essere proprio fuori se ho definito una callback di win32 come 
membro di una mia classe... =)
Grazie a tutti,
Francesco Napolitano

 membro di una mia classe... =)
Puoi anche farlo, l'importante e' che sia "static".