In the book Jumping Into C++, chapter 25, (page 360-370) we have these codes as examples:

Code:
class LinkedList
{ 
   public: 
           LinkedList (); // constructor
          ~LinkedList (); // destructor, notice the tilde (~) 
          void insert (int val); // adds a node
    private: 
             LinkedListNode *_p_head;
 };

class LinkedListNode
{ 
     public:
           ~LinkedListNode ();
             int val;
             LinkedListNode *p_next;
};

LinkedListNode::~LinkedListNode ()
{
         delete p_next;
}

LinkedList::~LinkedList ()
{
         delete _p_head;
}
In the book it says following:

Believe it or not, this code initiates a chain of recursive function calls. What happens is that the call to delete invokes the destructor for the object pointed to by p_next (or does nothing, if p_next is NULL). That destructor, in turn, calls delete and invokes the next destructor. But what’s the base
case? How will this chain of destruction end? Eventually p_next will be NULL, and at that point, the call to delete will do nothing. So there is a base case — it just happens to be hidden inside the call todelete. Once we have this destructor for LinkedListNode, the destructor for the LinkedList itself simply needs to invoke it:

Code:
LinkedList::~LinkedList () 
{ 
         delete _p_head; 
}


This call to delete starts the recursive chain, until the end of the list
I didn't understand the bolded text (I have bolded it). How this recursion deletes the nodes in the list, if what it does when calling delete is to just invoke the next constructor?

Does it just call the next and next constructor until it reaches NULL wtihout deleting the nodes?

Won't this code just "walk through" the nodes in the linked list without deleting any of them?