C++ operator precedence

Question

Lets say we have an iterator (iter) over a list of pointers to memory assigned to heap space, if I do that

delete (*iter++)

am I right that the precedence is first dereference iterator to get memory address then free the space and then increment the iterator to free the next element ?

Do not write code that requires too much though to figure out what is going on - better to spread it over a few lines. That way you will prevent errors either now or in the future. — Ed Heal, Mar 08 '13 at 13:47
Just to make sure I understand what is going on behind the scenes... — user1845360, Mar 08 '13 at 13:56

score 4 · Answer 1 · answered Mar 08 '13 at 13:38

Although ++ has higher precedence than *, the side effects of post-increment ++ are applied after the dereference operator * has used the iterator's value. That is the behavior of the post-increment, or suffix ++, (as opposed to the pre-increment, or prefix ++). This rule applies to iterators as well as the "plain" pointers.

score 3 · Accepted Answer · answered Mar 08 '13 at 13:42

The effect is as you write, but it's achieved using a slightly different sequence:

The post-increment has highest precedence, so it's evaluated first. However, its return value (which is processed by further operators) is the value of iter before the increment.
Dereference is evaluated next, returning pointer to which the non-incremented value of iter was "pointing."
delete is evaluated last, and the pointer is deleted.

score 1 · Answer 3 · answered Mar 08 '13 at 13:45

The precedence is actually the reverse, and if the iterator is of class type (with overloaded operators) this is the order of calls to the operator functions:

The increment operator is called to increment the iterator. It returns a copy of itself before the increment.
The dereference operator is called on the temporary iterator and returns the value of the list item to which iter used to call.
The pointer just returned is deleted, i.e. the pointed-to object is destructed and then the memory freed.

score 0 · Answer 4 · answered Mar 08 '13 at 13:40

The line is equivalent to this:

delete (*(iter++))

But since postfix increment returns the original value, you are still dereferencing the original value of iter. Therefore, if iter points at a pointer to a dynamically allocated object, the delete will destroy that object. Then iter will be left pointing to the next pointer along.

C++ operator precedence

4 Answers4

Linked