Dynamisches Erzeugen unterschiedlicher Klassen

[Karlheinz Druschel (Gast)]

Hi Leuts,

folgende Frage:
Ich habe zwei Klassen 8DBL425 und DBL800). Sie unterschieden sich
lediglich im Aufbau einiger Mehtoden, haben aber nach aussen hin die
gleichen Methoden mit gleichen Parametern und gleichen Rückgabewerten.
Nun möchte ich zur Laufzeit eine Variable erzeugen, entweder von der
einen Klasse doer von der anderen. Das entscheidet sich erst zur
Laufzeit! Dazu möchte ich aber ein und denselben Pointer benutzen. Aber
wie rufe ich dann die Methoden auf, da ich ja erst zur Laufzeit weiss
von welchem Typ der Pointer ist ?

Hintergrund ist folgender:
Über die serielle Schnittstelle kommuniziere ich mit einem Messgerät.
Dieses Protokoll wurde aber einmal geändert, weshalb ich hier zwei
unterschiedliche Protokolle einhalten muss, entweder das eine oder das
andere.
Wie mache ich sowas am besten ?

Greets
Karlheinz

[Rufus Τ. F. (rufus)]

Beide Klassen verwenden die gleiche Basisklasse, alle relevanten von Dir
aufzurufenden Methoden sind virtuelle Methoden,

Also;

basisklasse
{
  virtual int machwas() = 0;
};

klasse1 : public basisklasse
{
  virtual int machwas() { return 1;};
};

klasse2 : public basisklasse
{
  virtual int machwas() { return 2;};
};


basisklasse* p;
int x;

p = (basisklasse *) new klasse1;

x = p->machwas();

// x ist 1

p = (basisklasse *) new klasse2;

x = p->machwas();

// x ist 2

Statt des C-Typecasts "(basisklasse *)" sollte ein geeigneteres
C++-Konstrukt verwendet werden, reinterpret_cast oder dergleichen.

[H-A-L-9000 (Gast)]

class Kommunikator
{
   public:
   Kommunikator(int param1, int param2)
   {
      ... // Hier könnte man das tun, was beide Klassen
          // gemeinsam haben
   }

   virtual ~Kommunikator()
   {
      ...
   }

   virtual void tueDies(void)=0;
   virtual void tueDas(void)=0;
}

class Protokoll1Kommunikator : public Kommunikator
{
   public:
   Protokoll1Kommunikator(int param1, int param2, int param3)
                 :Kommunikator (param1, param2)
   {
      // Mit param1 und 2 wird der Konstruktor von
      // Kommunikator aufgerufen
      ... // Konstruktor von Protokoll 1
   }

   ~Protokoll1Kommunikator()
   {
      ...
   }

   void tueDies(void)
   {
      ... // Wie Protokoll 1 dies tut.
   }
   void tueDas(void)
   {
      ... // Wie Protokoll 1 das tut.
   }
   private:
   void ganzgeheim()
   {
      ... // Etwas ganz Geheimes das nur Protokoll 1 macht
   }
}

class Protokoll2Kommunikator : public Kommunikator
{
   public:
   // Konstruktor wie oben


   void tueDies(void)
   {
      ... // Wie Protokoll 2 dies tut.
   }
   void tueDas(void)
   {
      ... // Wie Protokoll 2 das tut.
   }

   ~Protokoll2Kommunikator()
   {
      ...
   }
}

void main()
{
   int protokoll;
   ...
   Kommunikator* k;
   if(protokol==1) k = new Protokoll1Kommunikator(a,b,c);
   else if(protokol==2) k = new Protokoll2Kommunikator(...);
   ...
   k->tueDies();
   k->tueDas();
   ...

}

[H-A-L-9000 (Gast)]

...zu langsam...

[Christoph _. (chris)]

@Rufus: Beim Casten eines Objekt-Zeigers auf einen Basisklassen-Zeiger
ist gar kein cast nötig, das geschieht implizit.

[Rufus Τ. F. (rufus)]

Schön ausgedrückt, aber natürlich trotzdem richtig =8^)

[Mäxchen (Gast)]

Also da gibt es ganz kluge Leute, die haben vor nicht langer Zeit
Designpatterns aufgeschrieben, wenn sich bei mir jemand um eine Stelle
als Programmierer bewirbt kommt die Frage nach Kenntnis von
Designpatterns:

Ich empfehle:

"Entwurfsmuster" von Gamma/Helm/Johnson/Vlissides

Adison-Weseley ISBN 3-8273-1862-9

Orginal ist auf Englisch, ist auch besser.

Dort findet man Fabrik und abstrakte Fabrik

Warum das Rad neu erfinden...