kann mir jemand sagen, warum der Aufruf eines Functors so klappt:

#define output(c) std::cout<<c;
#define outputLine(c) std::cout<<c<<"\r\n";

class TFunctor
{
public:
  virtual void operator()()=0;
  virtual void Call()=0;
};

template <class TClass> class TGameFunctor : public TFunctor
{
private:
  void (TClass::*fpt)();
  TClass* pt2Object;

public:
  TGameFunctor(TClass* _pt2Object, void(TClass::*_fpt)()) { pt2Object = _pt2Object;  fpt=_fpt; };
  virtual void operator()() { (*pt2Object.*fpt)();};
  virtual void Call() { (*pt2Object.*fpt)();};
};

struct MenuPoint
{
	float x1, y1, x2, y2;
	char * name;
	char * text;
	TFunctor * MethodPointer;

	MenuPoint(float _x1, float _y1, float _x2, float _y2, char * _name, char * _text, TFunctor * _MethodPointer)
	{
		x1 = _x1; y1 = _y1; x2 = _x2; y2 = _y2;
		name = _name;
		text = _text;
		MethodPointer = _MethodPointer;
	}

	MenuPoint()
	{
	}
};

class Menue
{
public:
	void AddMenuPoint(MenuPoint * newMenuPoint)
	{
		output("Aufruf ueber AddMenuPoint(): ");
		pMenuPoint = newMenuPoint;
		(*pMenuPoint->MethodPointer)();
	}

	void TestMenueIntersection()
	{
		output("Aufruf ueber TestMenueIntersection(): ");
		(*pMenuPoint->MethodPointer)();
	}

	MenuPoint * pMenuPoint;
};

class Game
{
public:
	void NewGame()
	{
		std::cout<<"Neues Spiel wird gestartet!\r\n";
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	Menue * pMenue = new Menue();
	Game * pGame = new Game();

	pMenue->AddMenuPoint(&MenuPoint(0, 0, 100, 20, "Testname", "Testtext", &TGameFunctor<Game>(pGame, &Game::NewGame)));
	pMenue->TestMenueIntersection();

	system("PAUSE");
}

nicht aber, wenn ich das Ganze über eine weitere Klasse laufen lasse, die pMenue und pGame initialisiert?

Abhilfe würde ein Smartpointer des TFunctor schaffen, der als Kopie abgelegt wird. Das Functor-Objekt muss dann aber mit new angelegt werden. Alternativ kannst Du Dir eine eigene Functor-Verwaltungsklasse schreiben, die dann auch als Kopie herumgereicht wird. Das hätte zudem den Vorteil, dass Du eventuelle weitere Nachfahren von TFunctor durch Hinzufügen eines weiteren Konstruktors auch mit dieser Klasse erschlagen könntest.

/* Annahme: TFunctor heißt TFunctorImpl und TGameFunctor heißt TGameFunctorImpl */
class TFunctor
{
    template<class TClass>
    TFunctor(TClass* _pt2Object, void(TClass::*_fpt)())
        : m_functor(new TGameFunctorImpl(_ptObject, _fpt)) {}
    ~TFunctor() { delete m_functor; }

    void operator()() { m_functor->Call(); }
    void Call() { m_functor->Call(); }
private:
    TFunctorImpl* m_functor;
};