Re^7: quickness is not so obvious

[LanX]

I think the first time I saw an increment in a high level language was in a loop like

 for (j = 0; j < count; j++) { }

The existence of ++j was only a side node without immediate use case.

So maybe blame K&Rą for this implementation documentation causing a bias ultimately leading to an "it looks better" perception? (well most probably it even predates C ˛)

Anyway optimizing for such implantation details can bite you severely when processor technology advances.

For instance linearizing loops used to be a good idea till the memory access for the longer code was beaten by inline caches being able to hold the smaller loops in processor memory.

So who knows what comes next?

Personally I don't like post increment since it's a side effect sometimes causing weird undefined conditions, and in the world of concurrency side effects are the worst sin.

But in Perl at least I have to trust that it's optimized away in void and loop context.

updates

ą)

I found the oldest version in the net and it explicitly says:

This slightly more ornate example adds up the elements of an array:

        sum = 0;
        for( i=0; i<n; i++)
               sum = sum + array[i];

But actually ++i would work the same, this post-increment notation hides the fact that the increment is only executed at the end of the loop's body.

NB: like in Perl

  For Loops
       Perl's C-style "for" loop works like the corresponding "while" 
+loop;
       that means that this:

           for ($i = 1; $i < 10; $i++) {
               ...
           }

       is the same as this:

           $i = 1;
           while ($i < 10) {
               ...
           } continue {
               $i++;
           }

˛) according to WP it was invented for B.