Reference count when returning a shared_ptr

Question

Does the following code mean that when this function returns, the request object inside this class still holds a reference to this object?

boost::shared_ptr<Request> RequestList::GetRequest()
{
    boost::mutex::scoped_lock(listmtx);
    request = boost::shared_ptr<Request>(new Request());
    return request;
}

used:

request = requests->GetRequest();  //Ref count is two on request object when it returns??

even after having completed above assignment, we still have a ref count of two on request...

where requests is just a RequestList pointer (raw pointer)...

Answer 1

It's two on return, one at the end of the statement.

request = boost::shared_ptr<Request>(new Request()); // ref count = 1
return request; // makes a copy of request. ref count = 2

So when it returns it's 2 because there is a temporary.

request = requests->GetRequest(); // it's two because there is still a temporary
// at the end of the statement all the temporaries are destroyed,
// ref count decremented to 1

Of course you can use request.use_count() to get the reference count.

Answer 2

The reference count is equal to the number of shared pointers in existence. In this case, it looks like, after creating the shared pointer, you end up with two copies (the assignment to request inside GetRequest(), which I'm guessing is a member of RequestList, and the assignment to request of the result of GetRequest()).

If both of these are shared pointers, and they don't both refer to the same pointer, then you will end up with two copies of the original pointer, and hence a reference count of two.

Answer 3

request is a private class variable...

Then there are two shared_ptr objects with a handle to the new Request(): the one in the calling function and the private class variable. Both legitimately bump the refcount.

Unless there's a reason for the private class variable to exist, eliminate it. At the very least, rename it last_request, because that's what it really is.

(Of course, when last_request gets reassigned by another call to GetRequest, its handle to the previous request goes away.)