With the advent of std::unique_ptr
, the blemished std::auto_ptr
can finally be put to rest. So for the last several days, I have been changing my code to use smart pointers and to eliminate all delete
from my code.
Although valgrind says my code is memory-clean, the semantic richness of smart pointers will make for cleaner and easier-to-understand code.
In most of the code, the translation is simple: use std::unique_ptr
for in place of the raw pointers held by the owning objects, throw out delete
, and carefully sprinkle get()
, reset()
and move()
calls, as needed, to interface well with the rest of the code.
I am at the point where I am translating non-owning raw pointers to smart pointers now.
Since I was careful with the lifetimes of my objects (I ensure my modules only depend in one direction), valgrind tells me that I don't have any uninitialized reads, dangling pointers, or leaks. So, technically, I could just leave those non-owning raw pointers alone now.
However, one option is to change those non-owning raw pointers to std::shared_ptr
because I know they are acyclic. Or, would it be better to leave them as raw pointers?
I need some advice from veteran users of smart pointers as to what rules of thumb you use to decide whether to keep non-owning raw pointers as-is, or to translate them into std::shared_ptr
, keeping in mind that I constantly unit-test and valgrind my code.
EDIT: I might be misunderstanding the use of std::shared_ptr
- can they be used in conjunction with std::unique_ptr
, or is it the case that if I use std::shared_ptr
, all handles should also be std::shared_ptr
?
std::shared_ptr::getReturns the stored pointer. The stored pointer points to the object the shared_ptr object dereferences to, which is generally the same as its owned pointer.
Use unique_ptr when you want a single pointer to an object that will be reclaimed when that single pointer is destroyed. Use shared_ptr when you want multiple pointers to the same resource.
So, we should use shared_ptr when we want to assign one raw pointer to multiple owners. // referring to the same managed object. When to use shared_ptr? Use shared_ptr if you want to share ownership of a resource.
The shared_ptr type is a smart pointer in the C++ standard library that is designed for scenarios in which more than one owner might have to manage the lifetime of the object in memory.
Use a shared_ptr
when you require multiple things own a resource (and those owning things may go in and out of scope at "random"), use a unique_ptr
when a single thing owns the resource, and use a raw pointer when you just need to refer to it and not own it (and expect this referral to not last longer than the resource exists).
There is a fourth type, a sort of raw-pointer-for-shared_ptr
's, called weak_ptr
. You use that to refer to a shared_ptr
without actually owning it; you can then check if the object is still there and use it.
Personally, this is how I (more or less) do it:
By far I use more unique_ptrs than shared_ptrs, and more raw pointers than weak pointers.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With