CPP Std::Bind

[ISP-Takt (Gast)]

Hi,

ich habe ein wenig mit der C++ Programmierung angefangen und stehe im 
Moment vor einem kleinen Problem. Ich möchte gerne Methoden einer Klasse 
dynamisch aufrufen. Normalerweise würde ich das über ein Array von 
Funktionpointern machen.
Nun ist es scheinbar nicht möglich Funktionspointer auf Methoden einer 
Klasse zu erstellen (oder es ist nicht schön). Über std::tr1::bind ist 
es jedoch möglich Methoden dynamisch aufzurufen. Ein Aufruf sieht in 
etwa so aus:

std::tr1::function <void(int)> callback;
callback = 
std::tr1::bind(&MyClass::myMethod,this,std::tr1::placeholders::_1);

Da ich das ganze recht einfach gestellten möchte, hätte ich gerne eine
Methode die nur die Argumente (&MyClass::myMethod) aufnimmt und das 
binding
innerhalb der Methode geschieht.

Ist das möglich, bzw. welchen Typ muss das Argument einer solchen 
Methode
haben oder gibt es andere Möglichkeiten ein solches Vorhaben zu 
realisieren.

Es tut mir weiterhin leid wenn ich mich falsch ausgedrückt habe was die 
Begrifflichkeiten zu C++ angehen, wie gesagt stehe ich noch am Anfang.

Grüße
ISP-Takt

[Klaus W. (mfgkw)]

ISP-Takt schrieb:
> Nun ist es scheinbar nicht möglich Funktionspointer auf Methoden einer
> Klasse zu erstellen (oder es ist nicht schön).

Warum soll das nicht gehen?

Was hast du denn genau vor? Wofür callback?

[Rolf M. (rmagnus)]

ISP-Takt schrieb:
> Nun ist es scheinbar nicht möglich Funktionspointer auf Methoden einer
> Klasse zu erstellen (oder es ist nicht schön).

Möglich ist das schon. Es funktioniert allerdings etwas anders, als bei 
normalen Funktionen. Was verstehst du unter "nicht schön"?
So macht man es:

#include <iostream>
class Klasse
{
public:
    void myfunc(int arg)
    {
        std::cout << "Hello, world, the answer is " << arg << "!\n";
     }

};

int main()
{
    void (Klasse::*func)(int)  = &Klasse::myfunc;

    Klasse k;
    (k.*func)(42);
}

> Über std::tr1::bind ist es jedoch möglich Methoden dynamisch aufzurufen. Ein
> Aufruf sieht in  etwa so aus:
>
> std::tr1::function <void(int)> callback;
> callback =
> std::tr1::bind(&MyClass::myMethod,this,std::tr1::placeholders::_1);

Und das findest du schön?

> Da ich das ganze recht einfach gestellten möchte, hätte ich gerne eine
> Methode die nur die Argumente (&MyClass::myMethod) aufnimmt und das
> binding innerhalb der Methode geschieht.

Naja, der Zweck von std::tr1::bind ist ja gerade, es vorher zu binden. 
Nur dafür ist es da.

> Es tut mir weiterhin leid wenn ich mich falsch ausgedrückt habe was die
> Begrifflichkeiten zu C++ angehen, wie gesagt stehe ich noch am Anfang.

Das ist kein Problem, aber es ist unklar, wozu du das überhaupt 
brauchst. Normalerweise benötigt man das äußerst selten. Ich hab bisher 
nur einmal gedacht, daß ich es brauche, hab's aber dann doch anders 
gelöst. Deshalb ist es ungewöhnlich, wenn du das als Anfänger schon 
gleich benötigst.

[ISP-Takt (Gast)]

Hallo,

danke für die Antwort ich habe noch mal ein Beispiel an dem es vill. 
deutlich wird. Ohne die auskommentierte Zeile kann man es normal mit 
compelierten. Mit gibt es den Fehler:

"ISO-C++ verbietet das Ermitteln der Adresse einer nicht qualifizierten 
oder geklammerten nicht-statischen Elementfunktion, um einen Zeiger auf 
Elementfunktion zu erzeugen."

Die UnknownClass schreibe ich nicht selber von da her kenne ich die 
Methoden nicht. Diese sollen dann trotzdem über einen Index oder etwas 
Ähnliches aufgerufen werden können. Daher der Unterbau über die 
BaseClass.

#include <iostream>
#include <sstream>
#include <cstring>
#include <stdlib.h>

using namespace std;

class BaseClass {
  public:

    BaseClass() {
      _anyEvent = NULL;
    }

    ~BaseClass() {}

    // Funktionspointer hinzufügen
    void add(void (*inp)(int anyInt)) {
      _anyEvent = inp;
    }
    
    void start(void) {
      // Funktion aufrufen
      _anyEvent(5);
    }

