std :: unique_ptrメンバーでカスタム削除機能を使用するにはどうすればよいですか？

unique_ptrメンバーを持つクラスがあります。

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

Barは、create（）関数とdestroy（）関数を持つサードパーティのクラスです。

std::unique_ptrスタンドアロン関数でwith it を使用したい場合、次のことができます。

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

std::unique_ptrクラスのメンバーとしてこれを行う方法はありますか？

次のシグネチャを持つ、無料の関数（OPのコードスニペットの場合と思われる）であるcreateと仮定しdestroyます。

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

あなたはFooこのようにあなたのクラスを書くことができます

class Foo {

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

    // ...

public:

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

    // ...
};

destroyはすでに削除者であるため、ラムダやカスタムの削除者をここで記述する必要はありません。

C ++ 11（G ++ 4.8.2でテスト済み）でラムダを使用してこれをきれいに行うことができます。

この再利用可能な場合typedef：

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

あなたは書ける：

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

たとえば、とFILE*：

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

これにより、トライ/キャッチノイズを必要とせずに、RAIIを使用した例外セーフクリーンアップの利点が得られます。

削除クラスを作成するだけです：

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

のテンプレート引数として提供しますunique_ptr。それでも、コンストラクターでunique_ptrを初期化する必要があります。

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

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

私の知る限り、人気のあるすべてのc ++ライブラリがこれを正しく実装しています。にBarDeleter は実際には状態がないため、内のスペースを占有する必要はありませんunique_ptr。

実行時に削除を変更できるようにする必要がない限り、カスタムの削除タイプを使用することを強くお勧めします。たとえば、あなたのデリータの関数ポインタを使用している場合、sizeof(unique_ptr<T, fptr>) == 2 * sizeof(T*)。つまり、unique_ptrオブジェクトのバイトの半分が無駄になります。

ただし、すべての関数をラップするカスタム削除機能を作成するのは面倒です。ありがたいことに、関数にテンプレート化された型を書くことができます：

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

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

単にstd::binddestroy関数で使用できます。

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

もちろん、ラムダを使用することもできます。

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

コード全体で言及する必要があるため、カスタムの削除機能を使用するのは最善の方法ではありません。
代わりに、カスタムタイプが関係し、セマンティクスを尊重している限り、名前空間レベルのクラスに特殊化を追加することが許可されているため::std、次のようにします。

専門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); }
};

そして多分またします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 };
}