ฉันจะใช้ deleter ที่กำหนดเองกับสมาชิก std :: unique_ptr ได้อย่างไร

ฉันมีชั้นเรียนที่มีสมาชิก unique_ptr

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

Bar เป็นคลาสของบุคคลที่สามที่มีฟังก์ชัน create () และฟังก์ชัน destroy ()

หากฉันต้องการใช้ a std::unique_ptrร่วมกับมันในฟังก์ชันสแตนด์อโลนฉันสามารถทำได้:

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

มีวิธีดำเนินการในstd::unique_ptrฐานะสมาชิกของชั้นเรียนหรือไม่?

สมมติว่าcreateและdestroyเป็นฟังก์ชันฟรี (ซึ่งดูเหมือนจะเป็นเช่นนั้นจากข้อมูลโค้ดของ OP) พร้อมลายเซ็นต่อไปนี้:

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

คุณสามารถเขียนชั้นเรียนของคุณFooแบบนี้

class Foo {

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

    // ...

public:

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

    // ...
};

สังเกตว่าคุณไม่จำเป็นต้องเขียน lambda หรือ custom deleter ใด ๆ ที่นี่เพราะdestroyเป็น deleter อยู่แล้ว

สามารถทำได้อย่างหมดจดโดยใช้แลมด้าใน 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 โดยไม่ต้องลอง / จับเสียง

คุณเพียงแค่ต้องสร้างคลาส deleter:

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.

ถ้าคุณไม่จำเป็นต้องสามารถเปลี่ยน deleter ในรันไทม์ได้ฉันขอแนะนำอย่างยิ่งให้ใช้ประเภท deleter ที่กำหนดเอง ตัวอย่างเช่นถ้าใช้ตัวชี้ฟังก์ชันสำหรับ Deleter sizeof(unique_ptr<T, fptr>) == 2 * sizeof(T*)ของคุณ กล่าวอีกนัยหนึ่งครึ่งหนึ่งของไบต์ของunique_ptrวัตถุจะเสียไป

การเขียน deleter ที่กำหนดเองเพื่อตัดทุกฟังก์ชันเป็นเรื่องที่น่ารำคาญ โชคดีที่เราสามารถเขียนประเภทแม่แบบในฟังก์ชัน:

ตั้งแต่ 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()};

คุณรู้ไหมว่าการใช้ deleter แบบกำหนดเองไม่ใช่วิธีที่ดีที่สุดเนื่องจากคุณจะต้องพูดถึงโค้ดทั้งหมด
แต่ในขณะที่คุณได้รับอนุญาตให้เพิ่มความเชี่ยวชาญในการเรียน namespace ในระดับ::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 };
}

คุณสามารถใช้std::bindกับฟังก์ชันทำลายของคุณ

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