Jak używać niestandardowego deletera z członkiem std :: unique_ptr?

Question

Mam klasę z członkiem unique_ptr.

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

Pasek jest klasą innej firmy, która ma funkcję create() i funkcję destroy().

Gdybym chciał użyć std::unique_ptr z nim na samodzielny funkcji mogę zrobić:

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

Czy istnieje sposób to zrobić z std::unique_ptr jako członek klasy?

Answer 1

Zakładając, że create i destroy są bezpłatne funkcje (co wydaje się być przypadek z fragmentu kodu PO) ze następujących podpisów:

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

można napisać klasę Foo tak

class Foo { 

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

    // ... 

public: 

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

    // ... 
}; 

Zauważ, że nie musisz pisać żadnych lambda ani niestandardowych deleterów tutaj, ponieważ destroy jest już deleterem.

Answer 2

Możesz po prostu użyć std::bind z funkcją niszczenia.

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

Ale oczywiście można również użyć lambda.

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

Answer 3

Wystarczy utworzyć klasę Deleter:

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

i dostarczyć go jako argumentu szablonu z unique_ptr. Nadal będziesz musiał zainicjować unique_ptr w swoich konstruktorów:

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

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

O ile mi wiadomo, wszystkie popularne C++ biblioteki zaimplementować to w prawidłowy sposób; ponieważ BarDeleter w rzeczywistości nie ma żadnego stanu, nie musi zajmować żadnego miejsca w unique_ptr.

Answer 4

Można to zrobić czysto, używając lambda w C++ 11 (testowane w G ++ 4.8.2).

Biorąc pod uwagę to wielokrotnego użytku typedef:

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

Można napisać:

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

---

Na przykład, z FILE*:

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

Dzięki temu możesz uzyskać korzyści bezpiecznego czyszczenia w wyjątkowych warunkach z użyciem RAII, bez konieczności generowania hałasu próbnego/przechwytującego.