¿Cómo uso un eliminador personalizado con un miembro std :: unique_ptr?

Tengo una clase con un miembro unique_ptr.

class Foo {
private:
    std::unique_ptr<Bar> bar;
    ...
};

The Bar es una clase de terceros que tiene una función create () y una función destroy ().

Si quisiera usar un std::unique_ptrcon él en una función independiente, podría hacer:

void foo() {
    std::unique_ptr<Bar, void(*)(Bar*)> bar(create(), [](Bar* b){ destroy(b); });
    ...
}

¿Hay alguna manera de hacer esto std::unique_ptrcomo miembro de una clase?

Asumiendo eso createy destroyson funciones libres (que parece ser el caso del fragmento de código del OP) con las siguientes firmas:

Bar* create();
void destroy(Bar*);

Puedes escribir tu clase Fooasí

class Foo {

    std::unique_ptr<Bar, void(*)(Bar*)> ptr_;

    // ...

public:

    Foo() : ptr_(create(), destroy) { /* ... */ }

    // ...
};

Tenga en cuenta que no necesita escribir ningún borrador lambda o personalizado aquí porque destroyya es un borrador.

Es posible hacer esto limpiamente usando un lambda en C ++ 11 (probado en G ++ 4.8.2).

Dado esto reutilizable typedef:

template<typename T>
using deleted_unique_ptr = std::unique_ptr<T,std::function<void(T*)>>;

Puedes escribir:

deleted_unique_ptr<Foo> foo(new Foo(), [](Foo* f) { customdeleter(f); });

Por ejemplo, con un FILE*:

deleted_unique_ptr<FILE> file(
    fopen("file.txt", "r"),
    [](FILE* f) { fclose(f); });

Con esto, obtiene los beneficios de una limpieza segura con excepción utilizando RAII, sin necesidad de intentar / detectar ruido.

Solo necesita crear una clase de eliminación:

struct BarDeleter {
  void operator()(Bar* b) { destroy(b); }
};

y proporcionarlo como argumento de plantilla de unique_ptr. Aún tendrá que inicializar el unique_ptr en sus constructores:

class Foo {
  public:
    Foo() : bar(create()), ... { ... }

  private:
    std::unique_ptr<Bar, BarDeleter> bar;
    ...
};

Hasta donde yo sé, todas las bibliotecas populares de c ++ implementan esto correctamente; dado BarDeleter que en realidad no tiene ningún estado, no necesita ocupar ningún espacio en el unique_ptr.

A menos que necesite poder cambiar el eliminador en tiempo de ejecución, le recomiendo utilizar un tipo de eliminador personalizado. Por ejemplo, si utiliza un puntero de función para su Deleter, sizeof(unique_ptr<T, fptr>) == 2 * sizeof(T*). En otras palabras, la mitad de los bytes del unique_ptrobjeto se desperdician.

Sin embargo, escribir un eliminador personalizado para ajustar cada función es una molestia. Afortunadamente, podemos escribir un tipo con plantilla en la función:

Desde C ++ 17:

template <auto fn>
using deleter_from_fn = std::integral_constant<decltype(fn), fn>;

template <typename T, auto fn>
using my_unique_ptr = std::unique_ptr<T, deleter_from_fn<fn>>;

// usage:
my_unique_ptr<Bar, destroy> p{create()};

Antes de C ++ 17:

template <typename D, D fn>
using deleter_from_fn = std::integral_constant<D, fn>;

template <typename T, typename D, D fn>
using my_unique_ptr = std::unique_ptr<T, deleter_from_fn<D, fn>>;

// usage:
my_unique_ptr<Bar, decltype(destroy), destroy> p{create()};

Simplemente puede usar std::bindcon una función de destrucción.

std::unique_ptr<Bar, std::function<void(Bar*)>> bar(create(), std::bind(&destroy,
    std::placeholders::_1));

Pero, por supuesto, también puedes usar una lambda.

std::unique_ptr<Bar, std::function<void(Bar*)>> ptr(create(), [](Bar* b){ destroy(b);});

Ya sabes, usar un eliminador personalizado no es la mejor manera de hacerlo, ya que tendrás que mencionarlo en todo tu código.
En cambio, como puede agregar especializaciones a las clases de nivel de espacio de nombres ::stdsiempre que estén involucrados tipos personalizados y respete la semántica, haga lo siguiente:

especializarse std::default_delete:

template <>
struct ::std::default_delete<Bar> {
    default_delete() = default;
    template <class U, class = std::enable_if_t<std::is_convertible<U*, Bar*>()>>
    constexpr default_delete(default_delete<U>) noexcept {}
    void operator()(Bar* p) const noexcept { destroy(p); }
};

Y tal vez también lo haga std::make_unique():

template <>
inline ::std::unique_ptr<Bar> ::std::make_unique<Bar>() {
    auto p = create();
    if (!p) throw std::runtime_error("Could not `create()` a new `Bar`.");
    return { p };
}