🚀 go-pugleaf

M G Berberich:
> 
>   Ich habe gestern versucht abgeleitete Klassen mit virtuellen
> Funktionen in einem STL-Container (list) zu speichern.  Dabei musste
> ich feststelle, dass die Klassen ihre Identitaet verlieren wenn man
> sie in den Container stellt.  D. h. beim Aufruf einer virtuellen
> Funktion wird die Funktion der Basisklasse aufgerufen und nicht die
> der abgeleitetn Klasse.
> 
> Kann man das irgendwie verhindern?
> 

Man kann den Pointer in einem Objekt kapseln, das u.a. fuer das
korrekte Kopieren der zugehoerigen Objekte zustaendig ist.
Die nachfolgenden Klassen skizzieren die Idee. Die generische
Klasse 'SP<T>' ('SmartPointer vom Typ T') verwaltet Pointer auf
ein T-Objekt oder auf ein Objekt einer Unterklasse von T. Durch
Ueberladen der entsprechenden Operatoren verhaelt sich eine 
Instanz von SP<T> wie ein T-Pointer.
Das Kopieren von Objekten wird in einer eigenen generischen Klasse
verwaltet. Durch Template-Spezialisierung koennen verschiedene
Implementierungen fuer unterschiedliche Typen bereitgestellt werden.
Z.B. verwendet man ueblicherweise fuer polymorphe Typen eine Funktion
'Clone' um eine Kopie eines gegebenen Objekts zu erzeugen, waehrend bei
herkoemmlichen Typen ein direktes Erstellen einer Kopie via 'new Type(obj)'
ausreicht.

>>>
template<class T> struct Dup { static T* Clone(T*); };
int* Dup<int> :: Clone(int* i) { return i ? new int(*i) : 0; }
template<class T> T* Dup<T> :: Clone(T* t) { return t ? t->Clone() : 0; }

template<class T> class SP {
 public:
  SP(T* pnt=0) : pnt_(pnt) {}
  SP(const SP& s) { pnt_=Dup<T> :: Clone(pnt_); }
  virtual ~SP() { delete pnt_; }
  SP& operator = (const SP& p) { 
    if (&p!=this) {
      this->~SP();
      new (this) SP(p.pnt_);
    }
    return *this;
  }
  T* operator -> () { return pnt_; }
  T& operator * () { return *pnt_; }
  operator T* () { return pnt_; }

private:
  T* pnt_;
};
<<<
Das Standard offeriert zwar elegantere Moeglichkeiten das Kopierverhalten
von der Wrapperklasse zu trennen, diese Lsg. duerfte aber auf allen gaengigen
Compilern laufen.

	Enno