rvalue ссылки

#if _HAS_AUTO_PTR_ETC
// CLASS TEMPLATE auto_ptr
template<class _Ty>
class auto_ptr;
 
template<class _Ty>
struct auto_ptr_ref
{   // proxy reference for auto_ptr copying
    explicit auto_ptr_ref(_Ty* _Right)
        : _Ref(_Right)
    {   // construct from generic pointer to auto_ptr ptr
    }
 
    _Ty* _Ref;  // generic pointer to auto_ptr ptr
};
 
template<class _Ty>
class auto_ptr
{   // wrap an object pointer to ensure destruction
public:
    typedef _Ty element_type;
 
    explicit auto_ptr(_Ty* _Ptr = nullptr) noexcept
        : _Myptr(_Ptr)
    {   // construct from object pointer
    }
 
    auto_ptr(auto_ptr& _Right) noexcept
        : _Myptr(_Right.release())
    {   // construct by assuming pointer from _Right auto_ptr
    }
 
    auto_ptr(auto_ptr_ref<_Ty> _Right) noexcept
    {   // construct by assuming pointer from _Right auto_ptr_ref
        _Ty* _Ptr = _Right._Ref;
        _Right._Ref = nullptr;  // release old
        _Myptr = _Ptr;  // reset this
    }
 
    template<class _Other>
    operator auto_ptr<_Other>() noexcept
    {   // convert to compatible auto_ptr
        return (auto_ptr<_Other>(*this));
    }
 
    template<class _Other>
    operator auto_ptr_ref<_Other>() noexcept
    {   // convert to compatible auto_ptr_ref
        _Other* _Cvtptr = _Myptr;   // test implicit conversion
        auto_ptr_ref<_Other> _Ans(_Cvtptr);
        _Myptr = nullptr;   // pass ownership to auto_ptr_ref
        return (_Ans);
    }
 
    template<class _Other>
    auto_ptr& operator=(auto_ptr<_Other>& _Right) noexcept
    {   // assign compatible _Right (assume pointer)
        reset(_Right.release());
        return (*this);
    }
 
    template<class _Other>
    auto_ptr(auto_ptr<_Other>& _Right) noexcept
        : _Myptr(_Right.release())
    {   // construct by assuming pointer from _Right
    }
 
    auto_ptr& operator=(auto_ptr& _Right) noexcept
    {   // assign compatible _Right (assume pointer)
        reset(_Right.release());
        return (*this);
    }
 
    auto_ptr& operator=(auto_ptr_ref<_Ty> _Right) noexcept
    {   // assign compatible _Right._Ref (assume pointer)
        _Ty* _Ptr = _Right._Ref;
        _Right._Ref = 0;    // release old
        reset(_Ptr);    // set new
        return (*this);
    }
 
    ~auto_ptr() noexcept
    {   // destroy the object
        delete _Myptr;
    }
 
    _NODISCARD _Ty& operator*() const noexcept
    {   // return designated value
#if _ITERATOR_DEBUG_LEVEL == 2
        _STL_VERIFY(_Myptr, "auto_ptr not dereferencable");
#endif /* _ITERATOR_DEBUG_LEVEL == 2 */
 
        return (*get());
    }
 
    _NODISCARD _Ty* operator->() const noexcept
    {   // return pointer to class object
#if _ITERATOR_DEBUG_LEVEL == 2
        _STL_VERIFY(_Myptr, "auto_ptr not dereferencable");
#endif /* _ITERATOR_DEBUG_LEVEL == 2 */
 
        return (get());
    }
 
    _NODISCARD _Ty* get() const noexcept
    {   // return wrapped pointer
        return (_Myptr);
    }
 
    _Ty* release() noexcept
    {   // return wrapped pointer and give up ownership
        _Ty* _Tmp = _Myptr;
        _Myptr = nullptr;
        return (_Tmp);
    }
 
    void reset(_Ty* _Ptr = nullptr)
    {   // destroy designated object and store new pointer
        if (_Ptr != _Myptr)
            delete _Myptr;
        _Myptr = _Ptr;
    }
 
private:
    _Ty* _Myptr;    // the wrapped object pointer
};
 
template<>
class auto_ptr<void>
{
public:
    typedef void element_type;
};
#endif /* _HAS_AUTO_PTR_ETC */