Question

This program recursively calls the function tester.

#include <iostream>
 void tester();
 int i = 1;
 int k = 1;

 int main() {
   tester();
 }

 void tester() {
  while(i++ < 10)
    tester();
  std::cout << "called " << k++ << " times" << std::endl;
 }

I am surprised by this output :

called 1 times
called 2 times
called 3 times
called 4 times
called 5 times
called 6 times
called 7 times
called 8 times
called 9 times
called 10 times

and it is because this is the way i understand this program :

After the first call to tester from main it enters a loop. The first statement of the loop calls the function tester again, and this carries on.After looping 10 times the statement following the while loop should work i.e only once . So the output should be :called 1 times . But this isn’t actually happening ! Why ? How does this program work ?

Answer 1

The while body is executed only once in each recursive depth. The while is false when i is 10, which will be when tester () is called 10 times recursively. As the i is declared global, the i++ update will be visible to each call of tester ().

At the last recursive depth when the while condition is false, the last tester () call will return to its previous depth. At this moment, the next iteration of the while loop will be false as i is 10. The cout statement will be encountered after each while loop is terminated, which will sequentially print the values of k, incrementing at each recursive depth, as the recursion rolls back.

Manually trace what happens to understand the stuff.

UPDATE

Have a look at the execution output. Especially note the d parameter, which denotes the recursive depth. At each depth the while loop has iterated one time, upto the last “while is true, tester called” output. At depth 10, the while is false as it is 10, and first time it returns back the control to its previous depth level, (the first “return back” when i is 10). After it returns the control returns to the body of the while loop of the last level, from which the function was called (from which it just returned), and the next iteration of this loop will be false, (i is global and 10 or more), therefore this also returns. Similarly, at each recursive depth the 2nd iteration of while loop is false, and it keeps returning. Check out the output.

i   k  d
 1  1  0, call from main
 2  1  1, while is true, tester called
 3  1  2, while is true, tester called
 4  1  3, while is true, tester called
 5  1  4, while is true, tester called
 6  1  5, while is true, tester called
 7  1  6, while is true, tester called
 8  1  7, while is true, tester called
 9  1  8, while is true, tester called
10  1  9, while is true, tester called
11  1 10, returning back, print k    // this step the while is false in depth 10
12  2  9, returning back, print k    // from now on, as the recursion rolls back
13  3  8, returning back, print k    // the second iteration at each recursive 
14  4  7, returning back, print k    // depth will be executed, and each while
15  5  6, returning back, print k    // condition will be false, therefore it will
16  6  5, returning back, print k    // not call tester anymore and return the control
17  7  4, returning back, print k    // to the previous level. NOICE the `d' parameter
18  8  3, returning back, print k
19  9  2, returning back, print k
20 10  1, returning back, print k

And here is the test code. I hope the description is much clear now (?). Analyzing this will help.

#include <stdio.h>

int i = 1;
int k = 1;

void tester (int d)
{
  while (i++ < 10)
  {
    printf ("%2d %2d %2d, while is true, tester called\n", i, k, d);
    tester (d+1);
  }
  printf ("%2d %2d %2d, returning back, print k\n", i, k++, d);
}

int main (void)
{
  int depth = 0;
  printf ("i   k  d\n");
  printf ("%2d %2d %2d, call from main\n", i, k, depth);
  tester (depth + 1);

  return 0;
}