Re: How to implement the virtual constructor behavour in C++

I'm not sure what exactly OP needs, but I assume it
is either function Shape * CreateShape(const char *)
or method Shape * Shape::Clone() const.

1. Cloning.

struct Shape
{
     virtual Shape * Clone() const = 0;
};

template <class Derived, class Base>
struct CloneImpl : Base
{
     virtual Derived * Clone() const
     {
         return new Derived(static_cast<const Derived &>(*this));
     }
};

struct Circle : CloneImpl<Circle, Shape> {};
struct Rectangle : CloneImpl<Rectangle, Shape> {};
// Square inherits Rectangle
struct Square : CloneImpl<Square, Rectangle> {};

It is also good idea to use NVI for clone. Like this:

struct Shape
{
     Shape * Clone() const
     {
         Shape * res = DoClone();
         assert(typeid(*this) == typeid(*res));
         return res;
     }
private:
     virtual Shape * DoClone() const = 0;
};

This way you'll get assert at runtime if you forget to
implement DoClone.

// Rectangle implements DoClone correctly
struct Rectangle : CloneImpl<Rectangle, Shape> {};
// Author of Square forgot to implement DoClone
struct Square : Rectangle {};

Square s;
s.Clone(); // assert

2. Object creation by name.

Standard solution is to register all your types in global
map. Registration is usually done from constructors of
static objects.

struct ShapeRegistry
{
     typedef Shape * (*Factory)();

     static ShapeRegistry & Instance()
     {
         static ShapeRegistry reg;
         return reg;
     }

     void Register(const char * name, Factory f)
     {
         m_fact[name] = f;
     }

     Shape * Create(const char * name)
     {
         return m_fact[name]();
     }

private:
     map<string, Factory> m_fact;
};

template <class T>
T * Create() { return new T(); }

template <class T>
struct Registrar
{
     Registrar(const char * name)
     {
         ShapeRegistry::Instance().Register(name, Create<T>);
     }
};

#define REGISTER_SHAPE(T) static Registrar<T>(#T)

struct Circle : Shape {};
REGISTER_SHAPE(Circle);

struct Square : Shape {};
REGISTER_SHAPE(Square);

int main()
{
     Shape * shape = ShapeRegistry::Instance().Create("Circle");
}

This solution can be easily generalized to all types
(not only Shapes). It is also possible to pass parameters to
constructors of object being created, you can get rid of macros,
etc.

Roman Perepelitsa.

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]