Namespaces
Variants
Views
Actions

std::shared_ptr<T>::use_count

From cppreference.com
< cpp‎ | memory‎ | shared ptr
 
 
Utilities library
Language support
Type support (basic types, RTTI)
Library feature-test macros (C++20)
Dynamic memory management
Program utilities
Coroutine support (C++20)
Variadic functions
Debugging support
(C++26)
Three-way comparison
(C++20)
(C++20)(C++20)(C++20)
(C++20)(C++20)(C++20)
General utilities
Date and time
Function objects
Formatting library (C++20)
(C++11)
Relational operators (deprecated in C++20)
Integer comparison functions
(C++20)(C++20)(C++20)   
(C++20)
Swap and type operations
(C++14)
(C++11)
(C++11)
(C++11)
(C++17)
Common vocabulary types
(C++11)
(C++17)
(C++17)
(C++17)
(C++11)
(C++17)
(C++23)
Elementary string conversions
(C++17)
(C++17)

 
Dynamic memory management
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Allocators
Garbage collection support
(C++11)(until C++23)
(C++11)(until C++23)
(C++11)(until C++23)
(C++11)(until C++23)
(C++11)(until C++23)
(C++11)(until C++23)



 
 
long use_count() const noexcept;

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

In multithreaded environment, the value returned by use_count is approximate (typical implementations use a memory_order_relaxed load).

Contents

[edit] Parameters

(none)

[edit] Return value

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

[edit] Notes

Common use cases include

  • comparison with 0. If use_count returns zero, 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, this 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.

[edit] Example

#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)

[edit] See also

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