Segmentation fault error singly linked lists C++

Question

Why is this getting an error:

int main(){
    lista *head, *x;
    head = nullptr;
    const int len = 3;
    int y[len] = {13, 4, 32};
    for(int i = len - 1; i >= 0; i--){
        x = new lista;
        x -> val = y[i];
        x -> next = head;
        head = x;
    }
    lista *p = head;
    // Changing lines are the next ones
    while(p->next != nullptr){
        p = p->next;
    }
    delete p;
    p = nullptr;

    print_lista(head);
    return 0;
}

But this is not:

int main(){
    lista *head, *x;
    head = nullptr;
    const int len = 3;
    int y[len] = {13, 4, 32};
    for(int i = len - 1; i >= 0; i--){
        x = new lista;
        x -> val = y[i];
        x -> next = head;
        head = x;
    }
    lista *p = head;
    // Changing lines are the next ones
    while(p->next->next != nullptr){
        p = p->next;
    }
    delete p->next ;
    p->next = nullptr;

    print_lista(head);
    return 0;
}

It doesn't work also in this way

while(p->next != nullptr){
    p = p->next;
}
p = p->next;
delete p;
p = nullptr;

This is the given error:

the monitored command dumped core

Segmentation fault

Isn't that the same thing? In the first case p is the next value of the second last element, in the second one p is the next value of the third last element, so p->next should be the next value of the second last element. This is the structure:

struct lista{
    int val;
    lista *next;
};

The error occurs in the 'delete...;' line

EDIT for Ben Voigt

Why? If I run a test like this:

lista *p = head;
while (p->next->next != nullptr){
    p = p->next;
}
cout << p->next;
lista *z = head;
while (z->next != nullptr){
    z = z->next;
}
cout << endl << z;

Both p and z are 0x5575909e3eb0, aren't them the same?

Answer 1

The problem is that in the failing code, you're deallocating the last item in the list, without removing it from the list. The result is a list containing a dangling pointer, so later operations that walk the list have undefined behavior.

The working code does detach it from the list.

---

To answer your thought experiment, let's make it even simpler.

std::cout << head << '\n';
lista* z = head;
std::cout << z << '\n';

z = nullptr;
// now how many items are in the list?
std::cout << head << '\n';
std::cout << z << '\n';

// are `head` and `z` really equivalent?
z = head;
head = nullptr;
// now how many items are in the list?
std::cout << head << '\n';
std::cout << z << '\n';