Wie benutze ich einen benutzerdefinierten Deleter mit einem std :: unique_ptr Mitglied?

Question

Ich habe eine Klasse mit einem unique_ptr Mitglied.

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

Der Balken ist eine Klasse von Drittanbietern, die über eine create() -Funktion und eine destroy() -Funktion verfügt.

Wenn ich ein std::unique_ptr mit ihm in einer Stand-alone-Funktion nutzen wollte ich tun konnte:

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

Gibt es eine Möglichkeit, dies als Mitglied einer Klasse mit std::unique_ptr zu tun?

Answer 1

Unter der Annahme, dass create und destroy sind frei Funktionen mit den folgenden Signaturen (was der Fall aus dem OP des Code-Schnipsel zu sein scheint):

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

Sie Ihre Klasse Foo wie diese

class Foo { 

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

    // ... 

public: 

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

    // ... 
}; 

schreiben

Beachten Sie, dass Sie hier keinen Lambda oder benutzerdefinierten Deleter schreiben müssen, da destroy bereits ein Deleter ist.

Answer 2

Sie können einfach std::bind mit einer Ihre zerstören Funktion verwenden.

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

Aber natürlich können Sie auch eine Lambda verwenden.

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

Answer 3

Sie brauchen nur eine deleter Klasse zu erstellen:

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

und bieten es als Template-Argument von unique_ptr. Sie werden immer noch die unique_ptr in Ihrer Konstruktoren müssen:

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

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

Soweit ich weiß, alle populären C++ Bibliotheken implementieren diese korrekt; seit BarDeleter hat eigentlich keinen Zustand, es braucht keinen Platz in der unique_ptr belegen.

Answer 4

Es ist möglich, dies sauber mit einem Lambda in C++ 11 (getestet in G ++ 4.8.2) zu tun.

Angesichts dieser wieder verwendbaren typedef:

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

Sie schreiben:

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

---

Zum Beispiel mit einem FILE*:

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

Damit Sie erhalten die Vorteile der Ausnahme-sichere Reinigung mit RAII, ohne Versuch/catch-Lärm.