C++Talk.NET

Markus Moll · Guest

Hallo

Ich habe hier eine bestehende (halbwegs grÃ¶ÃŸere) Klassenhierarchie,
weitgehend (durchgehend?) single-inheritance. Es gibt eine gemeinsame
Basisklasse, nennen wir sie Base.

Nun Ã¼berlege ich, wie man dort einfach clone()-FunktionalitÃ¤t (virtuelle
Funktion, die eine Kopie des most-derived objects zurÃ¼ckgibt) hinzufÃ¼gen
kann. Das ganze soll mÃ¶glichst wenig intrusiv sein, das HinzufÃ¼gen einer
virtuellen Funktion ist mir schon zu hart (und zu fragil: was passiert,
wenn man die mal vergiÃŸt?).

Jetzt kam mein krankes Hirn auf folgendes:
- Ich bastele eine CloneFactory. Diese soll dynamisch registrierte Typen
kopieren kÃ¶nnen.
- Dies geschieht Ã¼ber eine map von type_info-wrappern auf Kopierobjekte
(Memory overhead im Vergleich zu clone()-Funktionen, aber na gut Sad

)
- Registrierung geschieht Ã¼ber templatifizierte Basisklasse

Damit braucht man "nur" jede Klasse von einer weiteren erben lassen.
Tut man das nicht, oder vererbt man von der falschen, so kann man solche
Objekte nicht clonen.

Das Minimalbeispiel wird leider schon recht lange... hier ist es trotzdem:

// -----------------------------------------------------------

#include <boost/shared_ptr.hpp>
#include <map>
#include <typeinfo>
#include <iostream>

// wraps std::type_info, needed to map from type_info
struct type_info_wrapper
{
const std::type_info *ti;
type_info_wrapper(const std::type_info& ti) : ti(&ti) {}
bool operator< (const type_info_wrapper& t2) const
{
return ti->before(*t2.ti);
}
};

struct Base
{
virtual ~Base() {}
boost::shared_ptr<Base> clone() const;
};

struct bad_clone {}; // exception

struct clone_base
{
virtual ~clone_base() {}
virtual boost::shared_ptr<Base> clone(const Base&) const = 0;
};

class CloneFactory
{
std::map<type_info_wrapper, boost::shared_ptr<clone_base> >
clone_map;
CloneFactory() {}
static CloneFactory *instance;

public:
boost::shared_ptr<Base> clone(const Base& b)
{
boost::shared_ptr<clone_base> c clone_map[typeid(b)];
if(!c) throw bad_clone();
return c->clone(b);
}

void register_cloner(const std::type_info& ti,
boost::shared_ptr<clone_base> cb)
{
clone_map[ti] = cb;
}

static CloneFactory* the()
{
if(!instance) instance = new CloneFactory();
return instance;
}
};

CloneFactory* CloneFactory::instance = 0;

boost::shared_ptr<Base> Base::clone() const
{
return CloneFactory::the()->clone(*this);
}

template<typename T>
struct cloner : virtual public clone_base
{
virtual boost::shared_ptr<Base> clone(const Base &obj) const
{
if(typeid(T) != typeid(obj)) throw bad_clone();
return boost::shared_ptr<Base>( new T( *static_cast<const
T*>(dynamic_cast<const void*>(&obj) ) ) );
}
};

template<typename T>
class clone_registrant
{
struct aux
{
aux()
{

CloneFactory::the()->register_cloner(typeid(T),
boost::shared_ptr<clone_base>(new cloner<T>()));
}
};

public:
clone_registrant()
{
static aux doitonce;
}
};

// User code (derived classes)

struct Der1 : public Base, private clone_registrant<Der1>
{
};

struct Der2 : public Der1, private clone_registrant<Der2>
{
};

int main()
{
boost::shared_ptr<Base> p1( new Der1() );
boost::shared_ptr<Base> p2( p1->clone() );
std::cerr << typeid(*p2).name() << "\n";
}

// ------------------------------------------------------------

Dazu: ist das Ã¼bermÃ¤ÃŸig kompliziert? (es erscheint mir so)
Geht der dynamic_cast oben gut? (So wie ich das lese schon)
(Nomenklatur ist merkwÃ¼rdig, darum soll's mal nicht gehen)

GruÃŸ
Markus

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de

Torsten Robitzki · Guest

Markus Moll wrote: