When is std::weak_ptr useful?

by

std::weak_ptr is a very good way to solve the dangling pointer problem. By just using raw pointers it is impossible to know if the referenced data has been deallocated or not. Instead, by letting a std::shared_ptr manage the data, and supplying std::weak_ptr to users of the data, the users can check validity of the data by calling expired() or lock().

You could not do this with std::shared_ptr alone, because all std::shared_ptr instances share the ownership of the data which is not removed before all instances of std::shared_ptr are removed. Here is an example of how to check for dangling pointer using lock():

#include <iostream>
#include <memory>

int main()
{
    // OLD, problem with dangling pointer
    // PROBLEM: ref will point to undefined data!

    int* ptr = new int(10);
    int* ref = ptr;
    delete ptr;

    // NEW
    // SOLUTION: check expired() or lock() to determine if pointer is valid

    // empty definition
    std::shared_ptr<int> sptr;

    // takes ownership of pointer
    sptr.reset(new int);
    *sptr = 10;

    // get pointer to data without taking ownership
    std::weak_ptr<int> weak1 = sptr;

    // deletes managed object, acquires new pointer
    sptr.reset(new int);
    *sptr = 5;

    // get pointer to new data without taking ownership
    std::weak_ptr<int> weak2 = sptr;

    // weak1 is expired!
    if(auto tmp = weak1.lock())
        std::cout << "weak1 value is " << *tmp << '\n';
    else
        std::cout << "weak1 is expired\n";
    
    // weak2 points to new data (5)
    if(auto tmp = weak2.lock())
        std::cout << "weak2 value is " << *tmp << '\n';
    else
        std::cout << "weak2 is expired\n";
}

Output

weak1 is expired
weak2 value is 5

More Related Contents:

  1. Passing shared pointers as arguments
  2. shared_ptr and weak_ptr differences
  3. weak_ptr, make_shared and memory deallocation
  4. What is a lambda expression in C++11?
  5. Why should I use a pointer rather than the object itself?
  6. What is “rvalue reference for *this”?
  7. C++11 rvalues and move semantics confusion (return statement)
  8. How do I call ::std::make_shared on a class with only protected or private constructors?
  9. How can I add C++11 support to Code::Blocks compiler?
  10. Difference in make_shared and normal shared_ptr in C++
  11. Why does C++11 not support designated initializer lists as C99? [closed]
  12. How can I efficiently select a Standard Library container in C++11?
  13. Is the safe-bool idiom obsolete in C++11?
  14. How do I enable C++11 in gcc?
  15. Why do std::shared_ptr work
  16. Is the ‘override’ keyword just a check for a overridden virtual method?
  17. Should we pass a shared_ptr by reference or by value?
  18. Passing shared_ptr as shared_ptr
  19. Where is shared_ptr?
  20. C++11: How to set seed using
  21. std::shared_ptr thread safety explained
  22. What are the main purposes of std::forward and which problems does it solve?
  23. What is the difference between std::atoi() and std::stoi?
  24. When to make a type non-movable in C++11?
  25. How do shared pointers work?
  26. Why does unique_ptr take two template parameters when shared_ptr only takes one?
  27. What is the cyclic dependency issue with shared_ptr?
  28. Does C++11 unique_ptr and shared_ptr able to convert to each other’s type?
  29. About thread-safety of weak_ptr
  30. Boost asio thread_pool join does not wait for tasks to be finished

Leave a Comment