Newsgroup: it.comp.programmare.win32
Titolo: Il meccanismo delle callback!

 detto che io debba fare il fiorista....  [Morgan]  <
Visitate il mio sito:
http://digilander.iol.it/Superpork

meccanismo delle callback?
Sono funzioni richiamate da Windows, in corrispondenza di determinati
eventi. Vedi le funzioni chiamate da EnumWindows, EnumProcesses,
ecc...

 ecc...
beh, un attimo, da windows... ho usato funzioni di callback quando
Microsoft e Digital Research vendevano ancora il DOS... ;o)
l'idea fondamentale e'che si puo passare ad una funzione un puntatore ad un
altra funzione ne piu ne meno come si passano le variabili. Supponiamo di
voler scrivere una funzione "Integrale" che calcoli l'integrale di un altra
funzione double F(double) da x1 a x2 con il metodo dei rettangoli di
ampiezza d. Alla funzione Integrale devono essere passati quattro
parametri: i due punti x0 e x1, l'intervallo d e la funzione F su cui
calcolare l'integrale.
Integrale sara' quindi dichiarata e implementata come:
double Integrale(double F(double),double x0,double x1, double d)
{
double sum=0;
for (int x=x0;x<x1;x+=d)
  sum+=F(x)*d;
return sum;
}
// l'implementazione fa schifo, se  x0>x1 bisogna scambiarli e cambiare il
segno al risultato
// inoltre si fanno una valanga di moltiplicazioni (double) per d quando
basterebbe un contatore n
// e moltiplicare alla fine tutto per n*d, ma per chiarezza...
 
double F(double) e' l'indirizzo di una generica funzione che accetta come
parametro un double e ritorna un double, quindi ad un certo punto del
programma e' lecito scrivere:
#include <math.h> // per sin e log
...
double I;
I=Integrale( &sin , 0.0 , M_PI_2 , 0.01);//calcola l'integrale della
funzione seno tra 0 e pigreco/2 con passo 0.01
...
I=Integrale( &log , 10.0 , 14.7 , 0.001);//calcola l'integrale della
funzione logaritmo tra 10.0 e 14.7 con passo 0.001
...
quando si manda a Integrale &sin si manda l'indirizzo della funzione double
sin(double), quindi quando Integrale chiama F(x) in effetti chiama sin(x)
questo meccanismo viene inoltre utilizzato affinche' l'utente possa in
qualche modo "essere avvertito" quando viene eseguito del codice di
libreria. Prendiamo ad esempio la funzione lineInitialize delle TAPI:
questa funzione (inizializzazione della linea telefonica) vuole come
parametro l'indirizzo una funzione di "callback". Tale funzione, definita
dall' utente, viene eseguita dal sistema ogni volta che succede qualcosa
sulla linea telefonica. Si potrebbe scrivere la propria funzione di
callback come:
void lineCallbackFunc
  (
  DWORD hDevice,	
  DWORD dwMsg,	
  DWORD dwCallbackInstance,	
  DWORD dwParam1,	 
  DWORD dwParam2,	
  DWORD dwParam3	
 )
{
if((dwMsg==LINE_CALLSTATE)&&(dwParam1==LINECALLSTATE_BUSY))
  {
  //codice da eseguire se linea occupata	
  }
}

Microsoft e Digital Research vendevano ancora il DOS... ;o)
Si, ma siamo in it.comp.programmare.win32 e se si parla di "meccanismo
delle callback" penso lo si intenda in questo ambiente.
Che l'idea del "callback" sia universale lo sappiamo, penso, tutti
quanti.
--
Andrea Laforgia (
andrea_...@bigfoot.com
)
-----------------------------------------------------
"There is nothing better for understanding a kangaroo
 than seeing it jump." [D.Grune, C.J.H. Jacobs]
-----------------------------------------------------

 quanti.
io non sarei cosi' ottimista, dato che la domanda, rivolta ad un  ng win32
era:
"qualcuno ha voglia di spiegarmi con poche parole in cosa consiste il
meccanismo delle callback?"
da come era stata espressa la domanda ho pensato che si trattasse di un OT 
in buona fede e che la tua risposta lo avesse ancora piu confuso, forse
(invece di scrivere tutta quella spatafiata, peraltro non inerente ad un ng
win32) avrei dovuto dirglielo e rimandarlo a it.comp.lang.c
ciao
Ermando

 for in ambiente windows"
Diciamo che avete ragione entrambi. Il concetto di callback e'
piuttosto generico e non necessariamente legato ad un linguaggio.
Infatti e' possible estenderlo a un gran numero di casi le cui
implementazioni sono totalmente differenti. Si applica dagli
algoritmi di ordinamento all'accesso ai dati di array e database
o in tutte quelle procedure che richiedono il passaggio di puntatori
di funzione (la callback) per adattare la chiamata ad uno specifico
utilizzo o a metodi di interfaccia tra classi (es. callback di
funzioni virtuali in C++). In Win32 e' spesso associato al signal
handling, messaggi tra processi o operazioni di I/0 di tipo asincrono.
Per esempio se si  approfondisce l'analisi di strutture come i componenti
remoti o piu' precisamente dei DCOM e il loro macchinoso event handling
puo' esser utile conoscere come aggirare il problema implementando delle
early binding callback. Questo e' un concetto ben noto ai programmatori
VB che intendano creare applicazioni Client/Server ActiveX o in tutti
quei casi in cui vi sia la necessita' di gestire eventi di molti oggetti
in una relazione uno-molti.
Come vedi si puo' spaziare dallo specifico al generico.
Ciao.
Il Michett@
--

for in ambiente windows"
Per cortesia, non ci fossilizziamo sulle parole e non la facciamo
tanto lunga. Ripeto che sotto windows esiste un modo preciso di usare
le callback (vedi le funzioni del tipo Enum* o la stessa window
procedure dei controlli), per cui non e' sbagliato parlare delle
tecniche usato in QUESTO ambiente. 
--
Andrea Laforgia (
andrea_...@bigfoot.com
)
-----------------------------------------------
Dovro' prendere lezioni di Internet, 
se non sai di Internet non ti considera nessuno 
(Carmen di Pietro) 
-----------------------------------------------