Efficiency of a for loop

Question

I need the opinion of stack overflow to settle something that has been sitting in the back of my head about for loop efficiency. Now, when I began programming, "getting it to work" was a big priority and most of my for loops looked like this.

for (int i = 0; i < N; i++) {;}

Then I was tought, especially with C++ development that pre-increment saves you some calls, and considering that would be N calls and it doesn't alter the readability I got into the habit of.

for (int i = 0; i < N; ++i) {;}

This was good enough for a while, but focusing on the readability, and after reading some of Code Complete by Steve McConnell, I arrived at this.

for (int loop_index = 0; loop_index < loop_count; ++loop_index) {;}

And these variables change based on the context of the code. Then I read some of Effective C++ about built in types constructors and assignment. And basically that the difference between

int i = 42;

and

int i(42);

Is that the former one calls the constructor and the assignment operator while the latter only the constructor. So I got that into my routine whilst coding. So my question, is this the most efficient and readable way of writing a for loop:

for (int loop_index(0); loop_index < loop_counter; ++loop_index) {;}

You don't need opinions on matters of efficiency, you need cold hard facts. That of course, is my opinion. But people seem to love to waste time in data-free arguments on topics amenable to quantitative analysis here on SO, so don't let me stop you engaging in the practice. — High Performance Mark
– High Performance Mark, Commented Aug 8, 2012 at 13:36
For int, neither of these issues make any difference, and in practice copy-elision means that copy- vs. direct-initialisation is almost never a concern even for complicated types. Pre-increment is a good habit, since it can occasionally be more efficient, without affecting readibility. Long vs. short variable names are purely a matter of taste; personally, I find i easier to read than loop_index, but others will disagree. — Mike Seymour
– Mike Seymour, Commented Aug 8, 2012 at 13:45

bitmask · Accepted Answer · 2012-08-08 13:35:49Z

5

Actually,

for (int i = 0; i < N; i++) {;}

is fine. i is an int, so the compiler will optimise the post-increment away anyway. Whether you initialise an int with int i(42); or with int i = 42; is also a question of taste.

I would also call the iterator i, instead of loop_index. The former is ubiquitously understood, while the latter is strange.

If you are dealing with iterators, however, the picture changes. Chances are it++ will still be optimised to ++it, but here, I'd rather use pre-increment.

answered Aug 8, 2012 at 13:35

bitmask

35.2k17 gold badges107 silver badges174 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

juanchopanza · Accepted Answer · 2012-08-08 13:35:40Z

2

First of all, your last point is not correct. This line

int i = 42;

does copy initialization (see this related GoTW). There is no assignment there. For assignment you would need

int i;
i = 42;

Second, when dealing with builtins such as integer types, there will probably be no difference in the code produced by the compiler. You should profile the different options and see.

answered Aug 8, 2012 at 13:35

juanchopanza

228k35 gold badges421 silver badges493 bronze badges

Comments

milleniumbug · Accepted Answer · 2012-08-08 13:46:23Z

2

If you're not using iterators, it shouldn't matter, because compiler will translate this to the same code.

Addendum: If you're using iterators:

for(vector<int>::iterator i = a.begin(); i != a.end(); ++i)

Then ++i is i.operator++() and i++ is i.operator++(int) which can mean two different things.

BTW. You can measure performance if this is a problem.

edited Aug 8, 2012 at 13:46

answered Aug 8, 2012 at 13:35

milleniumbug

15.9k3 gold badges53 silver badges73 bronze badges

Comments

Michael Anderson · Accepted Answer · 2012-08-08 14:07:05Z

1

If you're using built in types, or most iterators, all of these will compile to the same code.

So I'd stick with the one that is most idiomatic to C++.

for (int i = 0; i < N; ++i) {;}

or if you want to be wordy ( but i and k are traditionally loop indices )

for (int loop_index = 0; loop_index < loop_count; ++loop_index) {;}

As evidence for my initial claim: These two pieces of code generate identical assembly code. ( g++ 4.0.1 on OS X compiled with g++ -Os -S test.cpp)

void f(int); // So that smart compilers can't optimise away the loop entirely.

void g()
{
  int N=100;
  // for( int i=0; i<N; i++)
  for (int i(0); i < N; ++i) 
  {
    f(i);
  }
}

For completeness, the generated code is:

.globl __Z1gv
__Z1gv:
LFB2:
    pushl   %ebp
LCFI0:
    movl    %esp, %ebp
LCFI1:
    pushl   %esi
LCFI2:
    xorl    %esi, %esi
    subl    $20, %esp
LCFI3:
L2:
    movl    %esi, (%esp)
    incl    %esi
    call    L__Z1fi$stub
    cmpl    $100, %esi
    jne L2
    addl    $20, %esp
    popl    %esi
    leave
    ret

edited Aug 8, 2012 at 14:07

answered Aug 8, 2012 at 13:34

Michael Anderson

74.3k9 gold badges148 silver badges196 bronze badges

3 Comments

tomasgudm Over a year ago

So there is no gain in having i(0) instead of i=0 ?

milleniumbug Over a year ago

Constructor taking single argument is called no matter if you write T x(a) or T x = a

WiSaGaN Over a year ago

@tomasgudm you really can't have two translation to assembly when i is an int.

ikh · Accepted Answer · 2012-08-08 13:44:12Z

0

While others have covered post- vs pre-increments and initializations quite well, I'd like to add that using int i in most cases is more readable than int loop_index, because that's what everyone else is using and expecting.

The only cases when you may want to call it something else is when you have multiple loops, and complicated interactions between the loop indexes. For example

for (int row = 0; row < rows; row++) {
    for (int column = 0; column < columns; column++) {
        stuff[row * columns + column] = calc_stuff(row, column);
    }
}

answered Aug 8, 2012 at 13:44

ikh

2,4362 gold badges21 silver badges30 bronze badges

1 Comment

bitmask Over a year ago

When dealing with matrices, row and column is probably a good idea. Otherwise, I'd stick with i,j,k.

Lie Ryan · Accepted Answer · 2012-08-08 13:52:55Z

0

Efficient? No, it most likely will be the same, as most compilers will optimize that post increment and initialization for int and simple pointers. And as to whether loop_index is more readable than i, IMO, it's less readable for simple counters.

If it's an iterator though, it's different story, compilers can't always optimize overloaded post increment or double initialization of iterators. I also prefer using the iterated object's names for iterator, as that reflects what's being used better, using the object's name looks more natural when using the arrow -> operator to dereference the iterator.

answered Aug 8, 2012 at 13:52

Lie Ryan

65.3k14 gold badges103 silver badges151 bronze badges

Collectives™ on Stack Overflow

Efficiency of a for loop

6 Answers 6

Comments

Comments

Comments

3 Comments

1 Comment

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

6 Answers 6

Comments

Comments

Comments

3 Comments

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Related