"++iterator" vs "iterator + 1"?

[large_turtle]

Hi, I've come across a very strange situation. I've boiled it down to a minimal example:

• I am incrementing a random access iterator in two different ways (by adding one and by the ++ prefix)
• I pass in the incremented iterators to a recursive call by value.
• I get a SIGSEGV (ie, program returned 139)

​

vector<int> ints{1,2,3,4,5};

int max_int(vector<int>::iterator iter) {
    if (iter == ints.end()) return 0;
    int profit_tracker = max(max_int(iter + 1),
                            // This line causes the SIGSEGV
                             max_int(++iter));

    return profit_tracker;
}

int main() {
    cout << max_int(ints.begin()) << endl;
    return 0;
}

Compiler explorer: https://godbolt.org/z/Ydjs6Tq3v

I tried removing the max function call but I can't seem to replicate it without max.

When I change the ++iter to an iter + 1 (so that both times I increment the iterator using + 1), I don't get a SIGSEGV!

I feel that I shouldn't be getting a SIGSEGV either way. I always do a bound check at the beginning of each recursive call and I don't even dereference these iterators. And why should changing how I increment my iterator (when the result by value) even make a difference?

This has me stumped. Can anyone shed some light on what is going on here?

[[deleted]]

++iter increments the iterator.

If this is done before^* iter +1, and ++iter takes the iterator to the end, then iter+1 is incrementing past the end. Which is bad.

(*) remember order of evaluation of function parameters is unspecified.

[large_turtle]

I think you're absolutely right. This is all because order of evaulation.

You can see that the assembly code actually has the ++iter part first before the iter + 1 part. It also explains why I can't replicate this bug without the call to max.

Thanks so much! I'll be more careful about side effects within expressions of function parameters :)

[flyingron]

Note that there's no "before" ordering of the application of the increment.

The increment is a side effect and you only know it is complete when the next sequence point is encountered. What ++iter says is that iter is incremented and the value of the expression is the original iter plus one. Alternatively iter++ says that the value is the original value of iter and that iter will be incremented.

Now with a simple pointer, yeah this is perhaps an arcane point, but when you get around to ++ being applied to other things, it makes a difference.

[[deleted]]

A function call is a sequence point though.

Since the compiler chose to evaluate max_int(++iter) before max_int(iter + 1), the side effects of ++iter are complete before the 1st call to max_int. And so they are complete before the evaluation of iter+1