Comment utiliser un suppresseur personnalisé avec un membre std :: unique_ptr?

J'ai une classe avec un membre unique_ptr.

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

La barre est une classe tierce qui a une fonction create () et une fonction destroy ().

Si je voulais utiliser un std::unique_ptravec lui dans une fonction autonome, je pourrais faire:

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

Existe-t-il un moyen de faire cela en std::unique_ptrtant que membre d'une classe?

En supposant que createet destroysont des fonctions gratuites (ce qui semble être le cas de l'extrait de code de l'OP) avec les signatures suivantes:

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

Tu peux écrire ta classe Foocomme ça

class Foo {

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

    // ...

public:

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

    // ...
};

Notez que vous n'avez pas besoin d'écrire de lambda ou de suppresseur personnalisé ici car il destroys'agit déjà d'un deleter.

Il est possible de le faire proprement en utilisant un lambda en C ++ 11 (testé dans G ++ 4.8.2).

Compte tenu de ce réutilisable typedef:

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

Tu peux écrire:

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

Par exemple, avec un FILE*:

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

Avec cela, vous bénéficiez des avantages d'un nettoyage sans risque d'exception à l'aide de RAII, sans avoir besoin de bruit d'essai / capture.

Il vous suffit de créer une classe de suppression:

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

et fournissez-le comme argument modèle de unique_ptr. Vous devrez toujours initialiser le unique_ptr dans vos constructeurs:

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

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

Autant que je sache, toutes les bibliothèques c ++ populaires implémentent cela correctement; comme BarDeleter n'a en fait aucun état, il n'a pas besoin d'occuper d'espace dans le fichier unique_ptr.

À moins que vous n'ayez besoin de pouvoir modifier le suppresseur au moment de l'exécution, je vous recommande vivement d'utiliser un type de suppression personnalisé. Par exemple, si l'on utilise un pointeur de fonction pour votre Deleter, sizeof(unique_ptr<T, fptr>) == 2 * sizeof(T*). En d'autres termes, la moitié des octets de l' unique_ptrobjet sont gaspillés.

Cependant, écrire un suppresseur personnalisé pour envelopper chaque fonction est un problème. Heureusement, nous pouvons écrire un type basé sur la fonction:

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

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

Vous savez, utiliser un suppresseur personnalisé n'est pas la meilleure façon de procéder, car vous devrez le mentionner partout dans votre code.
Au lieu de cela, comme vous êtes autorisé à ajouter des spécialisations aux classes au niveau de l'espace de noms ::stdtant que des types personnalisés sont impliqués et que vous respectez la sémantique, procédez comme suit :

Spécialisez 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); }
};

Et peut-être aussi faire 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 };
}

Vous pouvez simplement utiliser std::bindavec une fonction de destruction.

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

Mais bien sûr, vous pouvez également utiliser un lambda.

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