变量的多个实例（静态，非静态）

Question

I came across this piece of C code:

main(){
static int i=0;
i++;

if(i<=5){
      int i = 3;
      printf(" %d",i);
      main();
    }
}

1. First, I expected this code to give a compilation error as there are multiple definitions of the variable i . But, it compiled and ran successfully and gave this output.

 3 3 3 3 3

2. Observing the output, 3 is printed exactly 5 times, which means the loop was counted from 0 to 5 thus implying that for the if condition , the first definition (static) of i was used.

3 However, the value being printed is 3 which is the 2nd definition of i .

So the variable label i is referring to two different instances in memory. One is being used as the loop count, to do the increment, and the other is the value being printed.

The only way I can somehow explain this is:

1. int i = 3 (the 2nd definition) is repeated in every recursive call. That instance of i is created when the function is called, and killed when the next recursive call is made. (Because of static scoping). printf uses this instance, as it is the latest definition(?)

2. When entering a new level of recursion, i++ is being done. Since there is no other way to resolve this i , it uses the static "instance" of i , which is still "alive" in the code as it was defined as static.

However, I'm unable to exactly put a finger on how this works..can anyone explain what's going on here, in the code and the memory?

How is the variable binding being done by the compiler here?

Answer 1

The inner scope wins.

Example:

int i = 1;
void foo() {
    int i = 2; // hides the global i

    {
        int i = 3; // hides local i
    }
}

This behavior is by design. What you can do is use different naming conventions for variable scopes:

• global/statics
• function arguments
• locals
• class/struct members

Some compilers will issue a warning if you hide a variable in the same function (eg function argument and regular local variable). So you the max warning level on your compiler.

Answer 2

The {} of the if statement creates a new block scope and when you declare i in that scope you are hiding the i in the outer scope. The new scope does not start until { and thus the if statement is referring to the i in the outer scope.

Hiding is covered in the draft C99 standard section 6.2.1 Scopes of identifiers paragraph 4 says ( emphasis mine ):

[...]If an identifier designates two different entities in the same name space, the scopes might overlap. If so, the scope of one entity (the inner scope) will be a strict subset of the scope of the other entity (the outer scope). Within the inner scope, the identifier designates the entity declared in the inner scope; the entity declared in the outer scope is hidden (and not visible) within the inner scope .

Answer 3

The compiler will always use the most local version of a variable when more than one variable of that name exists.

Outside the loop, the first i is the only one that exists, so it is the one that is checked. Then a new i is created, with value 3. At this point whenever you talk about i it will assume you mean the second one, since that's more local. When you exit the loop, the second i will go out of scope and be deleted and so if you start talking about i again it will be the first one.