Question: 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?

Answer: 
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.
The .reset() method only applies to the object it's called upon.

It just replaces the pointer that variable is holding.