Ich baue mir zurzeit eine simple art Datenbank zum verwalten von Objekten. Diese will ich später als Grundlage benutzen ein oder mehrere spiele zu bauen.
In dieser Datenbank gibt es eine Objekt liste welche momentan so inetwa aussieht:

class Object
{
  public:
    void Timer(); 
    HRESULT Init(char*,unsigned int Nr,/*funktionsname*/);
  private:
    unsigned int Nr;
    char *DataName;
};

Ich möchte das jedes Objekt eine individuelle (Timer()) funktion aufrufen kann die ich vorher zb. durch Init() bestimmt habe. In dieser sollen dann dinge wie zb. später Kollision oder Positionsänderungen bearbeitet werden.

class Object
{
public:
void Timer();
Funktion F;
}

Object::Timer()
{
  RufeFunktionAuf(F,Infosübermich);
}

Diese sollte dann irgendwo außerhalb der Datenbank deklariert und implementiert werden.
Jetzt würde es mir helfen wenn ich wüsste wie man soetwas korrekt bezeichnet (Um danach zu suchen) / wie soetwas geht bzw. wie ihr das umsetzen würdet.

WinApi verwendet genau das was ich suche für die Message verarbeitung, falls meine beschreibung nicht klar ersichtlich ist führe ich das beispiel einfach mal hier auf:

INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR, INT )
    WNDCLASSEX wc;
    wc.lpfnWndProc = XYZ;
}

LRESULT CALLBACK XYZ( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);

Ansonsten findet man dazu sicher was im C++ Primer oder Thinking in C++ 1&2 (als PDF runterladbar).

Und falls du dich mit Funktoren und Template gut genug auskennst, dann sind diese zwei Bibliotheken von Boost deine dicksten Freunde
http://www.boost.org/doc/libs/1_37_0/libs/bind/bind.html
http://www.boost.org/doc/libs/1_37_0/doc/html/function.html

Grüssli

Wenn ich das richtig verstanden habe muss man für jede funktion dieser art eine eigene klasse machen. Die kann ich (vermutlich) nur als Template der Object klasse übergeben.
Jetzt ist meine frage:
Wie speichere ich den functor? Zu Variablen als Templates konnte ich keine treffenden informationen finden und das unten geschriebene, was mir am logischsten erschien, mag der Compiler nicht.

class Object
{
  public:
    unsigned int GetNr(){return Nr;}
    template<class TFunc> HRESULT Init(char*,unsigned int Nr,TFunc);
    void Timer(int);
  private:
    GameEngine *GE;
    unsigned int Nr;
    char *DataName;
    template<typename TFunc> TFunc funktion; //error: data member `funktion' cannot be a member template
};

void Object::Timer(int Time)
{
  funktion();
}

@oder:
Ich kann keinen zusammenhang zwischen dem link und meinem problem feststellen

Für die allgemeine Speicherung von Funktoren empfehle ich die bereits erwähnt Bibliothek von Boost:
http://www.boost.org/doc/libs/1_37_0/doc/html/function.html

Man kann sich sowas, relativ leicht auch selber bauen:

class BasicCallable
{
protected:
  BasicCallable() { }
  virtual ~BasicCallable() { }

public:
  virtual void call() = 0;
};

template<typename CalleeT>
class Callable : public BasicCallable
{
public:
  typedef CalleeT Callee;

private:
  Callee m_callee;

public:
  Callable(Callee callee)
    : m_callee(callee)
  { }

  ~Callable() { }

public:
  void call() { m_callee(); }
};

class Caller
{
private:
  BasicCallable* m_callable;

public:
  template<typename CallableT>
  Caller(CallableT callable)
    : m_callable(0)
  {
    m_callable = new Callable<CallableT>(callable);
  }

  ~Caller()
  {
    delete m_callable;
  }

public:
  void foo()
  {
    // ...
    m_callable->call();
    // ...
  }
};

(ungetestet)
Dies ist eine sehr billige Implementation. Boost.Function macht das wesentlich besser, berücksichtig zum Beispiel auch Rückgabewerte.

Die Lösung von "oder" ist übrigens nichts anderes, als dass du eine Schnittstelle anbietest. Eine abstrakte Klasse, von welcher man ableiten muss.

class Observer
{
public:
  virtual void call() = 0;
};

// Wer Informationen erhalten will, muss eine Klasse, welche von Observer ableitet, übergeben.

class Object
{
public:
  unsigned int GetNr(){return Nr;}
  HRESULT Init(char*,unsigned int Nr,Observer*);
  void Timer(int);
private:
  GameEngine *GE;
  unsigned int Nr;
  char *DataName;
  Observer* observer;
};

void Object::Timer(int Time)
{
  if(observer)
  { observer->call(); }
}

Grüssli