  private:
    // Funktionspointer
    void (*_anyEvent)(int anyInt);
};


class UnknownClass : public BaseClass {
  public:

    UnknownClass() : BaseClass() {
      _a = 0;
      // Das funktioniert nicht
//      add(&makeA);
    }

    void makeA(int inp) {
      _a = inp;
    }    
    
    void makeB(int inp) {
      _a = inp;
    }    

  private:
    int _a;
};

  
int main()
{
  UnknownClass tmp = *new UnknownClass();
  // Hier soll makeA gestartet werden
  tmp.start();
    
}

[Klaus W. (mfgkw)]

Möchtest du einen Zeiger
a) auf eine Methode (zu einem Element zugehörig), oder
b) zu einer von einem Element unabhängigen Funktion (globale Funktion 
oder statische Methode)?

Das sind zwei grundverschiedene Dinge.

[ISP-Takt (Gast)]

Hallo,

ich möchte einen Zeiger der auf eine Methode innerhalb einer Klasse 
zeigt und es ermöglicht diese Methode innerhalb diese Klasse bzw. der 
Instanz über den Funktionspointer aufzurufen.
Von da her Möglichkeit 1.

Grüße ISP-Takt

[Rolf M. (rmagnus)]

Warum nutzt du nicht Polymorphie, also machst eine Basisklasse mit einer 
virtuellen Memberfunktion und leitest für makeA und makeB jeweils eine 
Klasse ab? Das ist der von C++ vorgesehene Weg, sowas zu tun.

[Klaus W. (mfgkw)]

ISP-Takt schrieb:
> ich möchte einen Zeiger der auf eine Methode innerhalb einer Klasse
> zeigt und es ermöglicht diese Methode innerhalb diese Klasse bzw. der
> Instanz über den Funktionspointer aufzurufen.

Wie aufrufen? Für ein Objekt der Klasse oder nicht?
Genau das ist der springende Punkt.

Rolf Magnus schrieb:
> Polymorphie

wahrscheinlich der bessere Weg, ja.
Man kann Polymorphie aber auch von Hand bauen, wenn man will :-)

Aber vielleicht will er aus irgendwelchen Gründen das nicht an die 
Klasse kleben, sondern zur Laufzeit wild wechseln.
Schwer zu sagen...

PS: bin ja blind. Möglichkeit a entfällt, weil du in makeA() ja auf ein 
Element der Klasse zugreifst.
Also brauchst du einen Zeiger auf eine Methode -> wie oben von Rolf 
Magnus beschrieben
Beitrag "Re: CPP Std::Bind"

[Klaus W. (mfgkw)]

Dein Beispiel von oben kann man zum Laufen vergewaltigen, wenn man es so 
umbaut (ohne den Anspruch, halbwegs elegant zu sein - nur der Form 
halber):

#include <iostream>
#include <sstream>
#include <cstring>
#include <stdlib.h>

using namespace std;

class BaseClass {
public:

  BaseClass()
  {
    _anyEvent = NULL;
  }

  ~BaseClass() {}

  // Funktionspointer hinzufuegen
  void add(void (BaseClass::*inp)(int anyInt))
  {
    _anyEvent = inp;
  }

  void start(void) {
    // Funktion aufrufen
    (this->*_anyEvent)(5);
  }

  virtual void out( std::ostream &os ) const
  {
    os << "((BaseClass) _anyEvent=" << (void*)_anyEvent << ")";
  }

private:
  // Funktionspointer
  void (BaseClass::*_anyEvent)(int anyInt);
};


class UnknownClass : public BaseClass
{
public:

  UnknownClass() : BaseClass()
  {
    _a = 0;
    // Das funktioniert, wenn auch unelegant
    add((void (BaseClass::*)(int))&UnknownClass::makeA);
  }

  void makeA(int inp)
  {
    std::cout << "makeA()" << std::endl;
    _a = inp;
  }

  void makeB(int inp)
  {
    std::cout << "makeB()" << std::endl;
    _a = inp;
  }

  virtual void out( std::ostream &os ) const
  {
    os << "((UnknownClass)";
    BaseClass::out( os );
    os << ",_a=" << _a << ")";
  }

private:
  int _a;
};

std::ostream &operator<<( std::ostream &os, const BaseClass &b )
{
  b.out( os );
  return os;
}

int main()
{
  UnknownClass tmp = *new UnknownClass();
  std::cout << "tmp ist " << tmp << std::endl;
  // Hier soll makeA gestartet werden
  tmp.start();
  std::cout << "tmp ist " << tmp << std::endl;
}

Ausgabe:

tmp ist ((UnknownClass)((BaseClass) _anyEvent=0x8048b38),_a=0)
makeA()
tmp ist ((UnknownClass)((BaseClass) _anyEvent=0x8048b38),_a=5)