Pointer bug hunt

Questions 1 to 5 of 9

1. 1. What is wrong with this count_nodes? ``cpp int count_nodes(const Node* head) { if (head == nullptr) return 0; int count = 0; for (const Node* cur = head; cur->next != nullptr; cur = cur->next) ++count; return count; } ``

   It returns 1 for an empty list, because the if returns the wrong value.Its test checks cur->next, which is one node ahead, so the last node is never counted.It starts cur at head->next, so the first node is skipped.It counts the nodes but never returns the total, because count is not used after the loop.
2. 2. A caller runs this code. What goes wrong? ``cpp void remove_first(Node* head, int target) { Node* prev = nullptr; Node* cur = head; while (cur != nullptr && cur->value != target) { prev = cur; cur = cur->next; } if (cur == nullptr) return; if (prev == nullptr) head = cur->next; else prev->next = cur->next; delete cur; } ``

   The loop never stops when the target is the first node.delete cur runs before cur->value is read, so the value is lost.head is a copy of the caller's pointer, so head = cur->next leaves the caller's variable pointing at the deleted node.The != in the loop should be ==, so the search goes the wrong way.
3. 3. Which line is the bug in this remove_below? ``cpp void remove_below(Node*& head, int limit) { Node* prev = nullptr; Node* cur = head; while (cur != nullptr) { if (cur->value < limit) { if (prev == nullptr) head = cur->next; else prev->next = cur->next; delete cur; cur = cur->next; } else { prev = cur; cur = cur->next; } } } ``

   cur = cur->next; after delete cur; reads a node that was already given back.prev = cur; in the else branch should come before the if.The head parameter must be passed by value, not by reference.The if should test cur->value <= limit, so a node equal to the limit is removed.
4. 4. What does this insert_after do when p is the node holding 5 in the list 5 -> 6 -> 7? ``cpp void insert_after(Node* p, int value) { Node* fresh = new Node{value}; p->next = fresh; fresh->next = p->next; } ``

   It gives 5 -> 9 -> 6 -> 7, which is the list the caller wanted.It gives 5 -> 9 -> 9 -> 9, because fresh is copied into each node.It gives 5 -> 9, and the function frees nodes 6 and 7.Node 9 points to itself, and nodes 6 and 7 can no longer be reached from the head.
5. 5. What does this contains do when it is called as contains(h, 9) on the list 5 -> 6 -> 7? ``cpp bool contains(Node* head, int target) { for (Node* cur = head; cur != nullptr; cur = cur->next) { if (cur->value = target) return true; } return false; } ``

   It returns true, and the value of node 5 becomes 9.It returns false, and the list is unchanged.It does not compile, because if cannot hold an assignment.It returns true, and the value of node 7 becomes 9.