std::weak_ptr
cppreference.com
<tbody>
</tbody>
| <memory> .
|
||
template< class T > class weak_ptr; |
(since C++11) | |
std::weak_ptr std::shared_ptr ("") . std::shared_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.
In addition, std::weak_ptr is used to break circular references of std::shared_ptr.
Member types
| Member type | Definition |
element_type
|
T
|
Member functions
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) | |
Non-member functions
(C++11) |
specializes the std::swap algorithm (function template) |
Example
Demonstrates how lock is used to ensure validity of the pointer.
#include <iostream>
#include <memory>
std::weak_ptr<int> gw;
void f()
{
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;
f();
}
f();
}
Output:
42
gw is expired