Shall I optimize or let compiler to do that?

Question

What is the preferred method of writing loops according to efficiency: Way a)

   /*here I'm hoping that compiler will optimize this  
 code and won't be calling size every time it iterates through this loop*/
    for (unsigned i = firstString.size(); i < anotherString.size(), ++i)
    {
    //do something
    }

or maybe should I do it this way: Way b)

unsigned first = firstString.size();
unsigned second = anotherString.size();

and now I can write:

    for (unsigned i = first; i < second, ++i)
    {
    //do something
    }

the second way seems to me like worse option for two reasons: scope polluting and verbosity but it has the advantage of being sure that size() will be invoked once for each object.
Looking forward to your answers.

Answer 1

I usually write this code as:

/* i and size are local to the loop */
for (size_t i = firstString.size(), size = anotherString.size(); i < size; ++i) {
  // do something
}

This way I do not pollute the parent scope and avoid calling anotherString.size() for each loop iteration.

It is especially useful with iterators:

for(some_generic_type<T>::forward_iterator it = container.begin(), end = container.end();
    it != end; ++it) {
  // do something with *it
}

Since C++ 11 the code can be shortened even more by writing a range-based for loop:

for(const auto& item : container) {
  // do something with item
}

or

for(auto item : container) {
  // do something with item
}

Answer 2

In general, let the compiler do it. Focus on the algorithmic complexity of what you're doing rather than micro-optimizations.

However, note that your two examples are not semantically identical - if the body of the loop changes the size of the second string, the two loops will not iterate the same amount of times. For that reason, the compiler might not be able to perform the specific optimization you're talking about.