¿Cómo utilizar los punteros inteligentes estándar de C++ con Windows HANDLEs?

Question

Me preguntaba si hay una forma de usar unique_ptr<T> con Windows HANDLEs?

Estaba pensando en reemplazar el std::default_delete con handle_trats que llama al CloseHandle. El problema es que HANDLE se define como void*unique_ptr<void> no se compilará ya que sizeof(void) no está definido.

Hasta ahora sólo veo dos posibilidades:

1. crear una clase contenedora para las manijas y utilizar de esta manera: unique_ptr<new CHandle(h)>. Esto hace que el unique_ptr<T> sea inútil.
2. Utilice HANDLE clase específica de puntero inteligente que se asemeje a unique_ptr<T>.

¿Cuál cree que es la mejor opción? ¿Qué sugieres?

La pregunta se puede ampliar para COM IUnknown punteros - ¿puede reemplazarse CComPtr por alguno de los punteros inteligentes estándar?

Answer 1

La pregunta puede ser extendido para COM IUn punteros conocidos: ¿se puede reemplazar CComPtr por alguno de los punteros inteligentes estándar?

Sí. No se especializa en std::default_deleter, simplemente reemplace el tipo de eliminador.

struct COMDeleter { 
    template<typename T> void operator()(T* ptr) { 
     ptr->Release(); 
    } 
}; 
unique_ptr<IUnknown, COMDeleter> ptr; // Works fine 

El mismo principio se aplica a shared_ptr y, de hecho, a HANDLE.

Answer 2

Crear una clase de puntero inteligente específica, no llevará mucho tiempo. No abuse de las clases de la biblioteca. La semántica de Handle es bastante diferente de la de un puntero de C++; por un lado, quitarle una referencia a HANDLE no tiene sentido.

Una razón más para usar una clase de controlador inteligente personalizada: NULL no siempre significa un identificador vacío. A veces es INVALID_HANDLE_VALUE, que no es lo mismo (en realidad -1).

Answer 3

Debe usar CloseHandle() para "cerrar" una manija en su lugar usando delete. Ellos serán eliminados por Windows tan pronto como no se abran en otro lugar. Por lo tanto, podría escribir un contenedor que llame a CloseHandle() en lugar de eliminarlo. También podría escribir su propia clase de smartpointer, que podría ser mejor, ya que no hay necesidad de un contenedor.

Answer 4

Puede crear una clase Deleter que liberará el identificador en lugar de llamar a delete().

Se puede ver en este LINK forma en que han resuelto matrices eliminando con un shared_ptr (unique_ptr también tiene un constructor que recieves una clase Delete)

struct handle_deleter 
    { 
    void operator()(HANDLE handle) 
     { CloseHandle(p); } 
    }; 

    HANDLE blah = GetSomeHandle(); 
    unique_ptr myPointer(blah,handle_deleter); 

Answer 5

Puede typedef su unique_ptr con un Deleter encargo

struct handle_deleter 
{ 
    void operator()(void* handle) 
    { 
     if(handle != nullptr) 
      CloseHandle(handle); 
    } 
}; 

typedef std::unique_ptr<void, handle_deleter> UniqueHandle_t; 
UniqueHandle_t ptr(CreateFile(...)); 

Answer 6

No recomiendo el uso de punteros inteligentes con asas.

Le recomiendo que eche un vistazo a A Proposal to Add additional RAII Wrappers to the Standard Library y al the drawbacks of using smart pointers with handles.

Personalmente, estoy haciendo uso de la implementación de referencia de esa propuesta en lugar de usar std::unique_ptr para estas situaciones.

Answer 7

otra solución

std::unique_ptr< void, void(*)(HANDLE) > uniqueHandle(file, [](HANDLE h) { ::CloseHandle(h); }); 

Answer 8

inspirado en la solución de Alexander Drichel, aquí es aún más corto

std::unique_ptr< HANDLE, decltype(&CloseHandle) > uniqueHandle(nullptr, CloseHandle); 

Obras en MSVC 2010. Tenga en cuenta que es necesario especificar '&' para el nombre de función en decltype() para deducir un tipo de puntero a función.

Answer 9

A HANDLE no siempre se cierra con CloseHandle(), tenga cuidado. Por ejemplo, un identificador abierto con FindNextFile() debe ser cerrado por FindClose().