c++raiiresource-management

Generic handle class


I stumbled onto this problem: Using unique_ptr to control a file descriptor. The std::unique_ptr is not really appropriate for a general handle. So is the more general class

template<class HandleType,HandleType nullvalue,class Deleter>
class Handle;

already implemented (maybe in boost), or should I roll my own. This question has been raised before in What wrapper class in C++ should I use for automated resource management?, but now we have C++14 so there can be more alternatives.

I also found the following proposal: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3677.html. So someone else has also thought about this problem.


Solution

  • There's no such class in C++ standard yet, so I decided to write my own:

    template<typename Policy>
    class unique_handle
    {
        typename Policy::handle_type h;
    
    public:
        unique_handle(const unique_handle&) = delete;
    
        typename Policy::handle_type get() const
        {
            return h;
        }
    
        typename Policy::handle_type release()
        {
            typename Policy::handle_type temp = h;
            h = Policy::get_null();
            return temp;
        }
    
        explicit operator bool() const
        {
            return !Policy::is_null(h);
        }
    
        bool operator!() const
        {
            return !static_cast<bool>(*this);
        }
    
        void reset(typename Policy::handle_type new_handle)
        {
            typename Policy::handle_type old_handle = h;
            h = new_handle;
            if(!Policy::is_null(old_handle))
            {
                Policy::close(old_handle);
            }
        }
    
        void swap(unique_handle& other)
        {
            std::swap(this->h, other.h);
        }
    
        void reset()
        {
            reset(Policy::get_null());
        }
    
        ~unique_handle()
        {
            reset();
        }
    
        unique_handle& operator=(unique_handle other) noexcept
        {
            this->swap(other);
            return *this;
        }
    
        unique_handle(unique_handle&& other) noexcept
        {
            this->h = other.h;
            other.h = Policy::get_null();
        }
    
        unique_handle()
        {
            h = Policy::get_null();
        }
    
        unique_handle(typename Policy::handle_type handle)
        {
            h = handle;
        }
    };
    

    sample usage:

    #include <wiertlo/unique_handle.hpp>
    #include <iostream>
    #include <cassert>
    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    
    struct file_descriptor_policy
    {
        typedef int handle_type;
        static void close(handle_type handle)
        {
            ::close(handle);
        }
    
        static handle_type get_null()
        {
            return -1;
        }
    
        static bool is_null(handle_type handle)
        {
            return handle == -1;
        }
    };
    
    int main()
    {
        typedef wiertlo::unique_handle<file_descriptor_policy> file_descriptor;
        file_descriptor null_fd; // null file descriptor
        assert(!null_fd);
        file_descriptor fd(open("/dev/null", O_WRONLY));
        assert(fd);
        write(fd.get(), "test", 4);
        file_descriptor other = std::move(fd);
        assert(!fd);
        assert(other);
    }