What is better style: ++x or x++ in for loops

Question

I was having a discussion with a stubborn person I know over which of these two forms was more semantically correct, although there is no logical difference to the code:

1.

for(int x = 0; x < 10; x++)
// do something

2.

for(int x = 0; x < 10; ++x)
// do something

Is it better to pre-increment or post-increment in a for loop?

Does this answer your question? [Difference between pre-increment and post-increment in a loop?](https://stackoverflow.com/questions/484462/difference-between-pre-increment-and-post-increment-in-a-loop) — Flori Bruci, May 22 '20 at 12:26
No @FloriBruci that one simply explains the process without commenting on the style of the two alternatives. — Ethereal Unagi, May 22 '20 at 12:30
This is a very opinion-based question but generally speaking no one cares when it comes to simple integers and Microsoft uses `++it` in their implementation of the standard library whenever the thing getting incremented is an iterator. Make of that what you will. — Big Temp, May 22 '20 at 12:39
As a rule of thumb, prefer `++it` over `it++` unless you have a specific reason not to. — Aykhan Hagverdili, May 22 '20 at 12:40

Werner Henze · Accepted Answer · 2020-05-23T08:19:29.340

4

If you don't need the side effect of post increment, then the pre increment version is the better choice.

In case of an int it does not result in different code, but in case of an iterator you probably get better performance with pre increment because post increment needs to create a temporary copy of the original iterator. You can easily see that when comparing pre increment

class T {
    T& operator++() {
        this-> .... // do the increment
        return *this;
    }
}

with the post increment

class T {
    T operator++(int) {
        const T old{ *this };
        this-> .... // do the increment
        return old;
    }
}

If the iterator is just a pointer then the compiler might be able to optimize so much that you don't see a difference, but if the iterator is more complex, then you will see a difference.

Of course the same applies to prefix and postfix decrement.

edited May 23 '20 at 08:19

answered May 22 '20 at 12:27

Werner Henze

16,404
12
44
69

This depends on the underlying processor architecture and cannot be generalized. – Joel Bodenmann May 22 '20 at 12:28
6

`but in case of an iterator you probably get better performance with post increment because pre increment needs to create a temporary copy of the original iterator.` Quite the opposite. It is the post increment which necessitates the copy. That said, it too can be optimised away. – eerorika May 22 '20 at 12:32
I would say, you expect copying to optimize away. Iterators are designed to be passed by value, so iterators copying is lightweight operation prone to optimization. So actually there's no difference for iterators either. – Alex Guteniev May 22 '20 at 12:36
@eerorika Of course, you are right. I corrected my answer. – Werner Henze May 23 '20 at 07:45

Bathsheba · Answer 2 · 2020-05-22T13:06:45.117

2

If a modern compiler with optimisations switched on produces different code for x++ and ++x for this particular case then you ought to switch compiler vendors.

I always write ++x since (i) the type of x might change to a non-POD in the future and x++ could take an expensive copy in such a case, (ii) because it buries a message in your code that you think about things like this, and (iii) because I'm old fashioned.

(I insist on ++x in my company.)

edited May 22 '20 at 13:06

answered May 22 '20 at 12:54

Bathsheba

231,907
34
361
483

I agree with all the other points, but how is `++x` old fashioned? – Aykhan Hagverdili May 22 '20 at 14:24
@Ayxan: Some early C compilers didn't optimise ++x for even an `int`. In this respect COBOL and FORTRAN were ahead of their time. – Bathsheba May 22 '20 at 14:46
You mean they didn't optimize `x++`? – Aykhan Hagverdili May 22 '20 at 14:48
@Ayxan: In the early days of C you had to hold the compiler's hand much more tightly than you do now. These days you almost need to get out of this habit and trust the compiler to make optimisations itself. – Bathsheba May 22 '20 at 14:50

Alex Guteniev · Answer 3 · 2020-05-22T12:30:35.880

1

Does not matter.

Might matter for iterators instead of ints, but actually does not matter to them either.

I'd yield to a stubborn person.

Or retreat by saying "i += 1" (but that may be worse for iterators)

edited May 22 '20 at 12:30

answered May 22 '20 at 12:27

Alex Guteniev

12,039
2
34
79

I know it doesn't matter but I was wondering which solution was more idiomatic. – Ethereal Unagi May 22 '20 at 12:28
@EtherealUnagi Neither. Both are equally idiomatic. Pre-increment is simpler to understand, so that is usually used. – eerorika May 22 '20 at 12:29

score 0 · Answer 4 · answered May 22 '20 at 12:57

// pre-fix operator
MyCustomClass& operator++()
{
    return *this;
}

// post-fix operator
MyCustomClass operator++(int)
{
  MyCustomClass tmp(*this);
  operator++();
  return tmp;
}

and as a best practice:

to be consistent with the built in operators, your built in postfix operator should return the old value, thar value is returned as a value and never as a reference but for prefix operators you should return a reference to the modified object.

You prefix operator is a no-op. – Bathsheba May 22 '20 at 13:05 — Bathsheba, May 22 '20 at 13:05

What is better style: ++x or x++ in for loops

4 Answers4