std::weak_ptr - cppreference.com (original) (raw)

| | | | | ------------------------------------- | | ------------- | | 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 acquire 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.

Contents

• 1 Member types
• 2 Member functions
  • 2.1 Modifiers
  • 2.2 Observers
• 3 Non-member functions
• 4 Helper classes
• 5 Deduction guides (since C++17)
• 6 Notes
• 7 Example
• 8 Defect reports
• 9 See also

[edit] Member types

[edit] Member functions

[edit] Non-member functions

[edit] Helper classes

[edit] Deduction guides (since C++17)

[edit] Notes

Like std::shared_ptr, a typical implementation of weak_ptr stores two pointers:

• a pointer to the control block; and
• the stored pointer of the 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_ptrs. It is not possible to access the stored pointer in a weak_ptr without locking it into a shared_ptr.

[edit] Example

Demonstrates how lock is used to ensure validity of the pointer.

#include #include   std::weak_ptr gw;   void observe() { std::cout << "gw.use_count() == " << gw.use_count() << "; "; // we have to make a copy of shared pointer before usage: if (std::shared_ptr spt = gw.lock()) std::cout << "*spt == " << *spt << '\n'; else std::cout << "gw is expired\n"; }   int main() { { auto sp = std::make_shared(42); gw = sp;   observe(); }   observe(); }

Output:

gw.use_count() == 1; *spt == 42 gw.use_count() == 0; gw is expired

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit] See also

| | smart pointer with unique object ownership semantics (class template) [edit] | | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | | smart pointer with shared object ownership semantics (class template) [edit] |