Namespaces
Variants

    std::shared_ptr<T>::use_count

    From cppreference.com
     
    C++
     
    Memory management library
    Allocators
    (C++17)
    (C++20)
    Memory resources
    Uninitialized storage (until C++20*)
    Garbage collector support (until C++23)
     
    std::shared_ptr
    Member functions
    Modifiers
    Observers
    (C++17)
    (until C++20*)
    (C++26)
    (C++26)
    Non-member functions
    (C++20)
    (C++20)
    (C++17)
    (until C++20)(until C++20)(until C++20)(until C++20)(until C++20)(C++20)
    functions (until C++26*)
    Helper classes
    (C++20)
    Deduction guides(C++17)
     
    long use_count() const noexcept;
    		(constexpr since C++26)

    Returns the number of different shared_ptr objects (including *this) managing the current object. If there is no managed object, 0 is returned.

    In multithreaded environment, use_count retrieves the number of objects atomically (typical implementations use a memory_order_relaxed load).

    Return value

    The number of std::shared_ptr objects managing the current object or 0 if there is no managed object.

    Notes

    Common use cases include:

    • Comparison with 0. If use_count returns 0, the shared pointer is empty and manages no objects (whether or not its stored pointer is nullptr).
    • Comparison with 1. If use_count returns 1, there are no other owners. The deprecated(since C++17) member function unique() is provided for this use case.(until C++20)

    In multithreaded environment, the value returned by use_count should be considered approximate, as the number of shared owners might change in other threads between the atomic retrieval and meaningful use of the value. When use_count returns 1, it does not imply that the object is safe to modify because accesses to the managed object by former shared owners may not have completed, and because new shared owners may be introduced concurrently, such as by std::weak_ptr::lock. Only when use_count returns 0 is the count accurate.

    Example

    Run this code
    #include <iostream>
#include <memory>

void fun(std::shared_ptr<int> sp)
{
    std::cout << "in fun(): sp.use_count() == " << sp.use_count()
              << " (object @ " << sp << ")\n";
}

int main()
{
    auto sp1 = std::make_shared<int>(5);
    std::cout << "in main(): sp1.use_count() == " << sp1.use_count()
              << " (object @ " << sp1 << ")\n";
    
    fun(sp1);
}

    Possible output: 

    in main(): sp1.use_count() == 1 (object @ 0x20eec30)
in fun(): sp.use_count() == 2 (object @ 0x20eec30)

    See also

    (until C++20)
    		 checks whether the managed object is managed only by the current shared_ptr object
    (public member function) [edit]