Defined in header <memory> | ||
---|---|---|
template< class T > class weak_ptr; | (since C++11) |
std::weak_ptr
is a smart pointer that holds a non-owning ("weak") reference to an object that is managed by std::shared_ptr
. It must be converted to std::shared_ptr
in order to access the referenced object.
std::weak_ptr
models temporary ownership: when an object needs to be accessed only if it exists, and it may be deleted at any time by someone else, std::weak_ptr
is used to track the object, and it is converted to std::shared_ptr
to assume temporary ownership. If the original std::shared_ptr
is destroyed at this time, the object's lifetime is extended until the temporary std::shared_ptr
is destroyed as well.
Another use for std::weak_ptr
is to break reference cycles formed by objects managed by std::shared_ptr
. If such cycle is orphaned (i,e. there are no outside shared pointers into the cycle), the shared_ptr reference counts cannot reach zero and the memory is leaked. To prevent this, one of the pointers in the cycle can be made weak.
Member type | Definition | ||||
---|---|---|---|---|---|
element_type |
|
creates a new weak_ptr (public member function) |
|
destroys a weak_ptr (public member function) |
|
assigns the weak_ptr (public member function) |
|
Modifiers |
|
releases the ownership of the managed object (public member function) |
|
swaps the managed objects (public member function) |
|
Observers |
|
returns the number of shared_ptr objects that manage the object (public member function) |
|
checks whether the referenced object was already deleted (public member function) |
|
creates a shared_ptr that manages the referenced object (public member function) |
|
provides owner-based ordering of weak pointers (public member function) |
(C++11) | specializes the std::swap algorithm (function template) |
(C++20) | atomic weak pointer (class template specialization) |
Like std::shared_ptr
, a typical implementation of weak_ptr
stores two pointers:
shared_ptr
it was constructed from. A separate stored pointer is necessary to ensure that converting a shared_ptr
to weak_ptr
and then back works correctly, even for aliased shared_ptr
s. It is not possible to access the stored pointer in a weak_ptr
without locking it into a shared_ptr
.
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
DR | Applied to | Behavior as published | Correct behavior |
---|---|---|---|
LWG 3001 | C++17 | element_type was not updated for array support | updated |
Demonstrates how lock is used to ensure validity of the pointer.
#include <iostream> #include <memory> std::weak_ptr<int> gw; void observe() { std::cout << "use_count == " << gw.use_count() << ": "; if (auto spt = gw.lock()) { // Has to be copied into a shared_ptr before usage std::cout << *spt << "\n"; } else { std::cout << "gw is expired\n"; } } int main() { { auto sp = std::make_shared<int>(42); gw = sp; observe(); } observe(); }
Output:
use_count == 1: 42 use_count == 0: gw is expired
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
http://en.cppreference.com/w/cpp/memory/weak_ptr