Как запустить std :: unique_ptr в конструкторе с помощью std :: make_unique () [duplicate]

Вы знаете, использование пользовательского делетера - не лучший способ, так как вам придется упомянуть его по всему вашему коду. Вместо этого , поскольку вам разрешено добавлять специализации к классам уровня пространства имен в ::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 };
}

Это можно сделать с помощью lambda в 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, без шума try / catch.

Если вам не удастся изменить делетера во время выполнения, я настоятельно рекомендую использовать настраиваемый тип удаления. Например, если вы используете указатель функции для вашего делета, 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::bind с вашей функцией destroy.

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

Вам просто нужно создать класс 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.