Programming @programming.dev milon @lemm.ee 11mo ago

Why does the for loop repeat in this recursion?

I used the debugger to examine this code but not understanding a couple areas.

Why does the for loop repeat after it exits to print a new line? If it exits the loop, shouldn't it be done with it?
Why is n incremented and not i as stated with i++?


int main(void)
{
    int height = get_int("Height: ");

    draw(height);
}

void draw(int n)
{
    if (n &lt;= 0)
    {
        return;
    }

    draw(n - 1);

    for (int i = 0; i &lt; n; i++)
    {
        printf("#");
    }
    printf("\n");
}

You're viewing a single thread.

30 comments

This code has a recursive call (function calls itself) within the function so that has to be taken into account when tracing it

This would make the function execute multiple times so the for loop would end up executing multiple times.

Lets say main calls draw with a height value of 10 (draw(10)). First it sees that n is greater than 0 so it keeps going. Then it calls the draw function with a value of 10 - 1 aka 9. Now its executing in the draw(9) function. Greater than 0 so continues and calls draw(8). etc. all the way down to draw(0) where it sees that n is equal to 0 so returns out of the function due to the return statement.

Now that draw(0) finished executing draw(1) can keep going and goes to the for loop. Here it prints 1 # and then prints a new line (and then returns since it hit the end of the function). Now that draw(1) is done draw(2) can keep going and prints 2 #'s and then prints a new line (and then returns). This keeps going all the way up to the initial draw call, draw(10) which prints 10 #'s and then a new line, returns, and then the main function keeps going but theres nothing after that so it returns and the execution ends.

The effect from coming back after the recursive calls makes it seem like n is increasing but its just different calls to the same function. i is taken into account for but printing the amount of #'s since thats whats within that loop
- Why does the for loop return when it hits the end of the function? Isn't the recursive portion already completed in draw(n - 1)? The rest of it is just normal non-recursive code if I understand it correctly.
  
  No, the moment that draw(9) is called, draw(10) goes on pause while draw(9) runs, which pauses when it calls draw(8) … which repeats (or recurses) until draw(0) gets called. Then it returns which returns to draw(1). The draw(1) un-pauses and does the #\n bit and returns to draw(2), which un-pauses and does ##\n and so forth until draw(10) does ##########\n
  
  Gotcha. Thanks for the explanation.
  
  When the draw function calls itself it yields control to that new function its calling. When that function ends it takes back control and continues doing what it was doing.
  
  This means all of the for loops in all of the functions will execute. Draw(1) will do the for loop and then return as it hits the end of the function (standard behaviour when you reach the end of a function even if theres no return statement). Then draw(2) will do the for loop as it gets back control now that draw(1) is done and then return, etc. all the way up
  
  All parts of a function are recursive, theres no such thing as a non recursive part
  
  The for loop doesn't return, it's just that when control flows to the end of the function, returning is the standard behaviour. It has nothing left to do, so control is returned to the calling code.
  
  The recursive portion is begun with draw(n - 1), but then you have a new for loop, because the same function has been called again. That's what recursion is. Nothing in this function is non-recursive. It calls itself, so all of the code it contains could be happening from the initial call, or within a recursive call. When draw(3) is called, you will get 3 for loops. You will actually get 4 draw calls, but the last one will be draw(0) which returns immediately.
  
  It's confusing slightly because it works in reverse to what you'd expect. The operational part of the code - the part that does the drawing - only completes after the recursion is finished. That's why it does draw(1) first, to make the pyramid right way up.
  
  I don't know that I've ever done recursion like this. It seems deliberately fancy and somewhat confusing for a new learner.
  
  Imagine if you put the for loop before the recursive call. What would happen? You would draw three first, then decrease, so you would have an inverted pyramid. That would be easier to understand, but it would also not make a pyramid.
  
  This is all a really great example of how The Stack works. As the loop recurses it continually adds to the program stack in memory and then plays the next “item” in the stack. There is a specific limit to recursion as well based on this principle.

30 comments