abstrakte klassen

krümelkacker

Ich hatte mal selbst 'nen clone_ptr gebastelt, finde den aber gerade nicht. Aber die Version war eh nicht C++98 oder C++03 kompatibel. Also hier mal eine Skizze für einen recht einfachen clone_ptr:

template<class T>
class clone_ptr
{
public:
   explicit clone_ptr(T* p=0) : ptr(p) {}
   ~clone_ptr() {delete ptr;}
   clone_ptr(clone_ptr const& x) : ptr(!x ? 0 : x->clone()) {}
   clone_ptr& operator=(clone_ptr temp) {swap(temp); return *this;}
   void swap(clone_ptr & other) {std::swap(this->ptr,other.ptr);}
   friend void swap(clone_ptr & a, clone_ptr & b) {a.swap(b);}
   T* release() {T* result=ptr; ptr=0; return result;}
   void reset(T* p=0) {clone_ptr temp (ptr); ptr=p;}
   bool operator!() const {return !ptr;}
   T const& operator*() const {return *ptr;}
   T      & operator*()       {return *ptr;}
   T const* operator->() const {return ptr;}
   T      * operator->()       {return ptr;}
   T const* get() const {return ptr;}
   T      * get()       {return ptr;}
private:
   T* ptr;
};

clone sollte dann bei dir eine const-qualifizierte, virtuelle Funktion in der mother -Klasse sein, die jede abgeleitete Klasse überschreiben müsste.

Wie man die Klone erzeugt und zerstört, könnte man noch parameterisieren.