Ownership and leaks

Questions 1 to 5 of 7

1. 1. Two shared_ptr objects point at each other: x->other = y; and y->other = x;. When the block that holds x and y ends, what happens?

   Both objects are destroyed, and their destructors print their messages.Both counts drop to 1, so neither object is deleted and their destructors never run.The first one to leave scope is deleted, and the other one is kept.Both counts drop to 0, so both objects are deleted in order.
2. 2. In a tree where each parent owns its children, which link should be a weak_ptr?

   The parent's link to its children.Both links, so neither object keeps the other alive.The child's link back to its parent.The link from the root to the first child.
3. 3. What is the bug in this code? ``cpp std::shared_ptr<int> owner(new int(7)); std::weak_ptr<int> watcher = owner; int* raw = watcher.lock().get(); owner.reset(); std::cout << *raw << std::endl; ``

   new int(7) should be make_unique<int>(7), so the code compiles.weak_ptr cannot watch an int, so lock() always returns nullptr.lock() returns a temporary shared_ptr. It is gone at the end of its statement, so after owner.reset() the int is freed and raw is dangling.std::cout needs std::endl before *raw is read, or the value is lost.
4. 4. Which block leaks in this code, and why? ``cpp int* p = new int(5); p = new int(6); delete p; ``

   The int that holds 6, because delete p does not free an int.Both ints, because delete needs delete[] for any pointer.Neither, because LeakSanitizer only reports arrays.The int that holds 5, because p = new int(6); overwrites the only pointer to it before it is freed.
5. 5. True or false: a clean LeakSanitizer report, with no leaks found, means the program uses memory well.

   True, because LeakSanitizer reports every block that keeps growing.False, because a global list that keeps growing is still reachable, so the leak check stays silent about it.