ich versuche, den Compiler zu überreden, dass ich dabei (markierte Zeile im Code) nichts Böses will.
Kann mir jemand mit einem Tipp helfen?
Tausend Dank im Voraus!

PS: Die FAQ habe ich schon gelesen

#include <iostream> 

class A { 
public: 
   int fA(); 
}; 

int A::fA() { return 1; } 
//----------------------------------------
class B { 
public: 
   B(); 
   int (A::*pFunc)();
   int fB();

}; 

int B::fB(){ return 2; }

B::B() { 
   pFunc = &A::fA;
//	pFunc = &B::fB; //hier weint der Compiler
}

//----------------------------------------
int main() 
{ 
   B b; 
   A a; 

   std::cout << (a.*b.pFunc)() << std::endl;
   return 0;
 }

int (A::*pFunc)();

bedeutet eine menberfunktion der klasse A ohne parameter die int zurückgibt.
B::fB() ist keine menberfunktion von A;
Kurt

ZuK schrieb:

B::fB() ist keine menberfunktion von A;

eben!
Die Frage: Was muss ich machen, sodass es doch geht?

Sergey

2. Möglichkeit
Ändere dein Design! Ich frage mich, wozu du einen Funktionszeiger auf eine A Memberfunktion definierst, und diesem dann eine B Memberfunktion zuweisen willst.

std::cout << (a.*b.pFunc)() << std::endl;

eine member-funktion von A aufrufen. da kann pFunc sowieso keine memberfunktion von B sein!

wenn pFunc eine member-funktion von B sein soll, dann mußt du sie als

int (B::*pFunc)();

deklarieren. dann mußt du pFunc aber auch auf ein objekt von der klasse B anwenden. schließlich kannst du ja auch nicht einfach die istream-methode flush() auf ein vector-objekt anwenden.

ABER! Ich darf ja keine Polymorphie benutzen.
Dann wird immer die run() der Basisklasse aufgerufen.

Es gibt natürlich verschiedene Lösungen (z.B. in Tasks irgendwelche Eigenschaften speichern, abfragen und dann entscheiden welche run() aufgerufen wird). Diese haben einen Nachteil – schlechte Erweiterbarkeit. Bei jeder neuen Task-Klasse, muss die Basisklasse CTask geändert werden.

Aus diesem Grund dachte ich, dieses Problem anders zu lösen:
Die Basisklasse hat eine run()-Funktion und einen Zeiger fptr auf eine Memberfunktion.
Ich implementiere in jeder Kindklasse die run() neu, und lasse den geererbten fptr auf die &run dieser Kindklasse zeigen.
Dann müsste der Taskmanager über den fptr immer die „richtige“ run() aufrufen ganz ohne die Polymorphie. Das System wäre genau so erweiterbar, wie mit der Polymorphie.

Wenn ein Objekt im Heap-Bereich erzeugt wird, speichert es neben seinen Attributen nur die Referenzen zu den Implementierungen seiner Funktionen im Stack-Bereich. Ich kann dann den Pointer auf eine Memberfunktion darauf zeigen lassen. Dementsprechend kann genau diese Memberfunktion über den Pointer aufgerufen werden.

Lieder meckert der Compiler, wenn ich den Zeiger fptr zu einer Funktion, die nicht von der Basisklasse ist, umbiege. Die Typen passen nicht mehr. Die Funktion soll von der Basisklasse sein.

Sagt mir bitte, falls ich irgendwo Gedankenfehler mache?
Falls nicht, hilft mir bitte, den Compiler auszutricksen.

Viele Grüße
Sergej

class CTask
{
  int (CTask::*RunFunc)();

  public:
  CTask (void *runFunc) : RunFunc(reinterpret_cast<CTask::*()>(runFunc) {}
  int Run () { return this->RunFunc(); }
};

class MyTask: public CTask
{
  int Run ();
  MyTask() : CTask(Run) {}
};

du mußt dann allerdings im konstruktor jeder task-klasse den funktionszeiger für Run() in der initialisierungsliste explizit angeben. ohne polymorphismus sehe ich leider keine möglichkeit, dies automatisch zu machen.