how many times are the following functions called?

I have the following exercise program from a book. The book states that for values x=10 and y=100, functions; min, max, incr and square are called 1, 91, 90 and 90 respectively. However, to me it looks like they are being called the following number of times, 1, 1, 1 and 0. Can someone explain to me the book numbers. Thanks.

#include <stdio.h>

int min(int x, int y){
    return x < y ? x : y;
开发者_运维技巧}

int max(int x, int y){
    return x > y ? y : x;
}

void incr(int *xp, int v) {
    *xp += v;
}

int square (int x){
    return x*x;
}

int main(void){
    int i;
    int x = 10;
    int y = 100;
    int t = 0;

    for (i = min(x, y); i < max(x, y); incr(&i, 1)){
        t += square(i);
        printf("test %i", t);
    }
}

---

It really depends on the compiler and optimisation settings.

Compiling this program (after fixing the max() function to return the maximum) with -O3 shows that none of the functions are actually called. The compiler can see that the loop goes from 10 to 100, and that the variable is incremented by 1.

Never assume that a function is called. You tell the compiler what you want the program to do, but the compiler can choose to do it any way it wants to.

By the way, without fixing max(), the compiler could see that this is an empty loop, and produced a main() function that simply returned without setting any variable or doing anything (again, with -O3).

---

Well the loop is really (as x and y don't change):

for (i = 10; i < 100; incr(&i, 1))

The the first statement executes only once - that's why min is executed 1 time. The stop condition is executed once at the beginning and then after each iteration - so 91 times. The third statemnt is executed at the end of each iteration - so 90 times.

So the book is correct.

---

Feels like homework so I don't want to provide a full solution, but here's a hint... The key lies in understanding that max is evaluated (called) at the end of each loop iteration because the result of max can change after each loop iteration.

The loop will continue as long as i is less than max(x, y) for a given loop iteration.

---

In a for loop, there are 3 parts, initialization, continue condition, increment.

for(initialization; continue condition; increment) {
    body;
}

The loop does this:

1. Do initialization part
2. Check continue condition (exit if true)
3. Execute code in body of for loop
4. Execute increment condition
5. Go back to 2

So if we walk through it, min is called once (initialization), and until the condition is met, max is called each time (continue condition). This will happen from i = 10 to i = y, which is 91 times (once at the beginning, and once at each iteration).

The increment part is called exactly once for each iteration, but not called initially, so it would get called 90 times (100 - 10).

The square function will happen the same number of times that increment is called (because it is called before increment, but once per iteration).

---

The second two expressions in a for loop are evaluated every time through the loop. The second expression is run every time to check if the loop should continue, and the last expression is intended to change the state of the loop. For example:

for (int x = 0; x < 100; ++x) { /* ... */ }

The x < 100 expression has to be evaluated each time through the loop to see if you changed it. The ++x needs to be evaluated every time because it's what's incrementing x.

The for (expression 1; expression 2; expression 3) loop is really just a shortcut for the common pattern:

{
    expression 1;
    if (expression 2)
    {
        do //Do-while + if to demonstrate how `break` and `continue` affect things
        {
            //loop body
            expression 3;
        }
        while(expression 2)
    }
}