Separate scope for switch cases with static variables with the same name

Question

update: I've now re-tested both a simplified test case and the full code with the shared names reinstated, and it works correctly. There probably was some other error somewhere else in my code which is now fixed. Sorry for wasting your time and effort; will never post without a working test case in the future. Mea culpa.

---

I have a C++ function which I call repeatedly. It has the following snippet in it

     switch(c)
     {
     case 1:
        {
          static int i = 0;
          if ( ... )  { i = 0; }
          .... 
          break;
        }
     case 2:
        {
          static int i = 0;
          if ( ... )  { i = 0; }
          .... 
          break;
        }
     case 3:
        {
          static int i = 0;
          if ( ... )  { i = 0; }
          .... 
          break;
        }
     }

The idea is that it must remember its state per each case, and sometimes it must reset it.

It didn't work properly. When I was debugging it (MSVC++ 2010 Express Edition) I noticed that each i was not behaving independently and their values were changing seemingly by themselves; moreover when the re-set condition was hit, the corresponding if was entered OK but the i = 0; statement was just ... skipped over!!! And the "locals" window showed i with its previous value, unchanged (while the current statement was the next one, still inside the if). Other statements inside the if were executing properly.

When I renamed each i with a unique name (i1, i2, i3), the problem went away.

Is this some bug, or some language feature that I should know? I thought each block { ... } defines independent scope. What is going on here? Would it work in C?

edit: sorry for not constructing the test case. Will do so, and report back later.

Answer 1

This sounds like a bug in your code or interpretation. I can well imagine a "watch window" feature in your debugger getting this wrong, since blocks don't have names and will therefore be difficult to identify in text.

Local variables with static storage duration are bound by block scope.

Here's proof that they do not have function scope:

[C++11: 3.3.5/1]: Labels (6.1) have function scope and may be used anywhere in the function in which they are declared. Only labels have function scope.

And here's a practical demonstration:

#include <iostream>

void f(const int i)
{
    switch (i) {
        case 3: {
            static int x = 0;
            std::cout << x;
            x = 3;
            std::cout << x << ' ';
            break;
        }

        case 4: {
            static int x = 0;
            std::cout << x;
            x = 4;
            std::cout << x << ' ';
            break;
        }
    }
}

int main()
{
    f(3);
    f(4);
}

// Output: 03 04

This shows that when the second case is entered, you are working with a different local, static variable x. Otherwise you would see 03 34.

Live demo using GCC 4.8; I get the same result with Visual Studio 2012.

Answer 2

Static variables inside the function have a block scope and they are persistent over consecutive calls to it. You cannot declare two variables with same name in same scope but you can do it if they are in different scopes denoted as

{}

which is in your case.

switch(c)
 {
 case 1:
    {
      static int i = 0;
    }
 case 2:
    {
      static int i = 0;
    }
 case 3:
    {
      static int i = 0; 
    }
 }

So this should work as you expected and thus probably this is the bug in compiler, debugger (or somewhere else what is hard to guess without more information given) which treats all these static variables as the same variable. This is why changing names of these variables fixes your problem.

Answer 3

I had to check for myself, thought I'll share my little test. the variables are only visible inside the case curly brackets. and the same variable name can be declared inside another case and it won't overwrite the other variable.

the variables are not visible in the function though, only inside the curly braces in the switch statement.

#include<stdio.h>
int call_switch(int);
int main()
{
call_switch(2);
call_switch(3);
call_switch(2);
call_switch(3);
return 0;
}

int call_switch(int a){
switch(a)
{ 
   case 2:
   {
     static int i = 5;
     i++;
     printf(" i declared as 5     %d\n",i);
     break;
   }
   case 3:
   {
     static int i = 10;
     i++;
     printf("i declared as 10   %d\n",i);
     break;
   }
}
  // printf("%d",i ); not visible here
  return 0;

}

output was

i declared as  5     6
i declared as 10    11
i declared as  5     7
i declared as 10    12

Answer 4

static variables inside a function have function scope. The variable is visible in the whole of the function.

static variables outside the function have file scope, which is visible inside the file, but not across files.