Does using .reset() on a std::shared_ptr delete all instances

c++, memory, memory-leaks, shared-memory, shared-ptr

Solution

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.

Problem

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?

Original source