Re: [boost] unique_ptr for C++03

Subject: Re: [boost] unique_ptr for C++03
From: Eric Niebler (eniebler_at_[hidden])
Date: 2013-08-03 17:12:05

On 8/3/2013 2:00 AM, Andrew Ho wrote:
> Hi,
> 
> I implemented std::unique_ptr using C++03 features plus a few other
> Boost Libraries. Incidentally, I also implemented default_delete
> (which binds to std::default_delete if available) because it's
> required for unique_ptr.
> 
> https://github.com/helloworld922/unique_ptr

I never participated much in the discussion of Boost.Move, so I don't
know if this emulation approach was ever discussed, but once upon a
time I developed my own technique to simulate move-only types in
C++03. I never did anything with this technique when I first
discovered it (about 10 years ago now), and indeed completely forgot
about it until now.

Not extensively tested. Might miss important corner cases ...

    template<typename T>
    struct unique_ptr;

    template<typename T>
    struct unique_ptr_ref
    {
        explicit unique_ptr_ref(T *p)
          : p_(p)
        {}
    private:
        friend struct unique_ptr<T>;
        T *p_;
    };

    template<typename T>
    struct unique_ptr
    {
        unique_ptr()
          : p_(0)
        {}

        explicit unique_ptr(T *p)
          : p_(p)
        {}

        unique_ptr(unique_ptr_ref<T> r)
          : p_(r.p_)
        {}

        ~unique_ptr()
        {
            delete p_;
        }

        operator unique_ptr_ref<T>()
        {
            unique_ptr_ref<T> r(p_);
            p_ = 0;
            return r;
        }

        T *operator->() const
        {
            return p_;
        }

        T &operator*() const
        {
            return *p_;
        }

    private:
        unique_ptr(unique_ptr &); // param must be non-const ref
        unique_ptr &operator=(unique_ptr const &);
        T *p_;
    };

    template<typename T>
    unique_ptr<T> make_unique()
    {
        return unique_ptr<T>(new T);
    }

    template<typename T>
    unique_ptr<T> move(unique_ptr<T> &p)
    {
        return unique_ptr<T>(static_cast<unique_ptr_ref<T> >(p));
    }

    int main()
    {
        unique_ptr<int> p = make_unique<int>();
        //unique_ptr<int> no = p; // <== ERROR
        unique_ptr<int> yes = move(p); // <== OK
    }

-- 
Eric Niebler
Boost.org
http://www.boost.org