Умный указатель с копированием

[Сtrl]

Рассмотрим такой код:

boost::shared_ptr<X> ptr1 = new X;
boost::shared_ptr<X> ptr2 = ptr1;

В итоге ptr1 и ptr2 указывают на один и тот же объект, это нормально, в этом и есть смысл shared_ptr;
Но что делать, если мне нужно, чтобы была создана копия объекта? Конечно, можно замутить конструкцию вроде такой:

boost::shared_ptr<X> ptr3 = new X(*ptr2);

Но мне кажется это несколько кривоватым. Возможно есть умные указатели, которые при присваивании сами создают новый объект?

[Сtrl]

Эх, ладно! Пришлось собственный реализовать. Выкладываю, может кому-то понадобится! Взял за основу std::auto_ptr.

template<class _Ty>
class copy_ptr
{	// wrap an object pointer to ensure destruction
public:
    typedef copy_ptr<_Ty> _Myt;
    typedef _Ty element_type;

    explicit copy_ptr(_Ty *_Ptr = 0)
        : _Myptr(_Ptr)
    {	// construct from object pointer
    }

    copy_ptr(const _Myt& _Right)
        : _Myptr(_Right.copy())
    {	// construct by copying pointer from _Right copy_ptr
    }


    operator bool()
    {
        return (bool(_Myptr));
    }

    template<class _Other>
    operator copy_ptr<_Other>()
    {	// convert to compatible copy_ptr
        return (copy_ptr<_Other>(*this));
    }

    template<class _Other>
    _Myt& operator=(const copy_ptr<_Other>& _Right)
    {	// assign compatible _Right (assume pointer)
        reset(_Right.copy());
        return (*this);
    }

    template<class _Other>
    copy_ptr(const copy_ptr<_Other>& _Right)
        : _Myptr(_Right.copy())
    {	// construct by assuming pointer from _Right
    }

    _Myt& operator=(const _Myt& _Right)
    {	// assign compatible _Right (assume pointer)
        reset(_Right.copy());
        return (*this);
    }

    ~copy_ptr()
    {	// destroy the object
        delete _Myptr;
    }

    _Ty& operator*() const
    {	// return designated value
        return (*get());
    }

    _Ty *operator->() const
    {	// return pointer to class object
        return (get());
    }

    _Ty *get() const
    {	// return wrapped pointer
        return (_Myptr);
    }

	_Ty *release()
	{	// return wrapped pointer and give up ownership
        _Ty *_Tmp = _Myptr;
        _Myptr = 0;
        return (_Tmp);
    }

    _Ty *copy() const
    {   // return pointer to copy of wrapped object
        _Ty *_Ptr = new _Ty(*get());
        return (_Ptr);
    }

	void reset(_Ty *_Ptr = 0)
    {	// destroy designated object and store new pointer
        if (_Ptr != _Myptr)
            delete _Myptr;
        _Myptr = _Ptr;
    }

private:
	_Ty *_Myptr;	// the wrapped object pointer
};

P.S. Прошу прощения за неровные отступы, у меня в редакторе все нормально.