c++ shared_ptr release ownership

Question

We all know that we can easily convert unique_ptr to shared_ptr in C++. But what if I have made such a conversion :-

unique_ptr<X> u=make_unique<X>();    // X is some class
shared_ptr<X> s=move(u);      // this works of course

And now i want to transfer the ownership of the pointer in s back to u. Sadly there is no release() function in shared_ptr like in unique_ptr else I could have dont something like this :-

u.reset(s.release());

Moreover this also fails to work :-

u.reset(s.get());

Can anyone suggest me how to convert shared_ptr to unique_ptr or atleast release the pointer owned by shared_ptr ?

Answer 1

You should not do that!

The standard library does not really facilitate such a move, going from std::unique_ptr to std::shared_ptr is always safe (because of the semantics of the two) — but the opposite is dangerous since there might be more owners of the resource than the particular std::shared_ptr you would like to move from.

---

No, really — do not do that!

I should probably tell you one more time, but I will assume that you are somewhat grown up and can stand accountable for your own decisions.

---

Ey, come on.. sure there is a hack for this?

If you would like to hack together a solution that would not be undefined-behavior unless the std::unique_ptr goes out of scope and you still have std::shared_ptrs that directly or indirectly end up using the resource.. you would probably end up with something like:

#include <memory>

namespace hack {
  struct conditional_deleter {
    void  disable () { _do_delete = false; }

    template<class T>
    void operator()(T* p) {
      if (_do_delete)
        delete p;
    }   

    bool _do_delete = true;
  };  
}

int main () {
  std::unique_ptr<int> up (new int (123));
  std::shared_ptr<int> sp (up.release (), hack::conditional_deleter {});
  std::shared_ptr<int> sb (sp);

  std::get_deleter<hack::conditional_deleter> (sp)->disable (); 
  std::unique_ptr<int> ub (sp.get ()); // see the name of this variable?
}                                      // can I get a ticket to UB-land, please?

WARNING

The above is far from recommended praxis, if you ever find yourself in a situation where you need such thing you should set fire to your workstation—probably your whole house—and work on a new program design.

Answer 2

As everyone has mentioned, you cannot convert shared_ptr to unique_ptr because more than one shared_ptr might be owning the object. Hence there is no release() function for shared_ptr. Had there been one & you would have used release() on one shared_ptr object when more than one of such would be sharing a resource then there would be ambiguity for other shared_ptr pointers as to whether they own the resource or not.

However, because your actual problem was regarding the static& dynamic casting of unique_ptr (as you have mentioned in your comments) so I would like to add that you needn't actually use shared_ptr for casting unique_ptr & here I show you how you can do so very simply :-

void dynamic_unique_cast (unique_ptr<Parent> &pa)
{
    unique_ptr<Child> pb;    
    Parent *p=pa.release();   // release ownership
    try
    {
       pb.reset(dynamic_cast<Child*>(p));  // perform casting
       if (pb==nullptr)
       throw runtime_error {"nullptr exception"};
       cout<<"dynamic_cast successful\n\n";
       pa.reset(pb.release());  // if casting is successful then `pb` returns ownership back to `pa`
    }
    catch (exception &e)
    {
       cout<<"dynamic_cast unsuccessful: "<<e.what()<<"\n\n";
       pa.reset(p);  // if casting fails then `p` returns ownership to `pa`
    }
}
void static_unique_cast (unique_ptr<Parent> &pa)
{
    unique_ptr<Child> pb;
    Parent *p=pa.release();
    try
    {
       pb.reset(static_cast<Child*>(p));
       if (pb==nullptr)
       throw runtime_error {"nullptr exception"};
       show(pb);
       cout<<"static_cast successful\n\n";
       pa.reset(pb.release());
    }
    catch (exception &e)
    {
       cout<<"static_cast unsuccessful: "<<e.what()<<"\n\n";
       pa.reset(p);
    }
}

The above code works pretty well & will definitely solve your problem. If you have any ambiguity then feel free to comment.

Answer 3

OK, having looked at the comments I now realise that what you wanted was a version of dynamic_pointer_cast for unique_ptrs.

Remembering that unique_ptrs are well... unique, here is the answer:

Note that this answer may appear at first glance to be un-necessarily complex, but I think it's important to remember that unique_ptrs can have custom deleters. If we dynamic cast the unique_ptr into new one, the deleter must follow, but without the insertion of a translating shim, the pointer passed to the new unique_ptr's deleter would be of the wrong type.

This code not only dynamically moves ownership to a new pointer type, but also wires in the correct reverse pointer cast so that the object can be deleted on the correct interface by the correct deleter when the moved-to unique_ptr finally goes out of scope.

#include <iostream>
#include <memory>

template<class Dest, class Source, class Deleter>
auto
make_proxy_deleter(std::unique_ptr<Source, Deleter>& source)
{
    return [original = source.get_deleter()](Dest* p) {
        original(dynamic_cast<Source*>(p));
    };
}

template<class Dest, class T, class Deleter>
auto
dynamic_cast_unique(std::unique_ptr<T, Deleter>&& source)
{
    auto proxy_deleter = make_proxy_deleter<Dest>(source);
    auto p = dynamic_cast<Dest*>(source.get());
    if (!p) {
        return std::unique_ptr<Dest, decltype(proxy_deleter)>(nullptr,
                                                              std::move(proxy_deleter));
        // or... throw std::invalid_argument("not convertible");
    }

    return std::unique_ptr<Dest, decltype(proxy_deleter)>(dynamic_cast<Dest*>(source.release()),
                                                          std::move(proxy_deleter));
}

struct A {
    virtual ~A() {};
};
struct B {
    virtual ~B() {};
};
struct C: A, B {};


using namespace std;

auto main() -> int
{
    auto pa = make_unique<C>();
    auto pb = dynamic_cast_unique<B>(std::move(pa));
    return 0;
}