Re: Generic clone

On Aug 21, 5:27 am, Simon Richter <Simon.Rich...@hogyros.de> wrote:


[...]

You're also forgetting one thing that makes it ugly:

Your clone function is responsible for allocating your memory. That's
where the root of the ugliness lies. A virtual constructor should just
be a way to construct, not be a way to allocate memory, construct, and
then return a pointer to that memory that will be handled by who knows
who.
Plus not everyone may want to use new to allocate your object, because
they need to allocate it in a special place or because they need to
allocate it in a special pool. (think embedded systems, kernel
programming, etc.)

However, the callee doesn't have enough information to know how to
allocate the object: it needs to know its size, and eventually its
alignment.

Here is then a possible solution:

struct Base
{
    virtual void construct(void* p) const
    {
        new(p) Base();
    }

    virtual void clone(void* p) const
    {
        new(p) Base(*this);
    }

    virtual std::pair<std::size_t, std::size_t> size_and_align() const
    {
        return std::make_pair(sizeof Base, alignof Base);
    }
};

struct Derived : public Base
{
    void construct(void* p) const
    {
        new(p) Derived();
    }

    void clone(void* p) const
    {
        new(p) Derived(*this);
    }

    virtual std::pair<std::size_t, std::size_t> size_and_align() const
    {
        return std::make_pair(sizeof Derived, alignof Derived);
    }
};

There could be more overloads of 'construct' for other constructors.

Unfortunetely, the copy-constructor more or less has to be treated
separately to prevent confusion between Derived(Derived) and
Derived(Base). There is room for discussion here though.

It could be interesting to have the compiler automatically generates
those virtual "magic" functions when we tag constructors as being
virtual. (size_and_align could actually always be there)

Then, we could do:

template<typename T>
T* new_clone(const T& t)
{
    T* tmp = ::operator new(t.size_and_align().first);

    try
    {
        t.clone(tmp);
    }
    catch(...)
    {
        ::operator delete(tmp);
        throw;
    }

    return tmp;
}

int main()
{
    std::unique_ptr<Base> b = new Derived;
    std::unique_ptr<Base> b2 = new_clone(*b);
}

---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:std-c++@ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]