C++ member Methode als Callback-Funktion übergeben

[JoJo (Gast)]

Hallo zusammen,

ich versuche  eine Klasse zuschreiben in der sich eine Callback Funktion 
befindet. Ich möchte sie als nicht-statischen deklariert,weil ich in der 
Callback-Funktion  die anderen member Funktion und die andern Membern 
Werte zugreifen möchte. meine Frage Ob es möglich ist, denn die meisten 
beispiele und mein Programm kriege ich zum laufen nur wenn die 
Callbackfunktion als globale Funktion definiere oder als statische 
Funktion.

Hier ist mein Code:

myclass.hpp

//void * callBackFunction(void *arg) ; //callback als globale Funktion
class myClass
{

  public:
    myClass();
    void                              flaeche();
    void                              creatTreads();
    void*                             callBackFunction(void *arg);
    //static void*  callBackFunction(void *arg);
    vtkSmartPointer                   <vtkMultiThreader> threads;
  private:
       double  breite ;
       double  laenge;
 };

myclass.cpp

myClass::myClass(){
 
   this->laenge = 0.0;
   this->breite = 0.0;
     
}

void* myClass::callBackFunction(void *arg ){
 
    // explicitly cast to a pointer
    int id          = *((int *)arg);        // process ID
    myClass *mySelf = (myClass*) arg;
    mySelf->flaeche();

   std::cout<<"thread Function: process :prozess.id="<<id<<std::endl;
}
void myClass::flaeche(){
 
  double sr =this->laenge * this->breite;
 cout<<"flaeche():sr ="<<sr<< "lange="<<this->laenge<<"breite ="<<this->breit<<endl;

}

void myClass::creatTreads(){
 
   this->laenge =10.5;
   this->breite = 10.5;
 
  threads = vtkSmartPointer<vtkMultiThreader>::New();
   cout << "Initialization DONE" << endl;
   int thID = 0;
   thID = threads->SpawnThread((vtkThreadFunctionType)(*callBackFunction), &thID);

}
int main(int argc, char *argv[]) {
 
     myClass C;
     C.creatTreads();

Allerdings erhalte ich dann einen Fehler:

:104:57: error: invalid use of member function (did you forget the ‘()’ ?)

Wie könnte man diese Problem umgehen? Die CallBackfunktion als static 
deklarieren aber wie kann man auf den aktullen Object zugreifen oder 
gibts auch andere Lösungen?

Danke schön mal im Voraus
Jojo

[Karl H. (kbuchegg)]

Man kann das schon machen, allerdings ist das in C++ wenig hilfreich.
Du kannst den Funktionspointer nicht so machen

    void*                             callBackFunction(void *arg);

Denn der Funktionspointer soll ja nicht auf eine freistehende Funktion 
zeigen, sondern auf eine Memberfunktion. Eine Memberfunktion gehört aber 
zu einer bestimmten Klasse, daher muss in der Deklaration des 
Funtkionspointers auch der Name der Klasse auftauchen.

http://www.parashift.com/c++-faq/pointers-to-members.html


2-tens hilft dir der Funktionspointer nicht viel. Denn du brauchst ja 
auch immer ein Objekt, für das eine Funktion aufgerufen werden soll. Ein 
Funktionspointer alleine speichert diese Information aber nicht.

D.h. Member-Callbackpointer sind in C++ meistens nicht das was man will. 
Will man unbedingt mit Funktionspointern arbeiten, dann geht man 
meistens über eine freistehende Funktion (also keine Memberfunktion) und 
aus dieser Funktion heraus ruft man dann die Memberfunktion für ein 
spezifisches Objekt auf.

Oft aber ist der ganze Ansatz mit Callbackpointer schon der falsche Weg. 
Was man statt dessen macht, ist eine Basisklasse mit einer virtuellen 
Funktion, die vom Caller aufgerufen wird. Die eigentliche Callbackklasse 
leitet sich dann von dieser Klasse ab und implementiert ihrerseits dann 
diese virtuelle Funktion. Der Caller bekommt dann einen Pointer auf so 
ein Objekt und ruft mit diesem Objekt-Pointer die Funktion auf - der 
'virtual' Mechanismus sorgt dann dafür, dass die richtige Funktion 
aufgerufen wird.
Viele Problemstellungen löst man in C++ dadurch, dass man in der 
Klassenhierarchie eine Zwischenklasse einzieht, die einfach nur als 
gemeinsamer Ankerpunkt dient um dort eine virtuelle Funktion in die 
Hierarchie einzubringen, von der man dann weiter arbeiten kann.

[PittyJ (Gast)]

Ich kenne das so, dass immer eine statische Function verwendet wird.
Diese bekommt als ersten Parameter den this-Pointer mit, und kann dann 
damit die eigentliche Memberfunktion aufrufen.

class ServerThread {
    // callback entry points
    static void * ServerCB(void *pthis, void *p_Data) ;
    void* ServerCallback(ServerControllerData *p_Data);
};

//=========================================================
// statische
void * ServerThread::ServerCB(void *pthis, void *p_Data)
{
  ServerThread * pc_This;
  pc_This = (ServerThread *) pthis;

  // an die member-function weiterleiten
  return pc_This->ServerCallback((ServerControllerData *)p_Data);
} // ServerCB()

// Member Callback
void* ServerThread::ServerCallback(ServerControllerData *p_Data)
{
}

[JoJo (Gast)]

PittyJ schrieb:

>   // an die member-function weiterleiten
>   return pc_This->ServerCallback((ServerControllerData *)p_Data);
> } // ServerCB()
>
> // Member Callback
> void* ServerThread::ServerCallback(ServerControllerData *p_Data)
> {
> }
Hallo  Pitty,
Danke Sehr für dein Tipps,
wo ist ServerControllerData deklariert ?

