Як використовувати користувацький делетер з членом std :: unique_ptr?

У мене клас з унікальним членом_ptr.

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

Штрих - це сторонній клас, який має функцію create () та знищити ().

Якби я хотів використовувати це std::unique_ptrз ним у самостійній функції, я міг би:

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

Чи є спосіб це зробити std::unique_ptrяк член класу?

Припускаючи, що це 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.

Якщо вам не потрібно мати змогу змінити делетер під час виконання, я настійно рекомендую використовувати користувальницький тип делетера. Наприклад, якщо використовувати покажчик на функцію для вашого Deleter, 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, якщо задіяні спеціальні типи, і ви поважаєте семантику, зробіть це:

Спеціалізуйтеся 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);});