Funktionspointer einer Funktion in einem Objekt

Basingstoke

Wie der Titel schon sagt suche ich eine Möglichkeit einen
Funktionspointer einer Funktions zu bekommen die sich in
einem Objekt befindet oder kennt jemand noch ne andere möglichkeit
boost::thread zu befüttern!

Simon2

Hi,

was Du suchst, klingt nach "pointer to member function" ... vielleicht findest Du da etwas Passendes drunter (mit boost kann ich Dir leider auch nicht weiterhelfen - weiß nicht, ob die das überhaupt unterstützen).

Gruß,

Simon2.

hustbaer

Wenn dann würde ich nach "member function pointer" suchen.

@Basingstoke: nimm doch einfach boost::bind, nicht?

z.B.:

class foo
{
public:
    void bar();
};

void baz()
{
    boost::shared_ptr<foo> f(new foo);
    boost::shared_ptr<boost::thread> t(new boost::thread(boost::bind(&foo::bar, f)));
}

Basingstoke

ja...ok, aber dann müssen die Funktionen doch static sein nich?
also gibt Standard-mäßig keine möglichkeit einen Funktionspointer
einem Objekt zu entlocken ohne das die Funktion static ist?!Hm, ich
war bis jetzt echt überzeugt von C++ aber so langsam vermisse nen
par Sachen!z.B.:Interfaces wie sie in PHP und C# verfügbar sind bekommt
man ja noch einigermaßen mit abstrakten Klassen hin aber das mit den
Funktionspointern macht mich doch schon etwas stutzig...

Simon2

Basingstoke schrieb:

ja...ok, aber dann müssen die Funktionen doch static sein nich?
also gibt Standard-mäßig keine möglichkeit einen Funktionspointer
einem Objekt zu entlocken ohne das die Funktion static ist?!...

Doch ... aber für den Aufruf brauchst Du immer das konkrete Objekt und üblicherweise sind die Schnittstellen (z.B. der STL evtl. auch boost - weiß nicht) dafür nicht ausgelegt.

class A {
   public:
      int f(int i);
      int g(int i);
   };

   typedef int (A::*MemberFunc_A)(int);

   int memfunc_test_main(void) {
      MemberFunc_A pFunc = &A::f;

      A a1(1);
      A a2(2);
      (a1.*pFunc)(3); // a1.f(3);
      (a2.*pFunc)(3); // a2.f(3);

      pFunc = &A::g;
      (a1.*pFunc)(3); // a1.g(3);
      (a2.*pFunc)(3); // a2.g(3);

      return 0;
   }

Die Variablen (a1, a2, pFunc) kann man natürlich auch wiederum Funktionen übergeben, die dann den Aufruf übernehmen...

Wenn man eher die Objekte als die Funktion wechselt oder es nur um die Übergabe an eine Schnittstelle geht, die keine "nonstatic member function pointers" unterstützt, kann man bisweilen entsprechende Funktoren definieren (etwas übersichtichere Syntax):

// vorgebene API:
   template <typename FuncT>
   int callMeWithInt(FuncT t, int i) { return t(i); }

// selbstgebastelte Funktoren
   struct A_f_Caller {
      A& a;
      A_f_Caller(A& ref) : a(ref) {}
      int operator()(int i) { return a.f(i); }
   };

   struct A_g_Caller {
      A& a;
      A_g_Caller(A& ref) : a(ref) {}
      int operator()(int i) { return a.g(i); }
   };

// so aufgerufen   
   int main(void) {
      A_f_Caller functor_f(a1);
      callMeWithInt(functor_f, 3);

      A_g_Caller functor_g(a2);
      callMeWithInt(functor_g, 3);

      // oder kürzer:
      callMeWithInt(A_f_Caller(a1), 3);
      callMeWithInt(A_g_Caller(a2), 3);

      return 0;
   }

Gruß,

Simon2.