Introduction to weak pointers

A(n)   is a smart pointer that holds a non-owning reference to a resource managed by a shared pointer.

A std::weak_ptr models temporary ownership. One must convert a weak pointer to a(n)   to access the referenced object.

You've implemented a directed graph structured as a collection of nodes using shared pointers. For example, consider the following Node type definition:

struct Node {
  Node(char c) : id(c) {}
  char id;
  std::shared_ptr<Node> ptr;
};

If we invoke CreateCyclicGraph, defined as follows:

void CreateCyclicGraph() {

  auto A = std::make_shared<Node>('A');
  auto B = std::make_shared<Node>('B');
  auto C = std::make_shared<Node>('C');

  A->ptr = B;
  B->ptr = C;
  C->ptr = A;

}

Given the graph's structure and our use of shared pointers:

Given a reference cycle of shared pointers with no outside pointers pointing into the cycle, memory is leaked since the reference counts cannot reach zero. The best way to prevent this "non-breaking" cycle of std::shared_ptrs is to:

We prefer (and taught you) to implement a doubly linked list with smart pointers using one owner per node: a doubly linked list implementation using smart pointers should leverage std::unique_ptrs and raw pointers.

However, if you wanted to break from best practice and implement a doubly linked list using shared pointers, each node object in the sequence should have its next and previous node pointers typed (select the best response):