Bagaimana cara menggunakan deleter khusus dengan anggota std :: unique_ptr?

Saya memiliki kelas dengan anggota unique_ptr.

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

Bilah adalah kelas pihak ketiga yang memiliki fungsi create () dan fungsi destroy ().

Jika saya ingin menggunakan std::unique_ptrdengan itu dalam fungsi yang berdiri sendiri yang bisa saya lakukan:

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

Apakah ada cara untuk melakukan ini dengan std::unique_ptrsebagai anggota kelas?

Dengan asumsi itu createdan destroymerupakan fungsi bebas (yang tampaknya merupakan kasus dari cuplikan kode OP) dengan tanda tangan berikut:

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

Anda dapat menulis kelas Fooseperti ini

class Foo {

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

    // ...

public:

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

    // ...
};

Perhatikan bahwa Anda tidak perlu menulis lambda atau custom deleter di sini karena destroysudah menjadi deleter.

Dimungkinkan untuk melakukan ini dengan bersih menggunakan lambda di C ++ 11 (diuji dalam G ++ 4.8.2).

Mengingat ini dapat digunakan kembali typedef:

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

Kamu bisa menulis:

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

Misalnya, dengan FILE*:

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

Dengan ini Anda mendapatkan manfaat pembersihan dengan pengecualian-aman menggunakan RAII, tanpa perlu mencoba / menangkap kebisingan.

Anda hanya perlu membuat kelas deleter:

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

dan berikan sebagai argumen templat dari unique_ptr. Anda masih harus menginisialisasi unique_ptr di konstruktor Anda:

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

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

Sejauh yang saya tahu, semua pustaka c ++ populer mengimplementasikan ini dengan benar; Karena BarDeleter tidak benar - benar memiliki keadaan apa pun, tidak perlu menempati ruang apa pun di Internet unique_ptr.

Kecuali Anda harus dapat mengubah deleter saat runtime, saya akan sangat menyarankan menggunakan tipe deleter khusus. Misalnya, jika menggunakan pointer fungsi untuk deleter Anda sizeof(unique_ptr<T, fptr>) == 2 * sizeof(T*),. Dengan kata lain, setengah dari byte unique_ptrobjek terbuang sia-sia.

Menulis custom deleter untuk membungkus setiap fungsi memang merepotkan. Untungnya, kita dapat menulis sebuah tipe yang ditempel pada fungsi:

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

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

Anda cukup menggunakan std::binddengan fungsi penghancuran Anda.

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

Tapi tentu saja Anda juga bisa menggunakan lambda.

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

Anda tahu, menggunakan custom deleter bukanlah cara terbaik, karena Anda harus menyebutkannya di seluruh kode Anda.
Alih-alih, karena Anda diizinkan untuk menambahkan spesialisasi ke kelas tingkat namespace ::stdselama jenis kustom terlibat dan Anda menghormati semantik, lakukan itu:

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

Dan mungkin juga melakukan 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 };
}