C++ Methoden Durchlauf

[Maraike (Gast)]

Hallo zusammen, ich habe folgendes Problem:

ich habe 3 Klassen

class A
{
   ...
   public:
      meth1();
};

class B
{
   ...
   public:
      meth2();
};

class C
{
   ...
   public:
      meth3();
};

um Variable zu sein möchte ich die 3 Methoden je nach Konfiguration des 
Konstruktors in unterschiedlicher Reienfolge abarbeiten.

int main(void)
{
   ...
   for( u8TaskCount = 0u; u8TaskCount < u8MaxTasks; u8TaskCount++ )
   {
     // Je nach mitgabewert des Konstruktors
     meth1();
     meth3();
     meth2();

     // oder
     meth2();
     meth3();
   }
}

In C hätte ich das über eine Tabelle mit Funktionspointern gemacht aber 
in C++ habe ich noch keine Möglichkeit gefunden dieses Problem sauber zu 
lösen. Auf jeden Fall möchte ich keine Switch Case Abfrage verwenden.

Ich hoffe ihr könnt mir weiterhelfen.

Gruß Maraike

[Εrnst B. (ernst)]

Bring erstmal das Programm soweit in Ordnung, dass der Compiler es 
akzeptiert, und du wenigstens eine Methode erfolgreich aufrufen 
kannst, undabhängig von Parametern...

[Sharping (Gast)]

Maraike schrieb:
> Auf jeden Fall möchte ich keine Switch Case Abfrage verwenden.

Weil??? Wäre doch in deinem Fall genau das Richtige...

[Maraike (Gast)]

Über diesen Schritt bin ich schon längst hinaus. Also bitte keine 
Klugscheißer Kommentare mehr.

ACHTUNG - Der obige Code ist nur ein abstraktes Beispiel und kann 
natürlich nicht so compiliert werden - ACHTUNG

[Εrnst B. (ernst)]

Vermutlich soll die Hausaufgabenstellung folgendes Ergebnis bringen:

- Die drei Klassen erben von einer gemeinsamen Basis.
- Die Methode heißt immer gleich, und ist in der Basis als Virtuell 
markiert.
- Je nach Aufruf-Parameter wird eine Basisklassenpointer-Liste befüllt. 
(analog der Funktionspointer-Liste in C)
- Durchlaufen der Liste, Aufrufen der Methode auf jedem Element...

[Maraike (Gast)]

Insgesamt sind es 30 Methoden die je nach Plattform anders konfiguriert 
werden sollen. Ich möchte keine Switch Case da dann bis zu 30 Methoden 
überprüft werden.

[kopfkratzer (Gast)]

kopfkratz
Und wo ist da nun was objekorientiertes ?
Ein Lösungsansatz ist ja schon genannt worden, vielleicht mal im 
Stroustrup nachlesen ?

[Maraike (Gast)]

Hallo B*,

bitte gib kein Kommentar ab wenn du die Problematik noch nicht 
verstanden hast. Es ist keine Schande nachzufragen, vielleicht ist mein 
Beispiel nicht für jeden verständlich.

Wie im obigen Beispiel dargestellt existieren 3 Basisklassen mit ihren 
Methoden die vollkommen unterschiedlich heißen. Und ich möchte in einer 
Art Runtime diese Methoden ( die nichts mit einander gemein haben ) in 
unterschiedlicher Abfolge Abfragen.

Eine Klassenliste hilft mir da nicht weiter.

Hat vielleicht noch jemand eine Idee?

[Vlad T. (vlad_tepesch)]

Ich glaub der TO benötigt ein gutes C++ Tutorial

Ich fände folgenden Ansatz sehr viel besser:

class BaseTask
{
public:
  virtual void processingStep()=0;   
}

class Task1:public BaseTask
{
public:
  virtual void processingStep(){
    //tue was
  };   
}

class Task2:public BaseTask
{
public:
  virtual void processingStep(){
    //tue was anderes 
  };   
}

class Task3:public BaseTask
{
public:
  virtual void processingStep(){
    //tue was ganz anderes 
  };   
}

class BaseScheduler
{
public:
  virtual letATaskStep()=0;
  virtual addTask(BaseTask* i_task) = 0;
}

class RoundRobinScheduler : public BaseScheduler
{
public:
  RoundRobinScheduler()
   : m_curTask(0)
   , m_numTasks(0)
  {}
  static const int maxTasks = 10;

  virtual letATaskStep(){
    m_tasklist[m_curTask]->processingStep();
    ++m_curTask;
    if(m_curTask > m_numTasks)
      m_curTask = 0;
  }

  virtual addTask(BaseTask* i_task)
  {
    if(m_numTasks<maxTasks)
     m_tasklist[m_numTasks++] = i_task;
  }

private:
  int m_curTask;
  int m_numTasks;
  BaseTask* m_tasklist[maxTasks];
}

BaseScheduler* g_sched;

int main()
{
  RoundRobinScheduler rrsched;
  Task1 task1;
  Task2 task2;
  Task3 task3;
  g_sched = &rrsched;

  sched->addTask(&task1);
  sched->addTask(&task2);
  sched->addTask(&task3);

  for(;;)
  {
    sched->letATaskStep();
  }

}

PS: ich hab jetzt hier bewusst auf stl container verzichtet, um ohne 
dynamische Speicherverwaltung auszukommen.
Den Code könnte man somit auch auf einen kleinen µC einsetzen. Der 
Overhead durch die virtuellen Methoden wäre noch imho verschmerzbar.

[Vlad T. (vlad_tepesch)]

wenn die Klassen nix miteinander zu tun haben, außer eine identische 
Memberfunctions-Signatur, dann musst du dies nochmal verpacken.

du könntest zB, um bei meinem Beispiel zu bleiben eine template klasse 
schreiben, die von BaseTask ableitet und als konstruktorargument den 
Funktionspointer entgegennimmt.

Bin mir hier aber mit der Syntax nicht so richtig sicher

template <class T>
class GenericTask: public BaseTask
{
  typedef void (T* obj,  T::*MemberFunctionPointer) ();;
  GenericTask(  MemberFunctionPointer ptr )
   : m_ptr(ptr)
   , m_obj(obj)
  {}

  virtual void processingStep(){
    m_obj->(*m_ptr)();
  };   
  
private:
  T* m_obj;
  MemberFunctionPointer m_ptr;
};




...

int main()
{
  
  ...
  A a; // deine komische klasse
  GenericTask<A> gtA(&a, &(a->meth1) );
  B b; // deine komische klasse
  GenericTask<B> gtB(&b, &(b->meth2) );
  ...
  sched->addTask(&gtB);
}

edit:
Ergänzung im Code zur Benutzung.

Aber ich wette, dass der eigentliche Fehler in deinem Design der Klassen 
A, B, C liegt. Das ganze ist schon etwas krude

[Maraike (Gast)]

Danke das hilft mir weiter. Kann geschlossen werden.