Làm cách nào để sử dụng một deleter tùy chỉnh với thành viên std :: unique_ptr?

Tôi có một lớp học với một thành viên unique_ptr.

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

Bar là lớp bên thứ ba có chức năng tạo () và chức năng hủy ().

Nếu tôi muốn sử dụng một std::unique_ptrvới nó trong một chức năng độc lập, tôi có thể làm:

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

Có cách nào để làm điều này với std::unique_ptrtư cách là thành viên của một lớp không?

Giả sử rằng createvà destroylà các hàm miễn phí (dường như là trường hợp từ đoạn mã của OP) với các chữ ký sau:

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

Bạn có thể viết lớp của bạn Foonhư thế này

class Foo {

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

    // ...

public:

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

    // ...
};

Lưu ý rằng bạn không cần phải viết bất kỳ lambda hoặc deleter tùy chỉnh nào ở đây vì destroyđã là một deleter.

Có thể thực hiện việc này một cách sạch sẽ bằng lambda trong C ++ 11 (được thử nghiệm trong G ++ 4.8.2).

Đưa ra điều này có thể tái sử dụng typedef:

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

Bạn có thể viết:

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

Ví dụ: với một FILE*:

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

Với điều này, bạn sẽ có được những lợi ích của việc dọn dẹp an toàn ngoại lệ bằng RAII, mà không cần phải thử / bắt tiếng ồn.

Bạn chỉ cần tạo một lớp deleter:

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

và cung cấp nó như là đối số mẫu của unique_ptr. Bạn vẫn sẽ phải khởi tạo unique_ptr trong các hàm tạo của mình:

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

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

Theo tôi biết, tất cả các thư viện c ++ phổ biến đều thực hiện điều này một cách chính xác; vì BarDeleter thực tế không có bất kỳ trạng thái nào, nó không cần chiếm bất kỳ khoảng trống nào trong unique_ptr.

Trừ khi bạn cần có khả năng thay đổi deleter trong thời gian chạy, tôi thực sự khuyên bạn nên sử dụng một loại deleter tùy chỉnh. Ví dụ: nếu sử dụng một con trỏ hàm cho deleter của bạn , sizeof(unique_ptr<T, fptr>) == 2 * sizeof(T*). Nói cách khác, một nửa số byte của unique_ptrđối tượng bị lãng phí.

Tuy nhiên, viết một deleter tùy chỉnh để bọc mọi chức năng là một điều phiền phức. Rất may, chúng ta có thể viết một kiểu templated trên hàm:

Kể từ 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()};

Trước 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()};

Bạn chỉ có thể sử dụng std::bindvới chức năng hủy của bạn.

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

Nhưng tất nhiên bạn cũng có thể sử dụng lambda.

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

Bạn biết đấy, sử dụng một deleter tùy chỉnh không phải là cách tốt nhất, vì bạn sẽ phải đề cập đến nó trên toàn bộ mã của bạn.
Thay vào đó, khi bạn được phép thêm các chuyên ngành vào các lớp mức không gian ::stdmiễn là các loại tùy chỉnh có liên quan và bạn tôn trọng ngữ nghĩa, hãy làm điều đó:

Chuyên 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); }
};

Và cũng có thể làm 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 };
}