Ich hab ne ganz dringende Frage, ich raffs einfach nich wieso das nicht geht.
Also ich hab ne Klasse A dessen Deklaration sich in einer Headerdatei .h
und Implementierung in der zugehörigen Sourcedatei .cpp befindet.

So sieht die Deklaration in der .h Datei aus :

class A
{ 
  public :

  void (*Methode)(float);

  static void methode1(float p1);
         void methode2(float p1);
};

Und so sieht die Implementierung in der .cpp Datei aus :

void A::methode1(float p1) { }

void A::methode2(float p1) { }

Den ganzen include bla laß ich mal weg der ist uninteressant...

Jetzt will ich von einem ganz anderen Bereich (von mir aus von der main
methode aus) folgendes tun :

{
  A *p= new A();
  p->Methode= A::methode1;   // <== DAS GEHT ! Offenbar weil methode1 static
  p->Methode= A::methode2;   // <== GEHT NICHT ! Weil methode2 nicht static 
}

Wie bekomm ich das hin das auch eine nicht static deklariert methode
übergeben werden kann ? Ich möchte nämlich p->Methode dynamisch während
der Laufzeit ändern können also auf verschiedene Methoden zeigen lassen.

Bitte keine alternativen Möglichkeiten wie man das machen kann, sondern
wirklich eine Lösung die durch eventuell spezielles casten das möglich
macht was da oben nicht funktioniert, DANKE !!!

Schönes Wochenende !
Gruß Megelan

class A
{
  public :
  typedef void (A::*Methodenzeiger)(float f); // zeiger auf eine methode von A
  Methodenzeiger m;
  void (*Methode)(float);

  static void methode1(float p1);
         void methode2(float p1);
};

{
  A *p= new A();
  p->Methode= A::methode1;
  p->m      = A::methode2;
}

und wenn du m aufrufen willst brauchst du auch immer ein objekt
fuer das die methode aufgerufen werden soll:

void aufruf(A* a,Methodenzeiger m)
{
  (a->*m)(1.2); // aufruf der methode auf die m zeigt fuer das objekt a
}

du brauchst einen anderen zeigertyp:

class A
{
  public :
  typedef void (A::*Methodenzeiger)(float f); // zeiger auf eine methode von A
  Methodenzeiger m;
  void (*Methode)(float);

  static void methode1(float p1);
         void methode2(float p1);
};

{
  A *p= new A();
  p->Methode= A::methode1;
  p->m      = A::methode2;
}

und wenn du m aufrufen willst brauchst du auch immer ein objekt
fuer das die methode aufgerufen werden soll:

void aufruf(A* a,Methodenzeiger m)
{
  (a->*m)(1.2); // aufruf der methode auf die m zeigt fuer das objekt a
}

Ok, d.h. für static und nicht-static sind je zwei
unterschiedliche zeiger nötig. Gibts auch ne möglichkeit
das ich einen zeigertyp für beide arten von methoden
haben kann ? Genau das brauch ich nämlich.

Eine Variable (zeiger) den ich auf eine statische methode
genauso wie auf eine nicht-statische methode zeigen lassen
kann.

Geht das auch irgendwie ?