How do I use a custom deleter with a std::unique_ptr member?

by

Assuming that create and destroy are free functions (which seems to be the case from the OP’s code snippet) with the following signatures:

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

You can write your class Foo like this

class Foo {

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

    // ...

public:

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

    // ...
};

Notice that you don’t need to write any lambda or custom deleter here because destroy is already a deleter.

More Related Contents:

  1. What is “rvalue reference for *this”?
  2. C++11 rvalues and move semantics confusion (return statement)
  3. initializer_list and move semantics
  4. When should std::move be used on a function return value? [duplicate]
  5. What is the advantage of using forwarding references in range-based for loops?
  6. “Downcasting” unique_ptr to unique_ptr
  7. Copy constructor for a class with unique_ptr
  8. What does the standard library guarantee about self move assignment?
  9. Is a moved-from vector always empty?
  10. How to actually implement the rule of five?
  11. How do I use unique_ptr for pimpl?
  12. Why do we copy then move?
  13. Proper way to create unique_ptr that holds an allocated array
  14. Should I delete the move constructor and the move assignment of a smart pointer?
  15. copy vs std::move for ints
  16. std::unique_ptr, deleters and the Win32 API
  17. Why do you use std::move when you have && in C++11? [duplicate]
  18. Do built-in types have move semantics?
  19. Is there any case where a return of a RValue Reference (&&) is useful?
  20. std::auto_ptr to std::unique_ptr
  21. How does the custom deleter of std::unique_ptr work?
  22. When to make a type non-movable in C++11?
  23. error::make_unique is not a member of ‘std’
  24. shared_ptr is to weak_ptr as unique_ptr is to… what?
  25. Is std::array movable?
  26. Should the Copy-and-Swap Idiom become the Copy-and-Move Idiom in C++11?
  27. Why would I std::move an std::shared_ptr?
  28. Should all/most setter functions in C++11 be written as function templates accepting universal references?
  29. Is there a way to write make_unique() in VS2012?
  30. Move semantics == custom swap function obsolete?

Leave a Comment