Thread: Array parsing, would you write it like this?

There is this a quite common question I see, should i do

Code:

for (int i = 0; i < vec.size(); ++i)
{
   ...
}

or

Code:

int len = vec.size();
for (int i = 0; i < len; ++i)
{
   ...
}

provided of course that the size of vector vec doesn't actually change in the loop and you cannot use the "for each" syntax as you want to have the counter i. I would say that you shouldn't optimize and that there are good chances the compiler will optimize anyway, but in the cases that optimization is a good choice, would you think that it is cleaner to write it instead like:

Code:

for (int len = vec.size(), i = 0, ; i < len; ++i)
{
   ...
}

It is a bit more cleaner for me since you typically read line by line when quickly viewing your code so this hides a bit the optimization which is desirable. It is also more to the point as you basically want to write "vec.size()" but you want to instruct the compiler to compute that once.

I just haven't really see it be coded that way so maybe it is just cleaner to me..

Originally Posted by cyberfish

I wouldn't be surprised if that actually makes it slower, since it makes the code more confusing to the compiler by not following established idiom (which compilers are trained to optimize).

Compiler writers do tend to assume programmers are inefficient so, if they are going to the trouble of optimising for some idiom, they'll probably put in the effort to detect and optimise variants of it.

Originally Posted by cyberfish

Since vector::size() is just an accessor for a member, it's a trivial optimization problem for modern compilers (function inlining).

There is no requirement that vector::size() accesses a single member. Yes, some library implementations to it that way, but some also do it to a notional equivalent of "return end() - begin();" which actually involves some calculation.

That said, with most implementations (albeit not all), all member functions of templates (like vector) are inlined, so there is scope for optimising all uses of vectors.

Originally Posted by cyberfish

If you really want to do it, I would prefer the first form, because it is an established idiom (for when calculating the number of iterations is actually expensive), so experienced programmers can read it faster.

Personally, I would use the second or the third.

Then again, I would probably something different with iterators, and breaking the loop into a separate function

Code:

     do_stuff(vec.begin(), vec.end());

where do_stuff() is defined as something like;

Code:

template<class Iter> void do_stuff(Iter begin, Iter end)
{
      while (begin != end)
      {
            // stuff required

            ++begin;
      }
}

This approach has the advantage that it is not possible to change vec (unless the programmer jumps through certain hoops).

There are some other options that C++-11 supports, but I'll leave them alone for now.

For vectors, prefer the first option, or use iterators from begin() to end(). For every implementation of a vector's size() or end() method that I've seen, the difference is going to be pretty much negligible. The cost of it is certainly going to be dwarfed by whatever you have in the loop.