Come posso utilizzare un deleter personalizzato con un membro std :: unique_ptr?

Ho una lezione con un membro unique_ptr.

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

La barra è una classe di terze parti che ha una funzione create () e una funzione destroy ().

Se volessi usare a std::unique_ptrcon esso in una funzione autonoma, potrei fare:

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

C'è un modo per farlo con std::unique_ptrcome membro di una classe?

Supponendo che createe destroysiano funzioni gratuite (che sembra essere il caso dello snippet di codice del PO) con le seguenti firme:

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

Puoi scrivere la tua lezione in Fooquesto modo

class Foo {

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

    // ...

public:

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

    // ...
};

Si noti che non è necessario scrivere lambda o deleter personalizzato qui perché destroyè già un deleter.

È possibile farlo in modo pulito usando un lambda in C ++ 11 (testato in G ++ 4.8.2).

Dato questo riutilizzabile typedef:

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

Tu puoi scrivere:

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

Ad esempio, con a FILE* :

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

Con questo si ottengono i vantaggi di una pulizia sicura delle eccezioni utilizzando RAII, senza bisogno di provare / catturare il rumore.

Devi solo creare una classe deleter:

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

e forniscilo come argomento modello di unique_ptr. Dovrai comunque inizializzare unique_ptr nei tuoi costruttori:

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

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

Per quanto ne so, tutte le librerie c ++ popolari implementano questo correttamente; poiché in BarDeleter realtà non ha alcuno stato, non ha bisogno di occupare spazio nel unique_ptr.

A meno che non sia necessario poter modificare il deleter in fase di esecuzione, consiglio vivamente di utilizzare un tipo di deleter personalizzato. Ad esempio, se utilizzare un puntatore a funzione per la vostra deleter, sizeof(unique_ptr<T, fptr>) == 2 * sizeof(T*). In altre parole, la metà dei byte unique_ptrdell'oggetto viene sprecata.

Scrivere un deleter personalizzato per avvolgere ogni funzione è comunque un problema. Per fortuna, possiamo scrivere un tipo basato sulla funzione:

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

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

Sai, utilizzare un deleter personalizzato non è il modo migliore per andare, poiché dovrai menzionarlo in tutto il codice.
Invece, poiché ti è permesso aggiungere specializzazioni alle classi a livello di spazio dei nomi ::stdfintanto che sono coinvolti tipi personalizzati e rispetti la semantica, procedi come segue:

Specializzare 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 forse anche fare 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 };
}

Puoi semplicemente usare std::bindcon una tua funzione di distruzione.

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

Ma ovviamente puoi anche usare una lambda.

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