CurrentElement->next = CurrentElement->next->next (UNDEFINED?)

[Deniz Bahar]

Hi,

I'm working with a single linked list and want to delete elements by
searching through the list (starting form the HEAD) then finding the
element, then doing the following:

NewElement = CurrentElement->next;
CurrentElement->next = NewElement->next->next;
free(NewElement );

Does the double ->next invoke undefined behaviour (sequence points
etc)?



========
The full function follows:
========

typedef struct ElementTag Element;

extern Element *NewElement;
extern Element *CurrentElement ;
extern Element *HeadElement;

/* Finds and deletes person- returns 1, returns 0 for failure) */
int
FindDeletePerso n(const char *name)
{
if(!strcmp(Head Element->Person.name, name))
{
NewElement = HeadElement->next;
free(HeadElemen t);
HeadElement = NewElement;
return 1;
}
else
{
CurrentElement = HeadElement;
while(CurrentEl ement->next)
{
if(!strcmp(Curr entElement->next->Person.name, name))
{
NewElement = CurrentElement->next;
CurrentElement->next = NewElement->next->next;
free(NewElement );
return 1;
}
CurrentElement = CurrentElement->next;
}
}
return 0;
}

[Quentarez]

Re: CurrentElement->next = CurrentElement->next->next (UNDEFINED?)

On 8 Mar 2005 14:26:21 -0800, Deniz Bahar wrote:
[color=blue]
> Hi,
>
> I'm working with a single linked list and want to delete elements by
> searching through the list (starting form the HEAD) then finding the
> element, then doing the following:
>
> NewElement = CurrentElement->next;
> CurrentElement->next = NewElement->next->next;
> free(NewElement );
>
> Does the double ->next invoke undefined behaviour (sequence points
> etc)?
>[/color]

<snip>

You can use as many ->next as you wish, as long as the ->next link exists.

[Andrey Tarasevich]

Re: CurrentElement-&gt;next = CurrentElement-&gt;next-&gt;next (UNDEFINED?)

Deniz Bahar wrote:[color=blue]
> ...
> I'm working with a single linked list and want to delete elements by
> searching through the list (starting form the HEAD) then finding the
> element, then doing the following:
>
> NewElement = CurrentElement->next;
> CurrentElement->next = NewElement->next->next;
> free(NewElement );
>
> Does the double ->next invoke undefined behaviour (sequence points
> etc)?
> ...[/color]

No. Firstly, you are not accessing the same object twice.
'CurrentElement->next' as an lvalue is neither 'NewElement' nor
'NewElement->next' nor 'NewElement->next->next'. There's no problem with
sequence points here.

However, the code itself doesn't do what it is supposed to do. Doing

NewElement = CurrentElement->next;
CurrentElement->next = NewElement->next->next;

will exclude _two_ consecutive elements from the list (both 'NewElement'
and 'NewElement->next'), not one. Apparently, this is not what you
wanted to do. You probably intended to do either

NewElement = CurrentElement->next;
CurrentElement->next = NewElement->next;

or

NewElement = CurrentElement->next;
CurrentElement->next = CurrentElement->next->next;

That would exclude only one element from the list.

Now in that last version the value of 'CurrentElement->next' is accessed
twice (once to read it and once to modify it), which might rise the
question about sequence points etc. However, it this case everything is
fine too. The old value of 'CurrentElement->next' is read for the sole
purpose of determining its new value.

--
Best regards,
Andrey Tarasevich