Does using .reset() on a std::shared_ptr delete all instances
Solution 1
When you use .reset()
, you are eliminating one owner of the pointer, but all of the other owners are still around. Here is an example:
#include <memory>
#include <cstdio>
class Test { public: ~Test() { std::puts("Test destroyed."); } };
int main()
{
std::shared_ptr<Test> p = std::make_shared<Test>();
std::shared_ptr<Test> q = p;
std::puts("p.reset()...");
p.reset();
std::puts("q.reset()...");
q.reset();
std::puts("done");
return 0;
}
The program output:
p.reset()... q.reset()... Test destroyed. done
Note that p
and q
are both owners of the object, and once both p
and q
are reset, then the instance is destroyed.
Solution 2
No.
The whole purpose of shared_ptr
is that you cannot delete it from one place if someone is using it in another. shared_ptr::reset()
just decreases use_count
by one and replaces its object by nullptr
.
Solution 3
The .reset() method only applies to the object it's called upon.
It just replaces the pointer that variable is holding.
zeus_masta_funk
BS in Electrical Engineering current working on designing and implementing embedded systems. Professional experience includes Linux Device-Drivers, ARM processor development, C/C++ applications, University Research (undergrad level). Personal experiences include PCB design and various other hardware projects.
Updated on March 19, 2020Comments
-
zeus_masta_funk about 4 years
I'm new to shared_ptr's and I'm trying to figure out the exact functionality of the .reset() function.
#include <memory> #include <stdio> using namespace std; class SomeClass{}; int main() { shared_ptr<SomeClass> sp (nullptr); //do some stuff, sp now has 10 co-owners cout << sp.use_count << endl; sp.reset(); cout << sp.use_count << endl; return 0; }
Would output
10 0
So since I used the reset function are all instances deleted from memory? As in, have I just eliminated any possible memory leaks with sp? Obviously this was a toy example that I quickly made up, sorry if it has any errors.
Follow up situation:
shared_ptr<SomeClass> returnThis() { shared_ptr<SomeClass> someObject(new SomeClass(/*default constructor for example*/) ); return someObject; }
somehere in main:
shared_ptr<SomeClass> mainObject; mainObject = returnThis();
Does mainObject have a use count of 2 because someObject was created in a function but never cleared? Or is it one and the clean-up is done automatically when returning the value?