[Fux (Gast)]

JoJo schrieb:
> Danke Sehr für dein Tipps,
> wo ist ServerControllerData deklariert ?

Das ist doch nur ein beliebiger Parameter als Beispiel.

[Klemens W. (klemens)]

Hallo!

Schau dir mal boost.bind & boost.function an:
http://www.boost.org/doc/libs/1_54_0/libs/bind/bind.html#with_boost_function

lg

[Ronny S. (duselbaer)]

Callbacks auf Member-Funktionen sind an sich kein Problem. Dazu kannst 
Du Dir std::mem_fn und boost::function anschauen.

- http://en.cppreference.com/w/cpp/utility/functional/mem_fn
- http://www.boost.org/doc/libs/1_54_0/doc/html/function.html

Boost.Function benutze ich ab und an mal. Deine Member-Funktion hat wie 
schon beschrieben als ersten Parameter den this-Pointer auf Dein Objekt. 
Mit Boost.Bind kannst Du da schon einen Parameter anknüpfen und damit 
aus deinem Funktionspointer auf die Member-Funktion und einem 
this-Pointer einen zu Deinem Callback-Typen kompatiblen Funktionspointer 
machen.

Jetzt musst Du "nur" noch darauf achten, dass dein Objekt am Leben 
bleibt, so lange wie der FUnktionspointer benutzt werden könnte. Das 
kann man bspw. mit smart-Pointern lösen, die man statt this bindet.

Die Möglichkeiten sind interessant und vielfältig - kann aber auch jede 
Menge kaputtgehen dabei und die Fehlermeldungen des Compilers passen 
meisst nicht auf eine DIN-A4 Seite - auch, wenn nur ein Zeichen falsch 
ist :)

Rooney

[JoJo (Gast)]

Hallo Buchegger,

Danke sehr für deine Tipps, ich habe deine erste vorschlag eben probiert 
und

Karl Heinz Buchegger schrieb:
> 2-tens hilft dir der Funktionspointer nicht viel. Denn du brauchst ja
> auch immer ein Objekt, für das eine Funktion aufgerufen werden soll. Ein
> Funktionspointer alleine speichert diese Information aber nicht.
>
> D.h. Member-Callbackpointer sind in C++ meistens nicht das was man will.
> Will man unbedingt mit Funktionspointern arbeiten, dann geht man
> meistens über eine freistehende Funktion (also keine Memberfunktion) und
> aus dieser Funktion heraus ruft man dann die Memberfunktion für ein
> spezifisches Objekt auf.

