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.

@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)));
}

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.