std::unique_ptr, deleters and the Win32 API

by

Forget about the custom deleter for now. When you say std::unique_ptr<T>, the unique_ptr constructor expects to receive a T*, but CreateMutex returns a HANDLE, not a HANDLE *.

There are 3 ways to fix this:

std::unique_ptr<void, deleter> m_mutex;

You’ll have to cast the return value of CreateMutex to a void *.

Another way to do this is use std::remove_pointer to get to the HANDLE‘s underlying type.

std::unique_ptr<std::remove_pointer<HANDLE>::type, deleter> m_mutex;

Yet another way to do this is to exploit the fact that if the unique_ptr‘s deleter contains a nested type named pointer, then the unique_ptr will use that type for its managed object pointer instead of T*.

struct mutex_deleter {
  void operator()( HANDLE h ) 
  {
    ::CloseHandle( h );
  }
  typedef HANDLE pointer;
};
std::unique_ptr<HANDLE, mutex_deleter> m_mutex;
foo() : m_mutex(::CreateMutex(NULL, FALSE, NULL), mutex_deleter()) {}

Now, if you want to pass a pointer to function type as the deleter, then when dealing with the Windows API you also need to pay attention to the calling convention when creating function pointers.

So, a function pointer to CloseHandle must look like this

BOOL(WINAPI *)(HANDLE)

Combining all of it,

std::unique_ptr<std::remove_pointer<HANDLE>::type, 
                BOOL(WINAPI *)(HANDLE)> m_mutex(::CreateMutex(NULL, FALSE, NULL),
                                                &::CloseHandle);

I find it easier to use a lambda instead

std::unique_ptr<std::remove_pointer<HANDLE>::type, 
                void(*)( HANDLE )> m_mutex;
foo() : m_mutex(::CreateMutex(NULL, FALSE, NULL), 
                []( HANDLE h ) { ::CloseHandle( h ); }) {}

Or as suggested by @hjmd in the comments, use decltype to deduce the type of the function pointer.

std::unique_ptr<std::remove_pointer<HANDLE>::type, 
                decltype(&::CloseHandle)> m_mutex(::CreateMutex(NULL, FALSE, NULL),
                                                  &::CloseHandle);

More Related Contents:

  1. Is std::unique_ptr required to know the full definition of T?
  2. Why can I not push_back a unique_ptr into a vector?
  3. make_unique and perfect forwarding
  4. Returning unique_ptr from functions
  5. How do I pass a unique_ptr argument to a constructor or a function?
  6. Differences between std::make_unique and std::unique_ptr with new
  7. How do I use a custom deleter with a std::unique_ptr member?
  8. Differences between unique_ptr and shared_ptr [duplicate]
  9. Is there any use for unique_ptr with array?
  10. How to capture a unique_ptr into a lambda expression?
  11. “Downcasting” unique_ptr to unique_ptr
  12. Copy constructor for a class with unique_ptr
  13. How to implement make_unique function in C++11? [duplicate]
  14. How do I use unique_ptr for pimpl?
  15. So can unique_ptr be used safely in stl collections?
  16. Exception safety and make_unique
  17. std::auto_ptr to std::unique_ptr
  18. How does the custom deleter of std::unique_ptr work?
  19. How can I pass std::unique_ptr into a function
  20. Should I use shared_ptr or unique_ptr
  21. error::make_unique is not a member of ‘std’
  22. shared_ptr is to weak_ptr as unique_ptr is to… what?
  23. Raw pointer lookup for sets of unique_ptrs
  24. unique_ptr and OpenSSL’s STACK_OF(X509)*
  25. How can I compile C++11 code with Orwell Dev-C++?
  26. Why does unique_ptr take two template parameters when shared_ptr only takes one?
  27. Should std::unique_ptr be permitted
  28. Is there a way to write make_unique() in VS2012?
  29. Does std::bind work with move-only types in general, and std::unique_ptr in particular?
  30. Does C++11 unique_ptr and shared_ptr able to convert to each other’s type?

Leave a Comment