Storing Weak Pointers in Containers

Yes, you can store weak pointers in containers just like any other object type. Weak pointers can be stored in various standard containers such as std::vector, std::list, std::map, etc.

When storing weak pointers in containers, keep in mind that the container itself does not participate in the ownership or lifetime management of the pointed-to objects. The weak pointers in the container will not prevent the objects from being destroyed if all the corresponding shared pointers go out of scope.

Here's an example that demonstrates storing weak pointers in a std::vector:

1#include <memory>
2#include <vector>
3#include <iostream>
4
5int main() {
6  std::vector<std::weak_ptr<int>> WeakPtrVector;
7
8  {
9    auto SharedPtr1{std::make_shared<int>(10)};
10    auto SharedPtr2{std::make_shared<int>(20)};
11
12    WeakPtrVector.emplace_back(SharedPtr1);
13    WeakPtrVector.emplace_back(SharedPtr2);
14
15    for (const auto& WeakPtr : WeakPtrVector) {
16      if (auto SharedPtr{WeakPtr.lock()}) {
17        std::cout << *SharedPtr << " ";
18      }
19    }
20    std::cout << "\n";
21  }
22
23  for (const auto& WeakPtr : WeakPtrVector) {
24    if (auto SharedPtr{WeakPtr.lock()}) {
25      std::cout << *SharedPtr << " ";
26    } else {
27      std::cout << "Expired ";
28    }
29  }
30}

110 20
2Expired Expired

In this example, we create a std::vector called WeakPtrVector to store weak pointers to int objects. We create two shared pointers, SharedPtr1 and SharedPtr2, and add their corresponding weak pointers to the vector using emplace_back().

Inside the first block, we iterate over the WeakPtrVector and lock each weak pointer to obtain a shared pointer. If the object still exists, we dereference the shared pointer and print its value.

After the block ends, the shared pointers SharedPtr1 and SharedPtr2 go out of scope, and the pointed-to objects are destroyed. When we iterate over the WeakPtrVector again, locking the weak pointers will return expired shared pointers, indicating that the objects no longer exist.

Storing weak pointers in containers is useful in scenarios where you need to maintain a non-owning reference to objects without affecting their lifetimes. For example, you can use weak pointers in a cache or a lookup table where the actual ownership is managed elsewhere.

Just remember to always check the validity of the weak pointers using lock() or expired() before accessing the pointed-to objects, as the objects may have been destroyed since the weak pointers were added to the container.