shared_ptr is to weak_ptr as unique_ptr is to… what?

by

The “notify” behavior of shared_ptr requires reference counting the reference count control block. shared_ptr‘s reference count control block(s) use separate reference counts for this. weak_ptr instances maintain references to this block, and weak_ptrs themselves prevent the reference count control block from being deleteed. The pointed-to object has its destructor called when the strong count goes to zero (which may or may not result in deleteion of the memory where that object was stored), and the control block is deleteed only when the weak reference count goes to zero.

unique_ptr‘s tenet is that it has zero overhead over a plain pointer. Allocating and maintaining reference count control blocks (to support weak_ptr-ish semantics) breaks that tenet. If you need behavior of that description, then you really want shared semantics, even if other references to the object are non-owning. There’s still sharing going on in that case — the sharing of the state of whether or not the object has been destroyed.

If you need a generic nonowning reference and don’t need notification, use plain pointers or plain references to the item in the unique_ptr.

EDIT:

In the case of your example, it looks like Victim should ask for a Trebuchet& rather than a Trebuchet*. Then it’s clear who owns the object in question.

class World
{
public:

    Trebuchet& trebuchet() const { return *m_trebuchet.get(); }

private:
    std::unique_ptr< Trebuchet > m_trebuchet;
};

class Victim
{
public:
    Victim( Trebuchet& theTrebuchet ) : m_trebuchet( theTrebuchet ) {}

    ~Victim()
    {
        delete m_trebuchet;     // Compiler error. :)
    }

private:

    Trebuchet& m_trebuchet;    // Non-owning.
};

shared_ptr< Victim > createVictim( World& world )
{
    return make_shared< Victim >( world.trebuchet() );
}

More Related Contents:

  1. Is std::unique_ptr required to know the full definition of T?
  2. Why can I not push_back a unique_ptr into a vector?
  3. Returning unique_ptr from functions
  4. How do I pass a unique_ptr argument to a constructor or a function?
  5. Differences between std::make_unique and std::unique_ptr with new
  6. How do I use a custom deleter with a std::unique_ptr member?
  7. Differences between unique_ptr and shared_ptr [duplicate]
  8. Is there any use for unique_ptr with array?
  9. How to capture a unique_ptr into a lambda expression?
  10. “Downcasting” unique_ptr to unique_ptr
  11. Copy constructor for a class with unique_ptr
  12. How to implement make_unique function in C++11? [duplicate]
  13. How do I use unique_ptr for pimpl?
  14. Proper way to create unique_ptr that holds an allocated array
  15. So can unique_ptr be used safely in stl collections?
  16. Exception safety and make_unique
  17. std::unique_ptr, deleters and the Win32 API
  18. std::auto_ptr to std::unique_ptr
  19. How does the custom deleter of std::unique_ptr work?
  20. How can I pass std::unique_ptr into a function
  21. Should I use shared_ptr or unique_ptr
  22. error::make_unique is not a member of ‘std’
  23. Raw pointer lookup for sets of unique_ptrs
  24. How can I compile C++11 code with Orwell Dev-C++?
  25. Why does unique_ptr take two template parameters when shared_ptr only takes one?
  26. Should std::unique_ptr be permitted
  27. stl container with std::unique_ptr’s vs boost::ptr_container
  28. Is there a way to write make_unique() in VS2012?
  29. Does std::bind work with move-only types in general, and std::unique_ptr in particular?
  30. Does C++11 unique_ptr and shared_ptr able to convert to each other’s type?

Leave a Comment