smart-pointers – Page 6

“Downcasting” unique_ptr to unique_ptr

March 3, 2023 by Tarik

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 … Read more

Why does unique_ptr have the deleter as a type parameter while shared_ptr doesn’t?

February 27, 2023 by Tarik

Part of the reason is that shared_ptr needs an explicit control block anyway for the ref count and sticking a deleter in isn’t that big a deal on top. unique_ptr however doesn’t require any additional overhead, and adding it would be unpopular- it’s supposed to be a zero-overhead class. unique_ptr is supposed to be static. … Read more

std::shared_ptr initialization: make_shared() vs shared_ptr(new Foo) [duplicate]

February 22, 2023 by Tarik

Both examples are rather more verbose than necessary: std::shared_ptr<int> p(new int); // or ‘=shared_ptr<int>(new int)’ if you insist auto p = std::make_shared<int>(); // or ‘std::shared_ptr<int> p’ if you insist What’s the difference? The main difference is that the first requires two memory allocations: one for the managed object (new int), and one for the reference … Read more

When should I use raw pointers over smart pointers?

February 15, 2023 by Tarik

No, it’s not true. If a function needs a pointer and has nothing to do with ownership, then I strongly believe that a regular pointer should be passed for the following reasons: No ownership, therefore you don’t know what kind of a smart pointer to pass If you pass a specific pointer, like shared_ptr, then … Read more

Why can’t a weak_ptr be constructed from a unique_ptr?

February 10, 2023 by Tarik

If you think about it, a weak_ptr must refer to something other than the object itself. That’s because the object can cease to exist (when there are no more strong pointers to it) and the weak_ptr still has to refer to something that contains the information that the object no longer exists. With a shared_ptr, … Read more

RAII vs. Garbage Collector

February 9, 2023 by Tarik

If I strictly follow RAII rules, which seems to be a good thing, why would that be any different from having a garbage collector in C++? While both deal with allocations, they do so in completely different manners. If you are reffering to a GC like the one in Java, that adds its own overhead, … Read more

How can I use covariant return types with smart pointers?

February 9, 2023 by Tarik

Firstly, this is indeed how it works in C++: the return type of a virtual function in a derived class must be the same as in the base class. There is the special exception that a function that returns a reference/pointer to some class X can be overridden by a function that returns a reference/pointer … Read more

Example to use shared_ptr?

February 1, 2023 by Tarik

Using a vector of shared_ptr removes the possibility of leaking memory because you forgot to walk the vector and call delete on each element. Let’s walk through a slightly modified version of the example line-by-line. typedef boost::shared_ptr<gate> gate_ptr; Create an alias for the shared pointer type. This avoids the ugliness in the C++ language that … Read more

Should I assign or reset a unique_ptr?

January 31, 2023 by Tarik

From the docs of unique_ptr‘s operator=: Transfers ownership of the object pointed to by r to *this as if by calling reset(r.release()) followed by an assignment from std::forward<E>(r.get_deleter()). And all you need of that is the reset call, so it’s simpler to just call it directly

Is auto_ptr deprecated?

January 28, 2023 by Tarik

UPDATE: This answer was written in 2010 and as anticipated std::auto_ptr has been deprecated. The advice is entirely valid. In C++0x std::auto_ptr will be deprecated in favor of std::unique_ptr. The choice of smart pointer will depend on your use case and your requirements, with std::unique_ptr with move semantics for single ownership that can be used … Read more