Question

我正在尝试使用std :: unique_ptrs以异常安全的方式管理Windows HANDLE。

首先我尝试了：

struct HandleDeleter
{
    void operator()( HANDLE handle )
    {
        if( handle )
        {
            FindVolumeClose( handle )
        }
    }
}
typedef std::unique_ptr< HANDLE, HandleDeleter > unique_vol_handle_t;

稍后在我的代码中尝试使用它时：

unique_vol_handle_t volH( FindFirstVolumeW( buffer, MAX_GUID_PATH ) );

我从Visual Studio 2012RC收到以下错误：

1>          error C2664: 'std::unique_ptr<_Ty,_Dx>::unique_ptr(std::nullptr_t) throw()' : cannot convert parameter 1 from 'HANDLE' to 'std::nullptr_t'
1>          with
1>          [
1>              _Ty=HANDLE,
1>              _Dx=VolumeHandleDeleter
1>          ]
1>          nullptr can only be converted to pointer or handle types

引用上面的volH声明行。

搜索了一段时间后，我发现a blog article基本上说，添加：

typedef HANDLE pointer;

到结构声明的顶部，一切都会好的。

我不相信，但我尝试了它，它确实解决了错误。我很困惑如何定义一个类型（甚至没有引用它）可以产生这样的差异。

两个问题：

1）你能解释原始错误吗？我不明白为什么编译器指的是std::nullptr_t/nullptr。

2）typedef如何解决这个问题（或者至少看起来如此）？是否有一个较少的“远距离的幽灵行动”解决方案呢？

Answer 1

unique_ptr的实现检查删除器上是否存在::pointer类型。如果删除者具有::pointer类型，则此类型将用作pointer上的unique_ptr typedef。否则，使用指向第一个模板参数的指针。

根据cppreference.com，unique_ptr::pointer类型定义为

std::remove_reference<D>::type::pointer如果存在该类型，则为T*

Answer 2

来自MSDN manual on unique_ptr：

存储的指向所拥有资源的指针stored_ptr具有类型指针。如果已定义，则为Del::pointer，否则为Type *。如果删除器是无状态的，则存储的删除器对象stored_deleter在对象中不占用空间。请注意，Del可以是引用类型。

这意味着如果你提供一个删除函子，它必须提供pointer类型，用于unique_ptr的实际指针类型。否则，它将是指向您提供的类型的指针，在您的情况HANDLE*中，这是不正确的。

Answer 3

我建议您查看A Proposal to Add additional RAII Wrappers to the Standard Library和the drawbacks of using smart pointers with handles。

就我个人而言，我正在使用该提案的参考实施，而不是在这些情况下使用std::unique_ptr。

Answer 4

我一直在为Windows中的各种类型的句柄执行以下操作。假设我们已在某处声明：

std::unique_ptr<void, decltype (&FindVolumeClose)> fv (nullptr, FindVolumeClose);

这是填充：

HANDLE temp = FindFirstVolume (...);
if (temp != INVALID_HANDLE_VALUE)
    fv.reset (temp);

无需声明单独的结构来包装删除器。由于HANDLE实际上是void *，unique_ptr需要void作为其类型;对于使用DECLARE_HANDLE宏的其他类型句柄，可以避免这种情况：

// Manages the life of a HHOOK
std::unique_ptr<HHOOK__, decltype (&UnhookWindowsHookEx)> hook (nullptr, UnhookWindowsHookEx);

等等。

Answer 5

对Windows HANDLE使用std::unique_ptr的正确（且安全）方式是这样的：

#include <windows.h>
#include <memory>

class WinHandle {
    HANDLE value_;
public:
    WinHandle(std::nullptr_t = nullptr) : value_(nullptr) {}
    WinHandle(HANDLE value) : value_(value == INVALID_HANDLE_VALUE ? nullptr : value) {}

    explicit operator bool() const { return value_ != nullptr; }
    operator HANDLE() const { return value_; }

    friend bool operator ==(WinHandle l, WinHandle r) { return l.value_ == r.value_; }
    friend bool operator !=(WinHandle l, WinHandle r) { return !(l == r); }

    struct Deleter {
        typedef WinHandle pointer;
        void operator()(WinHandle handle) const { CloseHandle(handle); }
    };
};

inline bool operator ==(HANDLE l, WinHandle r) { return WinHandle(l) == r; }
inline bool operator !=(HANDLE l, WinHandle r) { return !(l == r); }
inline bool operator ==(WinHandle l, HANDLE r) { return l == WinHandle(r); }
inline bool operator !=(WinHandle l, HANDLE r) { return !(l == r); }

typedef std::unique_ptr<WinHandle, WinHandle::Deleter> HandlePtr;

这种方式INVALID_HANDLE_VALUE被隐式视为null，因此永远不会传递给CloseHandle函数，您永远不需要显式测试它。正如您通常所做的那样，使用std::unique_ptr＆＃39; operator bool()：

HandlePtr file(CreateFile(...));
if (!file) {
    // handle error
}

编辑：我最初忘记了INVALID_HANDLE_VALUE类型的HANDLE is not the only invalid value，实际上它被视为valid pseudo handle许多（如果不是大多数）内核函数。嗯，很高兴知道。

Answer 6

请查看Window Implementation Libraries（WIL），尤其是unique_handle与unique_hfile，以处理无效的句柄值。

Answer 7

虽然@Levi Haskell的答案考虑了INVALID_HANDLE_VALUE，但它没有考虑0是一个有效的句柄值，并将INVALID_HANDLE_VALUE和0（或nullptr）视为相同。这是不正确的：

我的建议（基于Levi Haskell，他的代码因此归功于他）

template<void *taInvalidHandleValue>
class cWinHandle 
{
    HANDLE value_ { taInvalidHandleValue };
public:
    cWinHandle() = default;
    cWinHandle(HANDLE value) : value_(value) {}
    ~cWinHandle()
    {
        reset();
    }

    explicit operator bool() const { return value_ != taInvalidHandleValue; }
    operator HANDLE() const { return value_; }

    HANDLE get() const { return value_; }
    HANDLE release() { HANDLE const result{ value_ }; value_ = taInvalidHandleValue; return result; }
    friend bool operator ==(cWinHandle l, cWinHandle r) { return l.value_ == r.value_; }
    friend bool operator !=(cWinHandle l, cWinHandle r) { return !(l == r); }
    void reset ()
    {
        if (value_ != taInvalidHandleValue)
        {
            CloseHandle(value_);
            value_ = taInvalidHandleValue;
        }
    }
};

inline bool operator ==(HANDLE l, cWinHandle<nullptr> r) { return cWinHandle<nullptr>(l) == r; }
inline bool operator !=(HANDLE l, cWinHandle<nullptr> r) { return !(l == r); }
inline bool operator ==(cWinHandle<nullptr> l, HANDLE r) { return l == cWinHandle<nullptr>(r); }
inline bool operator !=(cWinHandle<nullptr> l, HANDLE r) { return !(l == r); }
inline bool operator ==(HANDLE l, cWinHandle<INVALID_HANDLE_VALUE> r) { return cWinHandle<INVALID_HANDLE_VALUE>(l) == r; }
inline bool operator !=(HANDLE l, cWinHandle<INVALID_HANDLE_VALUE> r) { return !(l == r); }
inline bool operator ==(cWinHandle<INVALID_HANDLE_VALUE> l, HANDLE r) { return l == cWinHandle<INVALID_HANDLE_VALUE>(r); }
inline bool operator !=(cWinHandle<INVALID_HANDLE_VALUE> l, HANDLE r) { return !(l == r); }

对Windows HANDLE使用std :: unique_ptr

7 个答案: