Variable definition inside switch statement

In the following code, why is the variable i not assigned the value 1?

#include <stdio.h>      

int main(void)
{   
    int val = 0;
    switch (val) {         
        int i = 1;   //i is defined here

        case 0:
            printf("value: %d\n", i);
            break;
        default:
            printf("value: %d\n", i);
            break;
    }
    return 0;
}

When I compile, I get a warning about i not being initialized despite int i = 1; that clearly initializes it

$ gcc -Wall test.c
warning: ‘i’ is used uninitialized in this function [-Wuninitialized]
    printf("value %d\n", i);
    ^

If val = 0, then the output is 0.

If val = 1 or anything else, then the output is also 0.

Please explain to me why the variable i is declared but not defined inside the switch. The object whose identifier is i exists with automatic storage duration (within the block) but is never initialized. Why?

Solution 1:

According to the C standard (6.8 Statements and blocks), emphasis mine:

3 A block allows a set of declarations and statements to be grouped into one syntactic unit. The initializers of objects that have automatic storage duration, and the variable length array declarators of ordinary identifiers with block scope, are evaluated and the values are stored in the objects (including storing an indeterminate value in objects without an initializer) each time the declaration is reached in the order of execution, as if it were a statement, and within each declaration in the order that declarators appear.

And (6.8.4.2 The switch statement)

4 A switch statement causes control to jump to, into, or past the statement that is the switch body, depending on the value of a controlling expression, and on the presence of a default label and the values of any case labels on or in the switch body. A case or default label is accessible only within the closest enclosing switch statement.

Thus the initializer of variable i is never evaluated because the declaration

  switch (val) {         
      int i = 1;   //i is defined here
      //...

is not reached in the order of execution due to jumps to case labels and like any variable with the automatic storage duration has indeterminate value.

See also this normative example from 6.8.4.2/7:

EXAMPLE In the artificial program fragment

switch (expr) 
{ 
    int i = 4;
    f(i); 

case 0: 
    i = 17; /* falls through into default code */ 
default:
    printf("%d\n", i); 
}

the object whose identifier is i exists with automatic storage duration (within the block) but is never initialized, and thus if the controlling expression has a nonzero value, the call to the printf function will access an indeterminate value. Similarly, the call to the function f cannot be reached.

Solution 2:

In the case when val is not zero, the execution jumps directly to the label default. This means that the variable i, while defined in the block, isn't initialized and its value is indeterminate.

6.8.2.4 The switch statement

4. A switch statement causes control to jump to, into, or past the statement that is the switch body, depending on the value of a controlling expression, and on the presence of a default label and the values of any case labels on or in the switch body. A case or default label is accessible only within the closest enclosing switch statement.

Solution 3:

Indeed, your i is declared inside the switch block, so it only exists inside the switch. However, its initialization is never reached, so it stays uninitialized when val is not 0.

It is a bit like the following code:

{
   int i;
   if (val==0) goto zerovalued;
   else goto nonzerovalued;
   i=1; // statement never reached
   zerovalued:
     i = 10;  
     printf("value:%d\n",i);
     goto next;
  nonzerovalued:
     printf("value:%d\n",i);
     goto next;
  next:
     return 0;
 }

Intuitively, think of raw declaration like asking the compiler for some location (on the call frame in your call stack, or in a register, or whatever), and think of initialization as an assignment statement. Both are separate steps, and you could look at an initializing declaration in C like int i=1; as syntactic sugar for the raw declaration int i; followed by the initializing assignment i=1;.

^{(actually, things are slightly more complex e.g. with int i= i!=i; and even more complex in C++)}