shared_ptr and use_count

Question

In the following code snippet:

shared_ptr<int> p;

{
    p = shared_ptr<int>(new int);
    cout<<p.use_count()<<endl;
}

cout<<p.use_count()<<endl;

The output comes out to be

1
1

I don't understand why the 1st output is 1 -- shouldn't it be 2?

@Mat: I may be wrong, but i thought that within that scope of braces, the `p` and the temporary object created by rhs shall make up the `use_count()` to `2` — zeropoint, Aug 12 '12 at 08:10
@Mr.Anubis: Thank you, I thought the temporary's scope to be local and not the statment-scope — zeropoint, Aug 12 '12 at 08:23

score 9 · Accepted Answer · answered Aug 12 '12 at 08:17

The temporary object's lifetime does not last long enough for the first p.use_count() to return 2. The temporary object is destroyed first, relinquishing its ownership on anything it owned.

Furthermore, since the temporary is an rvalue, the assignment to p will result in a move-assignment, which means the use-count will never be 2 anyway (assuming a quality implementation). Ownership is simply transferred from the temporary to p, never exceeding 1.

dans3itz · Answer 2 · 2012-08-12T08:26:14.030

7

 #include <memory>
 #include <iostream>

 int
 main(int argc, char** argv) {
   std::shared_ptr<int> p(new int);
   std::shared_ptr<int> p2(p);
   std::cout << p.use_count() << std::endl;
   return 0;
 }

output: 2

EXPLANATION/EDIT: In your source, the initial 'p' never held ownership of anything. In the 2nd reference to p, you are assigning to a temporary and basically giving up ownership to 'p'. Most likely, as well, the move constructor is used to satisfy this assignment.

EDIT: This was probably what you were going for?

 #include <memory>
 #include <iostream>

 int
 main(int argc, char** argv) {
   std::shared_ptr<int> p(new int);
   {
       std::shared_ptr<int> p2(p);
       std::cout << p.use_count() << std::endl;
   }
   std::cout << p.use_count() << std::endl;
   return 0;
 }

output: 2
        1

edited Aug 12 '12 at 08:26

answered Aug 12 '12 at 08:11

dans3itz

1,605
14
12

I agree, but I had doubt with the temporary object created by rhs of statement `p = shared_ptr(new int);` whereas `p` is already an existing `shared_ptr` – zeropoint Aug 12 '12 at 08:17
Yes, but see how you are assigning to a temporary? And 'p' never owned anything, so its declaration had no basis for this at all. – dans3itz Aug 12 '12 at 08:18

score 1 · Answer 3 · answered Aug 12 '12 at 08:15

From boost.org:

template<class Y> explicit shared_ptr(Y * p); 
Requirements: p must be convertible to T *. Y must be a complete type. The     expression delete p must be well-formed, must not invoke undefined behavior, and     must not throw exceptions.

Effects: Constructs a shared_ptr that owns the pointer p.

Postconditions: use_count() == 1 && get() == p.

Throws: std::bad_alloc, or an implementation-defined exception when a resource other than memory could not be obtained.

Exception safety: If an exception is thrown, delete p is called.

Notes: p must be a pointer to an object that was allocated via a C++ new    expression or be 0. The postcondition that use count is 1 holds even if p is 0;    invoking delete on a pointer that has a value of 0 is harmless.

As you can see, it releases the last construct if you construct a new shared_ptr from the new int.

shared_ptr and use_count

3 Answers3

Linked