[c++] Callback

[Bloodxyz]

Salve ragazzi!
Sto uscendo pazzo con un sistema di callback e non riesco a darmi pace..

vediamo se potete aiutarmi almeno voi..

dunque sto facendo una classe e ho una pagina da includere di un SDK. Il mio progetto è in "c++", precisamente win32 console application.

Questo sdk è sviluppato anche per .net (da cui vi citerò prima l'esempio)
allora sul loro sample c'è scritto nella pagina da includere:

METODO C++ .NET
#grfinger.h

/** altro codice **/
//CALLBACK functions 
typedef void CALLBACK GRCAP_STATUS_EVENT_PROC(char* idSensor, GRCAP_STATUS_EVENTS event);

//delegate functions 
__delegate void StatusCallBack(char* idSensor, GRCAP_STATUS_EVENTS event); 

//***************************************************** // Functions - CAPTURE //***************************************************** DLLIMPORT 
GrCapInitialize(StatusCallBack* StatusEventHandler);
/** altro codice **/

file .h (classe "util")

void StatusEventHandler(char* idSensor, GRCAP_STATUS_EVENTS event);

StatusCallBack* myCallBack;

nella pagina cpp (classe "util") dentro il codice di inizializzazione della classe

//create callback myCallBack = new StatusCallBack(this,&Util::StatusEventHandler); //handle to keep callback away from garbage collector gchStatus = GCHandle::Alloc(myCallBack);
 

GrCapInitialize(myCallBack);

sempre dentro il cpp (classe "util") (fuori dall'inizializzazione ovviamente)

void Util::StatusEventHandler(char* idSensor, GRCAP_STATUS_EVENTS event) { ... }

Ok questo è il metodo .net .. adesso io devo rifarlo col c++, soltanto che l'include che forniscono col c++ è diverso dal .net. Vi posto il mio codice:

METODO C++ CONSOLE
#grfinger.h

/** altro codice **/
//CALLBACK functions
typedef void CALLBACK GRCAP_STATUS_EVENT_PROC(char* idSensor, GRCAP_STATUS_EVENTS event);

//*****************************************************
// Functions - CAPTURE
//*****************************************************
DLLIMPORT
GrCapInitialize(GRCAP_STATUS_EVENT_PROC *StatusEventHandler);
/** altro codice **/

già da qui potete vedere che non hanno messo le funzioni con __declare e che "GrCapInitialize" richiede GRCAP_STATUS_EVENT_PROC come parametro.


il mio file fingerprint.h (classe fingerprint)

static void CALLBACK StatusEventHandler(char* idSensor, GRCAP_STATUS_EVENTS event);

nel file fingerprint.cpp (classe fingerprint) (dentro l'inizializzazione)

GrCapInitialize(&StatusEventHandler);

sempre nel file fingerprint.cpp (classe fingerprint) (fuori dall'inizializzazione)

void CALLBACK fingerprint::StatusEventHandler(char* idSensor, GRCAP_STATUS_EVENTS event) { ... }

Ok.. detto questo, il tutto funziona.. soltanto che non posso interagire con membri e metodi della mia classe fingerprint perchè è come se agisse da un'altra parte.. a meno che non dichiaro "static" le cose, ed è un problema per me.. nell'esempio del .net rimane nell'ambito della classe invece.. che fò?

[linoma]

Vorrei capire ma quante volte usi la class fingerprint nella tua applicazione? Il parametro char *idSensor cosa è?

[Bloodxyz]

la richiamo una volta sola.. lascia perdere "idsensor" e "event" che se li prende in automatico dall'evento. Non è quello il punto.. è che se io richiamo un membro della classe fingerprint con static callback poi non posso richiamarne i membri.. il forum dell'sdk è inattivo e non riesco a cavarne piede.. ti faccio l'esempio:

.h

class fingerprint {

fingerprint::fingerprint();
fingerprint::~fingerprint();

static void CALLBACK StatusEventHandler(char* idSensor, GRCAP_STATUS_EVENTS event);

void WriteEvent(char* idSensor, int eventCode);

}

#include "fingerprint.h"

fingerprint::~fingerprint();

fingerprint::fingerprint() {

GrCapInitialize(&StatusEventHandler);

}

void CALLBACK fingerprint::StatusEventHandler(char* idSensor, GRCAP_STATUS_EVENTS event) {

// Signaling that a status event occurred.
WriteEvent(idSensor, event);

}

Ecco.. non posso richiamare il metodo WriteEvent() perchè dice che non è statico, funziona solo se nell'header lo imposto come statico.. ma non mi serve così.. vorrei che girasse tutto senza static..

[linoma]

Il discorso che il tuo oggetto esiste solo a runtime ecco la necessita dello static.

[Bloodxyz]

pero' nel .net non c'è bisogno di dichiararli static, fa un giro suo con i callback che non capito e come se riesce a farlo rimanere all'interno della classe util

Non fa a lasciarli così perchè non posso usare metodi e membri di fingerprint a meno che non li dichiaro static.. non c'è un modo per fare lo stesso giochetto di callback che usa nell'esempio .net?

In pratica nell'include file in più ha:

__delegate void StatusCallBack(char* idSensor, GRCAP_STATUS_EVENTS event);

e quando richiama il call back fà così:

StatusCallBack* myCallBack;
myCallBack = new StatusCallBack(this,&Util::StatusEventHandler);
GrCapInitialize(myCallBack);

void Util::StatusEventHandler(char* idSensor, GRCAP_STATUS_EVENTS event) { }

mentre io non ho quella riga nell'include e l'unico modo che ho trovato per accedere al callback è dichiarare static + callback "statuseventhandler":

static CALLBACK void StatusEventHandler(char* idSensor, GRCAP_STATUS_EVENTS event);

[linoma]

new StatusCallBack(this,&Util::StatusEventHandler);

In verita nn ricordo la creazione del delegato ma tu lo crei passando this e la funzione quindi e cm se passasi l'indirizzo dell'oggetto e l'offset della funzione, 2 puntatori se nn 3.

[Bloodxyz]

eh si ma non ho la funzione "statuscallback" io, se ricordi quel delegate è presente solo nell'include dedicato al .net

Vorrei poter rifare una cosa simile .. ecco

[linoma]

cercavo di spiegarti il motivo dello static e' perche' riconduce tutto ad un solo puntatore mentre con il metodo che vorresti, che poi dovrebbe essere simile al delegate del C#, il puntatore dovrebbe essere composto.

Girando ho trovato questo è troppo piccolo e a quest'ora nn riesco a leggerlo e questo

[shodan]

Ho dato un'occhiata alla documentazione e dire che fa schifo è un complimento.
Comunque non sei obbligato a rendere tutto static, dovrebbe bastare un puntatore.

class fingerprint {
    static fingerprint* pointer;
    
    fingerprint::fingerprint();
    fingerprint::~fingerprint();

     static void CALLBACK StatusEventHandler(char* idSensor, GRCAP_STATUS_EVENTS event);

     void WriteEvent(char* idSensor, int eventCode);

 };
 static fingerprint* pointer(0);

Ovviamente Il puntatore dovrà essere valido prima di poterlo usare.

void CALLBACK fingerprint::StatusEventHandler(char* idSensor, GRCAP_STATUS_EVENTS event) {
   if (!fingerprint::pointer) throw catastrophic_failure;
   fingerprint::pointer->WriteEvent(idSensor, evento_ricevuto);
}


fingerprint::pointer = new fingerprint;
GrCapInitialize(&fingerprint::StatusEventHandler);
delete fingerprint::pointer;

[Bloodxyz]

Guarda ci sono da maggio col c++ e sto imparando da un libro, non stai parlando con un espertone, quindi non scocciarti nel caso vedi che non son veloce a capire ^^

Io ho guardato su internet e ho letto che il corrispondente del c# delegate o __delegate in C++ è appunto CALLBACK definito in win32api come __stdcall se non erro.


Ho provato a riprodurre quel giro nel mio file creando una funzione chiamata

void CALLBACK StatusCallBack(char* idSensor, GRCAP_STATUS_EVENTS event);

ma poi se faccio tipo

StatusCallBack* myCallBack;
myCallBack = new StatusCallBack(this,&fingerprint::StatusEventHandler);
GrCapInitialize(myCallBack);

non funziona ovviamente