Comments on: Prefer prefix operators over postfix

By: Mark C

Mark C — Thu, 10 Nov 2011 20:50:37 +0000

“When you write postfix, you are communicating that
you need the old value after the increment.”

100% baloney, unless you also consider that when you write prefix, you are “communicating that you need the NEW value BEFORE the increment.”

By: rasika

rasika — Wed, 27 Jul 2011 06:01:36 +0000

Explaination in well manner…

By: Bennett

Bennett — Fri, 22 Oct 2010 09:01:46 +0000

@saint, that’s your optimising compiler at work.

By: G.U. "saint" Lauri

G.U. "saint" Lauri — Thu, 21 Oct 2010 17:07:40 +0000

I wrote the same loop twice, the index is used for output and computation. In one loop I used the prefix operator, in the other the suffix… Who can say who is who ?

.p2align 4,,7
.p2align 3
.L2:
movl %ebx, 8(%esp)
addl $1, %ebx
movl $.LC1, 4(%esp)
movl $1, (%esp)
call __printf_chk
cmpl $10, %ebx
jne .L2

.p2align 4,,7
.p2align 3
.L3:
movl %ebx, 8(%esp)
addl $1, %ebx
movl $.LC1, 4(%esp)
movl $1, (%esp)
call __printf_chk
cmpl $10, %ebx
jne .L3

By: Michael Chun

Michael Chun — Sun, 23 May 2010 11:00:55 +0000

Good stuff! Very well explained

By: Math

Math — Thu, 21 Aug 2008 15:54:50 +0000

Man… what a bummer. I mostly like the postfix operator for its aesthetics in code rather than its “save the old value” functionality, though I do use that occasionally too. I wish I had known the efficiency stuff in this article before I started running rampant with postfix with almost all my code. Now since I’m anal retentive, whenever I see i++, for example, I have to switch it to ++i.

By: ford prefix

ford prefix — Thu, 24 Apr 2008 22:54:53 +0000

The real reason to use prefix rather than postfix is because when you have a choice,
you should write exactly what you mean. When
you write postfix, you are communicating that
you need the old value after the increment. If you don’t need the value, why in the world wold you write it that way? If you don’t need the old value, use prefix.

Would you leave statements such as this:

{
int f = 0;
// …
f + 1;
f – 1;
// use f for real purpose
}

laying around in your code?

Say what you mean, mean what you say.

By: Bennett

Bennett — Fri, 29 Jun 2007 04:32:32 +0000

Good stuff, Sam. I just talk about what compilers might do, but you go the extra mile and find out. Nice to know that gcc optimises simple loops. But I also said:

In this case, of course, the compiler will probably realize that the value of the expression is not used, and can therefore avoid the copy.
…
Even if i is an integral type today, somebody might change it tomorrow to be some relatively heavyweight class type like an iterator: suddenly, you get a new object created and destroyed every time through the loop.

And don’t forget about visibility and consistency too, which in most cases are more important than efficiency anyway.

By: Sam Danielson

Sam Danielson — Thu, 28 Jun 2007 11:30:03 +0000

Here’s the objdump -d a.out for a postfix loop with a simple body. I compiled this with with gcc 4.1.2, with the -ggdb option.

The machine isn’t storing a copy of i, it just puts the i++ after the body of the loop.

for (i = 0; i
804835e: 8b 45 f4 mov 0xfffffff4(%ebp),%eax
8048361: 89 45 f8 mov %eax,0xfffffff8(%ebp)
8048364: 83 45 f4 01 addl $0×1,0xfffffff4(%ebp)
8048368: 83 7d f4 09 cmpl $0×9,0xfffffff4(%ebp)
804836c: 7e f0 jle 804835e