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.

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
};

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

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

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