Evaluation of constants in for loop condition

Question

for(int i = 0; i < my_function(MY_CONSTANT); ++i){
    //code using i
}

In this example, will my_function(MY_CONSTANT) be evaluated at each iteration, or will it be stored automatically? Would this depend on the optimization flags used?

will be evaluated at each iteration. Better to store it as a variable. — lakshmen, Oct 14 '14 at 14:10
possible duplicate of [loop condition evaluation](http://stackoverflow.com/questions/1242185/loop-condition-evaluation) — SirGuy, Oct 14 '14 at 14:11
@Basilevs, I don't think that changes things here, the expression (whatever that expression is) needs to be re-evaluated each time. In particular [this](http://stackoverflow.com/a/1242208/1277769) answer sums it up nicely I think — SirGuy, Oct 14 '14 at 14:21

score 10 · Accepted Answer · answered Oct 14 '14 at 14:12

It has to work as if the function is called each time.

However, if the compiler can prove that the function result will be the same each time, it can optimize under the “as if” rule.

E.g. this usually happens with calls to .end() for standard containers.

General advice: when in doubt about whether to micro-optimize a piece of code,

Don't do it.
If you're still thinking of doing it, measure.
Well there was a third point but I've forgetting, maybe it was, still wait.

In other words, decide whether to use a variable based on how clear the code then is, not on imagined performance.

Thank for the additional advice. When I was writing my question I had in mind that `MY_CONSTANT` was predefined by a '#define` instruction and reading the question tied above to my own, it seems that a recent compiler would store it. Many thanks! — Learning is a mess, Oct 14 '14 at 14:17

score 3 · Answer 2 · answered Oct 14 '14 at 14:11

3

It will be evaluated each iteration. You can save the extra computation time by doing something like

const int stop = my_function(MY_CONSTANT);
for(int i = 0; i < stop; ++i){
    //code using i
}

answered Oct 14 '14 at 14:11

Cory Kramer

114,268
16
167
218

1

There's even no need to polute the surrounding scope: `for(int i = 0, stop = my_function(MY_CONSTANT); i < stop; ++i)`. Most of my `for` loops tend to look like this recently. – Angew is no longer proud of SO Oct 14 '14 at 14:21

score 2 · Answer 3 · edited May 23 '17 at 11:57

A modern optimizing compiler under the as-if rule may be able to optimize away the function call in the case that you outlined in your comment here. The as-if rule says that conforming compiler only has the emulate the observable behavior, we can see this by going to the draft C++ standard section 1.9 Program execution which says:

[...]Rather, conforming implementations are required to emulate (only) the observable behavior of the abstract machine as explained below.5

So if you are using a constant expression and my_function does not have observable side effects it could be optimized out. We can put together a simple test (see it live on godbolt):

#include <stdio.h>

#define blah 10

int func( int x )
{
  return x + 20 ;
}

void withConstant( int y )
{
  for(int i = 0; i < func(blah); i++)
  {
    printf("%d ", i ) ;
  }
}

void withoutConstant(int y)
{
  for(int i = 0; i < func(i+y); i++)
  {
    printf("%d ", i ) ;
  }
}

In the case of withConstant we can see it optimizes the computation:

cmpl    $30, %ebx   #, i

and even in the case of withoutConstant it inlines the calculation instead of performing a function call:

leal    0(%rbp,%rbx), %eax  #, D.2605

score 1 · Answer 4 · answered Oct 14 '14 at 15:05

If my_function is declared constexpr and the argument is really a constant, the value is calculated at compile time and thereby fulfilling the "as-if" and "sequential-consistency with no data-race" rule.

constexpr my_function(const int c);

If your function has side effects it would prevent the compiler from moving it out of the for-loop as it would not fulfil the "as-if" rule, unless the compiler can reason its way out of it.

The compiler might inline my_function, reduce on it as if it was part of the loop and with constant reduction find out that its really only a constant, de-facto removing the call and replacing it with a constant.

int my_function(const int c) {
    return 17+c; // inline and constant reduced to the value.
}

So the answer to your question is ... maybe!

Evaluation of constants in for loop condition

4 Answers4