Are same static variables used for each recursive call to a function? [duplicate]

Question

As per my understanding, each called function has some memory allocated to it in the program stack, and this holds true even if the same function calls itself recursively (i.e, each invocation has it's own memory in program stack). Please answer the following two questions arising from my program below:

If a variable is declared static in a function, will the same variable/same copy be used for all recursive calls of that function?

If the variable is not declared static (e.g, simply "int x"), will each recursive call to the function have its own copy of that variable? If yes, is that the way it normally happens when a function is called from other function, including the recursive calls?

#include<stdio.h>
#include<stdlib.h>

int main()
{
    static int x=0;
    x++;
    printf("Team %d\n",x);
    if(x<10)
        main();
    else
        exit;
}

Output:

Team 1
Team 2
Team 3
Team 4
Team 5
Team 6
Team 7
Team 8
Team 9
Team 10

Answer 1

If a variable is declared static in a function, will the same variable/same copy be used for all recursive calls of that function?

Yes, as your code sample shows

If the variable is not declared static (e.g, simply "int x"), will each recursive call to the function have its own copy of that variable? If yes, is that the way it normally happens when a function is called from other function, including the recursive calls?

Yes, each call will have it's own stack frame with a copy of each local variable. This is what happens for every function call, whether they are recursive or not. And yes, this very principle allows, among other things, recursion.

Answer 2

Static variables live the life of the program, there is only one copy

Locals (Autos) get a new copy on the stack each function call.

Parameters passed by value get a new copy as well.

Parameters passed by reference (pointer) point to the copy that's passed to them. Therefore if it's a local in a recursive execution, it might be a unique copy; but usually it's a reference to a variable that called the function before the recursion started, therefore, the same copy.

It's better to do the functionality you're doing by passing a pointer to a variable, you have more control over subsequent instances of recursion.