referencja do metody

Witam,
chcę napisać metodę, która jako jeden z argumentów otrzymuje referencję do metody innego obiektu. Jednak nie potrafię tego zrobić. Nie do końca rozumiem komunikaty kompilatora, a poprawianie kodu według tego co rozumiem prowadzi do nikąd. Chciałabym żeby kod wyglądał mniej więcej tak:
deklaracja metody:

 
Stick (); // ta metoda powinna otrzymać jako argument referencję do innej metody

wywołanie:

Paddle paddle;
stick = new Stick(&paddle->funkcja); // tutaj mi kompilator pisze że powinno być Paddle::funkcja

proszę o pomoc :)

Funkcje w C++ nie są obiektami pierwszej klasy i nie mogą być przekazywane jako argumenty wywołania metod. Możesz poslużyć się wskaźnikiem do funkcji. Przy czym to co tutaj napisałeś to jakiś bełkot ;]

Wskaźniki do metod w C++ są dość ograniczone, tj. jeżeli spodziewasz się czegoś w stylu delegat z C# to się zawiedziesz. Możesz przekazać adres do metody danej klasy (nie obiektu!) i dalej będziesz musiał gdzieś w środku ją wywołać na rzecz danej metody (czyli i tak potrzebujesz wskaźnik do obiektu). Czyli wydaje mi się, że w tym przypadku i tak lepiej będzie przekazać referencję / wskaźnik do całego obiektu.

Tutaj masz więcej informacji: http://www.parashift.com/c++-faq-lite/pointers-to-members.html

można coś takiego zrobić:

#include <cstdio>

class Baza
{
public:
  virtual void metoda1()=0;
  virtual void metoda2()=0;
};

class A: public Baza
{
private:
  int pole;
public:
  A(int pole): pole(pole) {}
  void metoda1()
    {
      printf("metoda1 klasy A (pole=%d)\n",pole);
    }
  void metoda2()
    {
      printf("metoda2 klasy A (pole=%d)\n",pole);
    }
};

class B: public Baza
{
private:
  int pole;
public:
  B(int pole): pole(pole) {}
  void metoda1()
    {
      printf("metoda1 klasy B (pole=%d)\n",pole);
    }
  void metoda2()
    {
      printf("metoda2 klasy B (pole=%d)\n",pole);
    }
};


class Wywolywacz
{
private:
  Baza* obiekt;
  void (Baza::* metoda)();
public:
  Wywolywacz(Baza* obiekt, void (Baza::* metoda)()): obiekt(obiekt), metoda(metoda) {}
  void operator()()
    {
      (obiekt->*metoda)();
    }
};

int main()
{
  A a1(1), a2(2);
  B b1(3), b2(4);
  Wywolywacz w1(&a1,&Baza::metoda1),
             w2(&a2,&Baza::metoda1),
             w3(&b1,&Baza::metoda1),
             w4(&b2,&Baza::metoda1),
             w5(&a1,&Baza::metoda2),
             w6(&a2,&Baza::metoda2),
             w7(&b1,&Baza::metoda2),
             w8(&b2,&Baza::metoda2);
  w1();
  w2();
  w3();
  w4();
  w5();
  w6();
  w7();
  w8();
  return 0;
}

Można po prostu użyć tego, co już jest w C++:

#include <functional>
// ... 
typedef std::function<void()> FunPtr;
// ...
FunPtr w1 = std::bind(&Baza::metoda1, &a1);
w1();
// itd...

Implementacja tego co już zostało powiedziane:

struct Paddle {
	void MetodaPaddle() { /* ... */ }
};

struct Stick {
	Stick(Paddle *obiekt, void (Paddle::*metoda)())
	{
		/* przykładowe wywołanie metody 'metoda' na obiekcie 'obiekt' */
		(obiekt->*metoda)();
	}
}; 

Paddle paddle;
stick = new Stick(&paddle, &Paddle::MetodaPaddle);

dzięki za pomoc :)