std::weak_ptr::use_count(3)

NAME
std::weak_ptr::use_count - std::weak_ptr::use_count

Synopsis
   long use_count() const noexcept; (since C++11)
   Returns the number of shared_ptr instances that share ownership of the managed
   object, or 0 if the managed object has already been deleted, i.e. *this is empty.

Parameters
   (none)

Return value
   The number of shared_ptr instances sharing the ownership of the managed object at
   the instant of the call.

Notes
   expired() may be faster than use_count(). This function is inherently racy, if the
   managed object is shared among threads that might be creating and destroying copies
   of the shared_ptr: then, the result is reliable only if it matches the number of
   copies uniquely owned by the calling thread, or zero; any other value may become
   stale before it can be used.

Example
// Run this code
 #include <iostream>
 #include <memory>
 std::weak_ptr<int> gwp;
 void observe_gwp()
 {
     std::cout << "use_count(): " << gwp.use_count() << "\t id: ";
     if (auto sp = gwp.lock())
         std::cout << *sp << '\n';
     else
         std::cout << "??\n";
 }
 void share_recursively(std::shared_ptr<int> sp, int depth)
 {
     observe_gwp(); // : 2 3 4
     if (1 < depth)
         share_recursively(sp, depth - 1);
     observe_gwp(); // : 4 3 2
 }
 int main()
 {
     observe_gwp();
     {
         auto sp = std::make_shared<int>(42);
         gwp = sp;
         observe_gwp(); // : 1
         share_recursively(sp, 3); // : 2 3 4 4 3 2
         observe_gwp(); // : 1
     }
     observe_gwp(); // : 0
 }

Output:
 use_count(): 0 id: ??
 use_count(): 1 id: 42
 use_count(): 2 id: 42
 use_count(): 3 id: 42
 use_count(): 4 id: 42
 use_count(): 4 id: 42
 use_count(): 3 id: 42
 use_count(): 2 id: 42
 use_count(): 1 id: 42
 use_count(): 0 id: ??

See also
   expired checks whether the referenced object was already deleted
           (public member function)