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

Question

Ho una classe 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 un std::unique_ptr con esso in una funzione stand-alone ho potuto fare:

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

C'è un modo per fare questo con std::unique_ptr come membro di una classe?

Answer 1

Supponendo che create e destroy sono funzioni libere (che sembra essere il caso dal frammento di codice del PO) con le seguenti firme:

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

è possibile scrivere la classe Foo come questo

class Foo { 

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

    // ... 

public: 

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

    // ... 
}; 

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

Answer 2

È possibile utilizzare semplicemente std::bind con una funzione di eliminazione.

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

Ma ovviamente è anche possibile utilizzare un lambda.

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

Answer 3

Hai solo bisogno di creare una classe di delezione:

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

e fornirlo come argomento modello di unique_ptr. Avrai ancora per inizializzare l'unique_ptr nei tuoi costruttori:

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

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

Per quanto ne so, tutti i popolari librerie C++ implementano questa correttamente; poiché lo BarDeleter non ha alcun stato, non è necessario occupare spazio nello unique_ptr.

Answer 4

È possibile farlo in modo pulito utilizzando 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*)>>; 

si può scrivere:

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

---

Ad esempio, con un FILE*:

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

Con questo si ottiene la vantaggi di una pulizia eccezionalmente sicura usando RAII, senza bisogno di provare/catturare il rumore.