c++ - 正确关闭 WinAPI HANDLEs(避免重复关闭)

Question

我有一些句柄，我需要关闭它。代码中有些地方可能会关闭句柄。那么，这是关闭句柄的正确方法吗？

HANDLE h;
....
if ( h != INVALID_HANDLE_VALUE ) {
  ::CloseHandle(h);
  h = INVALID_HANDLE_VALUE;
}

关于位图句柄也有同样的问题:

HBITMAP hb;
....
if ( hb != INVALID_HANDLE_VALUE ) {
  ::DeleteObject(hb);
  hb = INVALID_HANDLE_VALUE;
}

编辑: 我认为存在一些误解。我知道 CloseHandle 用于关闭句柄。我想知道关闭 Handlebars 的正确方法。删除指针时会发生类似的情况。

Foo *foo = new Foo();

// for example there is 2 functions that can delete foo
void bar() {
  ....
  delete foo;
}
void duck() {
  ....
  delete foo;
}

所以，下面的代码意味着问题:

bar();
duck();

这种情况有一些解决方法。我们需要像这样定义 bar&duck 函数:

void bar() {
  ....
  if (foo) {
    delete foo;
    foo = NULL;
  }
}
void duck() {
  ....
  if (foo) {
    delete foo;
    foo = NULL;
  }
}

所以我们避免重复删除foo。问题是关闭句柄的正确方法是什么？我的意思是，如何避免重复关闭句柄问题？

Answer 1

并非所有使用HANDLE 的函数都使用CloseHandle()，有些函数使用其他关闭函数。此外，并非所有 HANDLE 值都使用 INVALID_HANDLE_VALUE。有些人使用 NULL 代替。

HBITMAP 从不使用 INVALID_HANDLE_VALUE，它总是使用 NULL。并且您永远不应该为您不拥有的 HBITMAP 调用 DeleteObject()。

所以简短的回答是 - 如果您正在尝试创建一些通用的句柄管理，请不要打扰。你很可能弄错了。如果你分配/打开一些句柄，你必须知道关闭它的正确方法，你不能猜测它。

如果你想让句柄自己管理，那么RAII是最好的选择。我更喜欢使用具有特殊特征的模板化类来减少不同类型句柄的代码重复，例如:

template< class traits >
class HandleWrapper
{
private:
    traits::HandleType FHandle;

public:
    HandleWrapper()
        FHandle(traits::InvalidValue)
    {
    }

    HandleWrapper(const traits::HandleType value)
        FHandle(value)
    {
    }

    ~HandleWrapper()
    {
        Close();
    }

    void Close()
    {
        if (FHandle != traits::InvalidValue)
        {
            traits::Close(FHandle);
            FHandle = traits::InvalidValue;
        }
    }

    bool operator !() const {
        return (FHandle == traits:::InvalidValue);
    }

    operator bool() const {
        return (FHandle != traits:::InvalidValue);
    }

    operator traits::HandleType() {
        return FHandle;
    }
};

.

struct KernelHandleTraits
{
    typedef HANDLE HandleType;
    static const HANDLE InvalidValue = INVALID_HANDLE_VALUE;

    static void Close(HANDLE value)
    {
        CloseHandle(value);
    }
};

HandleWrapper<KernelHandleTraits> hFile(CreateFile(...));

.

struct NullKernelHandleTraits
{
    typedef HANDLE HandleType;
    static const HANDLE InvalidValue = NULL;

    static void Close(HANDLE value)
    {
        CloseHandle(value);
    }
};

HandleWrapper<NullKernelHandleTraits> hMapping(CreateFileMapping(...));

.

struct FileMapViewTraits
{    
    typedef void* HandleType;
    static const void* InvalidValue = NULL;

    static void Close(void *value)
    {
        UnmapViewOfFile(value);
    }
};

HandleWrapper<FileMapViewTraits> hView(MapViewOfFile(...));

.

struct GDIBitmapHandleTraits
{    
    typedef HBITMAP HandleType;
    static const HBITMAP InvalidValue = NULL;

    static void Close(HBITMAP value)
    {
        DeleteObject(value);
    }
};

HandleWrapper<GDIBitmapTraits> hBmp(CreateBitmap(...));

等等