6

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

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是为了关闭手柄。我想知道关闭手柄的正确方法。删除指针也会出现类似的情况。

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。问题是关闭句柄的正确方法是什么？我的意思是，如何避免重复关闭句柄问题？

4

5 回答 5

13

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

HBITMAP从不使用INVALID_HANDLE_VALUE，它总是使用NULL。你永远不应该要求DeleteObject()一个HBITMAP你不拥有的东西。

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

如果您希望手柄自行管理，那么 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(...));

等等。

于 2012-10-25T00:29:46.947 回答
3

使用RAII 模式。

将句柄包装到一个类中，该类在构造函数中分配句柄并在析构函数中销毁它。您可以在 MFC 中找到一些示例，例如用于 GDI 对象的CGdiObject 类HBITMAP，例如.

另请参阅这个 SO 问题：RAII and smart pointers in C++

于 2012-10-23T11:36:44.500 回答
2

是的。

我认为您的困惑来自于它们都被称为“句柄”，但它们是不同的“类”对象。术语句柄在HBITMAP这里更多地用作“不透明的标识符”。还有大量文档假定“句柄”==“Windows 内核句柄”。

一般来说，如果您想知道如何删除某些内容，您应该查看构造函数的文档。

于 2012-10-23T11:04:26.830 回答
1

以下代码可能是您所追求的：

BOOL CloseValidHandle(HANDLE& handle)
{
  if (handle != INVALID_HANDLE_VALUE && handle != 0)
  {
    if (CloseHandle(handle))
    {
      handle = INVALID_HANDLE_VALUE;
      return TRUE;
    }
    else
    {
      return FALSE;
    }
  }

  return TRUE;
}
于 2012-10-23T11:42:49.667 回答
0

它不是 RAII，但它有助于删除/关闭处理程序。

class HandleDel : boost::notcopyable{
public:
    HandleDel(HANDLE h, HANDLE invalid, BOOL(WINAPI *del)(HANDLE)):
        h(h), invalid(invalid), del(del){
    }
    ~HandleDel(){
        if ( h != invalid ) del(h);
    }
private:
    HANDLE h;
    HANDLE invalid;
    BOOL(WINAPI *del)(HANDLE);
};
于 2015-10-30T07:32:07.303 回答