“Downcasting” unique_ptr to unique_ptr

by

I’d create a couple of function templates, static_unique_ptr_cast and dynamic_unique_ptr_cast. Use the former in cases where you’re absolutely certain the pointer is actually a Derived *, otherwise use the latter.

template<typename Derived, typename Base, typename Del>
std::unique_ptr<Derived, Del> 
static_unique_ptr_cast( std::unique_ptr<Base, Del>&& p )
{
    auto d = static_cast<Derived *>(p.release());
    return std::unique_ptr<Derived, Del>(d, std::move(p.get_deleter()));
}

template<typename Derived, typename Base, typename Del>
std::unique_ptr<Derived, Del> 
dynamic_unique_ptr_cast( std::unique_ptr<Base, Del>&& p )
{
    if(Derived *result = dynamic_cast<Derived *>(p.get())) {
        p.release();
        return std::unique_ptr<Derived, Del>(result, std::move(p.get_deleter()));
    }
    return std::unique_ptr<Derived, Del>(nullptr, p.get_deleter());
}

The functions are taking an rvalue reference to ensure that you’re not pulling the rug out from underneath the caller’s feet by stealing the unique_ptr passed to you.

More Related Contents:

  1. Why can I not push_back a unique_ptr into a vector?
  2. Differences between std::make_unique and std::unique_ptr with new
  3. Is there any use for unique_ptr with array?
  4. std::auto_ptr to std::unique_ptr
  5. unique_ptr and OpenSSL’s STACK_OF(X509)*
  6. make_unique and perfect forwarding
  7. Returning unique_ptr from functions
  8. How do I pass a unique_ptr argument to a constructor or a function?
  9. Differences between unique_ptr and shared_ptr [duplicate]
  10. How to implement make_unique function in C++11? [duplicate]
  11. Is there a non-atomic equivalent of std::shared_ptr? And why isn’t there one in ?
  12. smart pointers and arrays
  13. How do I use unique_ptr for pimpl?
  14. So can unique_ptr be used safely in stl collections?
  15. Exception safety and make_unique
  16. Passing shared_ptr as shared_ptr
  17. How can I pass std::unique_ptr into a function
  18. Should I use shared_ptr or unique_ptr
  19. error::make_unique is not a member of ‘std’
  20. Is auto_ptr deprecated?
  21. Raw pointer lookup for sets of unique_ptrs
  22. How can I compile C++11 code with Orwell Dev-C++?
  23. Why would I std::move an std::shared_ptr?
  24. Why does unique_ptr take two template parameters when shared_ptr only takes one?
  25. C++11: Replace all non-owning raw pointers with std::shared_ptr()?
  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