Wie verwende ich einen benutzerdefinierten Löscher mit einem std :: unique_ptr-Mitglied?

Ich habe eine Klasse mit einem unique_ptr-Mitglied.

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

Die Leiste ist eine Klasse von Drittanbietern mit einer Funktion create () und einer Funktion destroy ().

Wenn ich a std::unique_ptrdamit in einer eigenständigen Funktion verwenden wollte, könnte ich Folgendes tun:

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

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

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

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

Sie können Ihre Klasse Fooso schreiben

class Foo {

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

    // ...

public:

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

    // ...
};

Beachten Sie, dass Sie hier kein Lambda oder benutzerdefiniertes Deleter schreiben müssen, da destroyes sich bereits um ein Deleter handelt.

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

Angesichts dieser wiederverwendbaren typedef:

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

Du kannst 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 erhalten Sie die Vorteile einer ausnahmesicheren Bereinigung mit RAII, ohne dass Try / Catch-Rauschen erforderlich ist.

Sie müssen nur eine Deleter-Klasse erstellen:

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

und geben Sie es als Vorlagenargument von an unique_ptr. Sie müssen das unique_ptr in Ihren Konstruktoren noch initialisieren:

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

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

Soweit ich weiß, implementieren alle gängigen C ++ - Bibliotheken dies korrekt. da BarDeleter es eigentlich keinen zustand hat, muss es keinen platz in der besetzen unique_ptr.

Sofern Sie nicht in der Lage sein müssen, den Löscher zur Laufzeit zu ändern, würde ich dringend empfehlen, einen benutzerdefinierten Löschertyp zu verwenden. Wenn Sie beispielsweise einen Funktionszeiger für Ihren Deleter verwenden , sizeof(unique_ptr<T, fptr>) == 2 * sizeof(T*). Mit anderen Worten, die Hälfte der Bytes des unique_ptrObjekts wird verschwendet.

Das Schreiben eines benutzerdefinierten Löschers zum Umschließen jeder Funktion ist jedoch problematisch. Zum Glück können wir einen Typ schreiben, der für die Funktion vorgesehen ist:

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

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

Sie können einfach std::bindmit Ihrer Zerstörungsfunktion verwenden.

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

Natürlich können Sie auch ein Lambda verwenden.

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

Sie wissen, dass die Verwendung eines benutzerdefinierten Löschers nicht der beste Weg ist, da Sie ihn in Ihrem gesamten Code erwähnen müssen.
Stattdessen können Sie Spezialisierungen zu Klassen auf Namespace-Ebene in hinzufügen::std solange benutzerdefinierte Typen beteiligt sind und Sie die Semantik respektieren, gehen Sie folgendermaßen vor:

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

Und vielleicht auch 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 };
}