Bir std :: unique_ptr üyesiyle özel bir siliciyi nasıl kullanabilirim?

Unique_ptr üyesi olan bir sınıfım var.

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

Bar, create () işlevi ve destroy () işlevi olan üçüncü taraf bir sınıftır.

Onunla std::unique_ptrbağımsız bir işlevde kullanmak isteseydim şunları yapabilirdim:

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

Bunu std::unique_ptrbir sınıfın üyesi olarak yapmanın bir yolu var mı ?

Varsayarsak createve destroyaşağıdaki imzalarla (OP kod parçacığı vaka gibi görünüyor olan) serbest işlevleri şunlardır:

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

Sınıfını Fooböyle yazabilirsin

class Foo {

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

    // ...

public:

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

    // ...
};

Burada herhangi bir lambda veya özel silici yazmanıza gerek olmadığına dikkat edin, çünkü destroyzaten bir silme aracıdır.

Bunu C ++ 11'de bir lambda kullanarak temiz bir şekilde yapmak mümkündür (G ++ 4.8.2'de test edilmiştir).

Bu yeniden kullanılabilirlik göz önüne alındığında typedef:

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

Yazabilirsin:

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

Örneğin, bir FILE*:

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

Bununla, deneme / yakalama gürültüsüne gerek kalmadan RAII kullanarak olağanüstü güvenli temizlemenin avantajlarını elde edersiniz.

Yalnızca bir silme sınıfı oluşturmanız gerekir:

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

ve bunu şablon argümanı olarak sağlayın unique_ptr. Yine de kurucularınızda unique_ptr'yi başlatmanız gerekecek:

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

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

Bildiğim kadarıyla, tüm popüler c ++ kitaplıkları bunu doğru bir şekilde uyguluyor; çünkü BarDeleter aslında hiçbir devlet yoktur, bu herhangi bir alanı işgal etmek gerekmez unique_ptr.

Siliciyi çalışma zamanında değiştirebilmeniz gerekmedikçe, özel bir silici türü kullanmanızı şiddetle tavsiye ederim. Örneğin, siliciniz için bir işlev işaretçisi kullanıyorsanız sizeof(unique_ptr<T, fptr>) == 2 * sizeof(T*),. Başka bir deyişle, baytların yarısıunique_ptr nesnenin boşa harcanır.

Yine de, her işlevi sarmak için özel bir silici yazmak zahmetlidir. Neyse ki, fonksiyon üzerine şablonlu bir tip yazabiliriz:

C ++ 17'den beri:

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'den önce:

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

Biliyorsunuz, kodunuzun her yerinde bundan bahsetmeniz gerekeceğinden, özel bir silici kullanmak en iyi yol değildir.
Bunun yerine, ad alanı düzeyindeki sınıflara uzmanlıklar eklemenize izin verildiğinden::std özel türler dahil olduğu ve semantiğe saygı duyduğunuz sürece , şunu yapın:

Uzmanlaşı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); }
};

Ve belki şunu da yapın 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 };
}

Sadece std::bindbir yok etme fonksiyonunuzla kullanabilirsiniz.

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

Ama tabii ki bir lambda da kullanabilirsiniz.

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