Como uso um deleter personalizado com um membro std :: unique_ptr?

Eu tenho uma classe com um membro unique_ptr.

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

A barra é uma classe de terceiros que possui uma função create () e uma função destroy ().

Se eu quisesse usar um std::unique_ptrcom ele em uma função autônoma, eu poderia fazer:

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

Existe uma maneira de fazer isso std::unique_ptrcomo membro de uma classe?

Supondo que createe destroysejam funções livres (o que parece ser o caso do snippet de código do OP) com as seguintes assinaturas:

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

Você pode escrever sua turma Fooassim

class Foo {

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

    // ...

public:

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

    // ...
};

Observe que você não precisa escrever nenhum deleter lambda ou personalizado aqui, porque ele destroyjá é um deleter.

É possível fazer isso corretamente usando um lambda no C ++ 11 (testado no G ++ 4.8.2).

Dado este reutilizável typedef:

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

Você pode escrever:

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

Por exemplo, com um FILE*:

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

Com isso, você obtém os benefícios da limpeza com exceção de segurança usando RAII, sem a necessidade de tentar / capturar ruído.

Você só precisa criar uma classe deleter:

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

e forneça-o como o argumento do modelo de unique_ptr. Você ainda precisará inicializar o unique_ptr em seus construtores:

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

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

Até onde eu sei, todas as bibliotecas populares do c ++ implementam isso corretamente; como BarDeleter na verdade não tem nenhum estado, não precisa ocupar nenhum espaço no unique_ptr.

A menos que você precise alterar o deleter em tempo de execução, recomendo fortemente o uso de um tipo personalizado. Por exemplo, se você usar um ponteiro de função para seu deleter sizeof(unique_ptr<T, fptr>) == 2 * sizeof(T*),. Em outras palavras, metade dos bytes do unique_ptrobjeto são desperdiçados.

Escrever um deleter personalizado para agrupar todas as funções é um problema. Felizmente, podemos escrever um tipo de modelo na função:

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 do 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()};

Você pode simplesmente usar std::binduma função de destruição.

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

Mas é claro que você também pode usar um lambda.

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

Você sabe, usar um deleter personalizado não é o melhor caminho a percorrer, pois você precisará mencioná-lo em todo o seu código.
Em vez disso, como você pode adicionar especializações a classes no nível de namespace no::std , desde que tipos personalizados estejam envolvidos e você respeite a semântica, faça o seguinte:

Especializar 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); }
};

E talvez também faça 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 };
}