ein Pattern verwenden?

netrobot

kann ich hier ein Design Pattern verwenden?
original:

class CDisplay
{
   ...
   virtual void Draw(){
   //draw for general situation
   }
};

class CFirstDisplay{
   ...
   void Draw(){
   //inital some data for this class
   //special Draw for this class
   }
};

class CSecondDisplay{
   ...
   void Draw(){
      //initial some data for this class
      CDisplay::Draw(); //here i dont like it
   }
};

class CThirdDisplay{
   ...
   void Draw(){
      //initial some data for this class
      CDisplay::Draw(); //here i dont like it
   }
};

man kann natürlich auch Draw als class definieren, dann spezielle draw methode in abgleiteten Klassen definieren, aber man kann nicht vermeiden, in abgleiteten Klassen, die methoden von superclass aufrufen.

pumuckl

ich nehme mal an dass du die anderen Displays von CDisplay ableitest.
Evtl. wäre das template method pattern was für dich:

class CDisplay
{
public:
  void Draw() //non-virtual, children don't override the method directly
  {
    doInit();
    doDraw();
  }
protected:
  virtual void doInit() = 0;
  virtual void doDraw() { /* ... general drawing */ }
};

class CFirstDisplay : public CDisplay
{
  //Draw() is inherited from CDisplay...
protected:
  virtual void doInit() { /* special initialisation for this class */ }
  virtual void doDraw() { /* special drawing for this class */ }
};

class CSecondDisplay : public CDisplay
{
protected:
  virtual void doInit() { /*...*/ }
  // doDraw() not overridden because the general drawing is sufficient
};

7H3 N4C3R

Das Template Method Pattern sollte hier anwendbar sein.

class Base
{
  void Draw() {
    // do some basic stuff
    doDraw();
    // some other stuff
  }
  virtual doDraw() {
    // empty
  }
}

Wer erweiterte Sachen machen will, überschreibt doDraw. Die Basisbehandlung findet in Draw statt.

Edit: Hmm Pumuckl war schneller

netrobot

1.es scheint, strategie und template pattern sind fast gleich
2. die Lösung, die ich vorher geschrieben hatte, ist ja auch korrekt, aber ich mag es nicht, wieso weiss ich auch nicht, welche Nachteile hat es in sich?

pumuckl

Das template method pattern und das strategy pattern sehen auf den ertsen Blick zwar ähnlich aus, sind aber doch verschieden: beim strategy pattern kann man die selbe Klasse an einer Stelle mit zwei verschiedenen Verhaltensweisen ausstatten. Bei dir hieße das, dass du dieselbe Displayklasse auf verschiedene Arten zeichnest, dass sich die verschiedenen Objekte also nur in ihrem Zeichenverhalten unterscheiden und ansonsten identisch sind.
Beim template method pattern wird dagegen das grundlegende Verhalten von Kindklassen vorgeschrieben, wobei einzelne Aspekte dieses Verhaltens von den Kindklassen abgeändert werden können. Im grunde sind beide Konzepte also Orthogonal:

Strategy pattern = gleiche Klasse, unterschiedliches Verhalten
template method pattern = verschiedene Klassen, ähnliche Verhaltensweise

netrobot

wenn wir nur die DoInit() anschauen, ist es kein strategie pattern? nicht direkt, aber wenn ich die DoInit in einer Base Class einpacke.Z.B

class CInitBase
{
   virtual void DoInit()=0;
};
class CInitConcrete1 : public CInitBase
{
   void DoInit(){/*implementation*/}
};
class CInitConcrete2 : public CInitBase
{
   void DoInit(){/*implementation*/}
};

Ob es einen Sinn macht, ist eine andere Frage

pumuckl

die CInit-Klassen für sich sind natürlich immernoch kein strategy-pattern. Wenn du deiner CDisplay-Klasse jettz eine CInit-Klase verpasst um deren Verhalten zu steuern, dann ist das ein Strategy-Pattern - allerdings ist eines der wichtigen Merkmale des Strategy-Pattern, dass man das Verhalten zur Laufzeit ändern kann (indem du zwischendurch die CInit-Klasse wechselst). Allerdings scheint das nicht deinen Absichten zu entsprechen, das Template Method Pattern wäre also ausreichend. Natürlich kannst du das Strategy-Pattern verwenden, du bekommst allerdings auf Kosten einer zusätzlichen Indirektion ein Feature das du in dem Umfang nicht brauchst. (Du könntest noch viel mehr Patterns benutzen, allerdings werden dir die meisten keinen besonderen Vorteil bringen, den Code nur unübersichtlich machen usw.)