Как использовать пользовательское средство удаления с элементом 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) { /* ... */ }

    // ...
};

Обратите внимание, что вам не нужно писать здесь какие-либо лямбда-выражения или специальные средства удаления, потому что destroy уже является средством удаления.

Это можно сделать чисто, используя лямбду в С++ 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.

Если вам не нужно менять средство удаления во время выполнения, я настоятельно рекомендую использовать настраиваемый тип средства удаления. Например, если вы используете указатель на функцию для удаления, sizeof(unique_ptr<T, fptr>) == 2 * sizeof(T*). Другими словами, половина байтов объекта unique_ptr тратится впустую.

Однако написание пользовательского удаления для переноса каждой функции — проблема. К счастью, мы можем написать тип, основанный на функции:

Начиная с С++ 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()};

До С++ 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>
    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);});

С лямбда вы можете получить тот же размер, что и обычный std::unique_ptr. Сравните размеры:

plain: 8
lambda: 8
fpointer: 16
std::function: 40

Что является результатом следующего. (Я объявил лямбду вне области действия класса. Не уверен, что вы можете охватить ее внутри класса.)

#include <iostream>
#include <memory>
#include <functional>

struct Bar {};
void destroy(Bar* b) {}
Bar* create() { return 0; }

auto lambda_destroyer = [](Bar* b) {destroy(b);};

class Foo {
    
    std::unique_ptr<Bar, decltype(lambda_destroyer)> ptr_;

public:

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

int main()
{
    std::cout << "plain: "         << sizeof (std::unique_ptr<Bar>) << std::endl
              << "lambda: "        << sizeof (std::unique_ptr<Bar, decltype(lambda_destroyer)>) << std::endl
              << "fpointer: "      << sizeof (std::unique_ptr<Bar, void(*)(Bar*)>) << std::endl
              << "std::function: " << sizeof (std::unique_ptr<Bar, std::function<void(Bar*)>>) << std::endl;
}