A clone_ptr that does not require T to have a clone method Here is my clone pointer template:

#include &lt;functional&gt;
#include &lt;utility&gt;
#include &lt;iostream&gt;

template&lt;typename T&gt;
struct clone_ptr
{
    clone_ptr() : ptr(nullptr), cloner(nullptr) {}
    clone_ptr(clone_ptr&amp;&amp; other) noexcept
        : clone_ptr()
    {
        swap( other );
    }
    clone_ptr(const clone_ptr&amp; other)
    {
        ptr = other.cloner(other.ptr);
        cloner = other.cloner;
    }
    void swap( clone_ptr&amp; other ) noexcept
    {
        using std::swap;
        swap( ptr,    other.ptr    );
        swap( cloner, other.cloner );
    }

    clone_ptr&amp; operator=( const clone_ptr&amp; other )
    {
        clear();
        ptr = other.cloner(other.ptr);
        cloner = other.cloner;
        return *this;
    }
    clone_ptr&amp; operator=( clone_ptr&amp;&amp; other )
    {
        clear();
        swap(other);
        return *this;
    }

    T* operator-&gt;() { return ptr; }
    const T* operator-&gt;() const { return ptr; }
    T&amp; operator*() { return *ptr; }
    const T&amp; operator*() const { return *ptr; }

    operator bool() const { return ptr; }

    bool operator&lt;(const clone_ptr&amp; other) const
    {
        if(!ptr) return other.ptr;
        if(!other.ptr) return false;
        return (*ptr) &lt; (*other.ptr);
    }
    bool operator==(const clone_ptr&amp; other) const
    {
        if(!ptr) return !other.ptr;
        if(!other.ptr) return false;
        return (*ptr) == (*other.ptr);
    }

    std::ostream&amp; output(std::ostream&amp; os) const { if(ptr) os &lt;&lt; *ptr; else os &lt;&lt; "&lt;nullptr&gt;"; return os ; }

    template&lt;typename T2=T, typename ...Ts&gt;
    void make( Ts&amp;&amp; ...ts )
    {
        clear();
        ptr = new T2( std::forward&lt;Ts&gt;(ts)... );
        cloner = [](T* p) -&gt; T* { return new T2( * (T2*) p ); };
    }

    void clear() { delete ptr; ptr=nullptr; cloner=nullptr; }

    ~clone_ptr() { clear(); }

private:
    T* ptr;
    std::function&lt;T*(T*)&gt; cloner;
};

template&lt;typename T, typename T2=T, typename ...Ts&gt;
clone_ptr&lt;T&gt; make_cloned( Ts&amp;&amp; ...ts )
{
    clone_ptr&lt;T&gt; p;
    p.template make&lt;T2&gt;( std::forward&lt;Ts&gt;(ts)... );
    return p;
}

template&lt;typename T&gt;
std::ostream&amp; operator&lt;&lt;(std::ostream&amp; os, const clone_ptr&lt;T&gt;&amp; p) { return p.output(os); }


It is primarily intended to preserve polymorphism, esp. when stored in a container. It "forwards" operator&lt; and operator== so containers can be sorted etc. based on the contained object.

Have I missed/forgotten anything?
Prefer to use Copy and Swap Idiom

clone_ptr&amp; operator=( const clone_ptr&amp; other )
{
    clear();
    ptr = other.cloner(other.ptr);
    cloner = other.cloner;
    return *this;
}


Or

clone_ptr&amp; operator=(clone_ptr copy)
{
    copy.swap(*this);
    return *this;
}


No need to clear on move assignment

clone_ptr&amp; operator=( clone_ptr&amp;&amp; other )
{
    // clear();   No need to do that.
                  The destructor of `other` will do that at some point.
    swap(other);
    return *this;
}


Easier to write as:

clone_ptr&amp; operator=(clone_ptr copy)
{
    copy.swap(*this);
    return *this;
}


Personally I don't see the point in havin output() and operator&lt;&lt;

I would just combine them into operator&lt;&lt; and make it a friend (also declare it in the class).