und es läuft ohne Problem:

void callBackFunctionHelper(void *arg);
class myClass
{

  public:

    myClass();
    void          flaeche();
    vtkSmartPointer<vtkMultiThreader> threads;
    void          creatTreads();
    void         callBackFunction(void *arg);
    private:
       double  breite ;
       double  laenge;
    
  
};

myClass::myClass(){
 
   this->laenge = 0.0;
   this->breite = 0.0;
   cout<<"Konstruktur:"<<endl;   
}

void myClass::callBackFunction(void *arg ){

     int id          = *((int *)arg);        // process ID
     this->flaeche();

   // boost::bind(&myClass::flaeche, &mySelf);
    
    std::cout<<"thread Function: process : gl ="<<gl<<"prozess.id="<<id<<std::endl;
  
}
void myClass::flaeche(){
 
  double sr =this->laenge * this->breite;
    
  cout<<"flaeche():sr ="<<sr<< "lange="<<this->laenge<<"breite ="<<this->breite<<endl;

}

void myClass::creatTreads(){
  
 //  this->laenge =10.5;
  // this->breite = 10.5;
   
   vtkSmartPointer<vtkMultiThreader> threads =  vtkSmartPointer<vtkMultiThreader>::New();
   cout << "Initialization DONE" << endl;
   int thID = 0;
   thID = threads->SpawnThread((vtkThreadFunctionType)(callBackFunctionHelper),&thID);
  sleep(1);
 

}
 
myClass C;
void callBackFunctionHelper(void *arg){  // standalone Funktion 

      C.callBackFunction(arg);  
}

aber wie du schön erwähnt hast,ist schlechte variante, da der Instanz 
global sein muss.ich bin dabei zweite variante zu probieren

[old man (Gast)]

Ich empfehle dir anzusehen was z.B. die mbed-Leute gemacht haben. Da 
gibts eine Klasse FunktionPointer. Da kann sowohl eine statisch Funtion 
als auch eine Memberfunktion einer Klasse die nicht! statisch ist als 
Handler gesetzt werden. Der Code ist mittlerweile OpenSource:

http://mbed.org/users/mbed_official/code/mbed-src/file/4263a77256ae/api/FunctionPointer.h
http://mbed.org/users/mbed_official/code/mbed-src/file/4263a77256ae/common/FunctionPointer.cpp

[Karl H. (kbuchegg)]

JoJo schrieb:

> aber wie du schön erwähnt hast,ist schlechte variante, da der Instanz
> global sein muss.

'muss' nicht.
Schau dir mal das von PittyJ weiter oben gepostete Beispiel an. Da wird 
der Pointer zum Objekt ebenfalls gespeichert und der Funktion übergeben. 
Sinnvollerweise wird man rund um das Gespann 
Objektpointer/Funktionspointer eine Klasse legen und diesem 
Spezialpointer den Aufruf überlassen. ....

> .ich bin dabei zweite variante zu probieren

... womit man dann mehr oder weniger genau hier landet.

Edit: Und 'old man' zeigt dann auch, wies geht.

[Dr. Sommer (Gast)]

Seit C++11 brauchts keine externen Libraries mehr für sowas:

#include <functional>
#include <iostream>

class X {
  public:
    X (int y) : m_y (y) {}
    void fun (int x) {
      std::cout << m_y << " " << x << std::endl;
    }
    
    int m_y;
};

int main () {
  X x (7);
  // Alternative 1
  std::function<void(int)> memPtr1 = std::bind(&X::fun, x, std::placeholders::_1);
  // Alternative 2
  std::function<void(int)> memPtr2 = [&](int a) { x.fun (a); };
  
  memPtr1 (3);
  memPtr1 (2);
}