I>>Идея проста — подобно std::auto_ptr и boost::scoped_ptr и пр. сделать смарт-пойнтер, который следил бы за освобождением некоторого ресурса операционной системы. Т.е. правильно было бы его назвать смарт-хендл .

I>>В boost ничего похожего не нашел..

typedef shared_ptr<void> handle;

handle createProcess()
{
    shared_ptr<void> pv(CreateProcess(), CloseHandle);
    return pv;
}

I>>>Идея проста — подобно std::auto_ptr и boost::scoped_ptr и пр. сделать смарт-пойнтер, который следил бы за освобождением некоторого ресурса операционной системы. Т.е. правильно было бы его назвать смарт-хендл .

I>>>В boost ничего похожего не нашел..

PP4>typedef shared_ptr<void> handle;

PP4>handle createProcess()
PP4>{
PP4>    shared_ptr<void> pv(CreateProcess(), CloseHandle);
PP4>    return pv;
PP4>}


PP4>

template<class Y, class D> shared_ptr(Y * p, D d);

I>Идея проста — подобно std::auto_ptr и boost::scoped_ptr и пр. сделать смарт-пойнтер, который следил бы за освобождением некоторого ресурса операционной системы. Т.е. правильно было бы его назвать смарт-хендл .

I>В boost ничего похожего не нашел..

namespace HelpUtils
{
    // Default handle strategy
    class DefaultHandle
    {
    protected:
        void close(HANDLE handle)
        {
            ::CloseHandle(handle);
        }
    };

    // Strategy for sockets
    class SocketHandle
    {
    protected:
        void close(SOCKET sock)
        {
            closesocket(sock);
        }

        HANDLE get_as(SOCKET sock, HANDLE) const
        {
            return reinterpret_cast<HANDLE>(sock);
        }
    };

    // auto pointer for handles
    // HandleT - type of the handle (for example HANDLE or SOCKET);
    // InvalidValueConst - invalid value constant (for example INVALID_SOCKET)
    // HandleStrategyT - specific strategy for the this handle type,
    //                   must implement so operation as handle close,
    //                   can implement get_as operation for handle converting.
    template<typename HandleT, HandleT InvalidValueConst, class HandleStrategyT = DefaultHandle>
    class auto_handle : public HandleStrategyT
    {
    public:
        typedef HandleT handle_type;
        typedef auto_handle<HandleT, InvalidValueConst, HandleStrategyT> auto_handle_type;
        
        explicit auto_handle(HandleT h = InvalidValueConst) throw()
                : owns(h != InvalidValueConst), handle(h) {}

        auto_handle(const auto_handle_type& left) throw()
                : owns(left.owns), handle(left.release()) {}

        auto_handle_type& operator=(const auto_handle_type& left) throw()
        {
            if(this != &left)
            {
                if(handle != left.get())
                {
                    if(owns)
                    {
                        close();
                    }
                    owns = left.owns;
                }
                else if(left.owns)
                {
                    owns = true;
                }
                handle = left.release();
            }
            
            return (*this);
        }

        ~auto_handle()
        {
            if(owns)
            {
                close();
            }
        }

        // Get handle
        handle_type get() const throw(){ return handle; }

        // Release handle (not close!)
        handle_type release() const throw()
        {
            owns = false;
            return handle;
        }

        // Convert handle from type HandleT to type Type.
        // For using this function handle strategy must implement function get_as:
        // Type get_as(HandleT, Type)
        template<typename Type>
        Type get_as(Type tp) const
        {
            return HandleStrategyT::get_as(handle, tp);
        }

        // Check is handle valid
        bool is_valid() const { return handle != InvalidValueConst; }

        // Close handle.
        // Handle strategy must implement function close for real handle closing:
        // void close(HandleT)
        void close()
        {
            if(is_valid())
            {
                HandleStrategyT::close(handle);
                handle = InvalidValueConst;
            }
        }

        // Reset handle. Close current and set new.
        void reset(HandleT h)
        {
            close();
            handle = h;
        }

    private:
        mutable bool owns;
        HandleT handle;
    };

    // Typedef for standart handle.
    typedef auto_handle<HANDLE, 0> StdHandle;
    // Typedef for sockets.
    typedef auto_handle<SOCKET, INVALID_SOCKET, SocketHandle> SocketWrap;
}