In C,why is multiple declarations working fine for a global variable but not for a local variable?

Question

In the following code, why do multiple declarations (and one definition) work fine for a global variable x but not for a local variable y which is inside the main() function? It shows the following 2 errors:

1) redeclaration of 'y' with no linkage

2) previous declaration of 'y' was here

Why is it showing error for the local variable but not global variable? Not only my book, but the following 2 links from this forum clearly state that we can declare a variable multiple times (though define only once).

link1 link2

And kindly take care to explain what does the "with no linkage" part of the first error "redeclaration of 'y' with no linkage" mean? What linkage and to whom? Where would a local variable be linked?

    #include<stdio.h>

    int x;
    int x;
    int x=303;

    int main(void)
    {

      int y;
      int y;
      int y=776;   //Works fine if above 2 declarations are removed!!

      printf("The value of x is %d,and of y is %d",x,y);

    }

Answer 1

In C and C++, int y; within a function is both a declaration and a definition.

In C, int x; in the file scope (outside any function) is a declaration and a tentative defintion. Multiple tentative definitions are allowed; only one definition is allowed.

Answer 2

This is the way defined in the C99 standard, section 6.2.2, part 2:

In the set of translation units and libraries that constitutes an entire program, each declaration of a particular identifier with external linkage denotes the same object or function. Within one translation unit, each declaration of an identifier with internal linkage denotes the same object or function. Each declaration of an identifier with no linkage denotes a unique entity.

The "global" variables x have external linkage, so they denote the same object. The local y variables, on the other hand, has no linkage, so there is a collision.

References: C99 Standard.

Answer 3

With external variables, any declaration that isn't an initialisation is a tentative definition. These by themselves don't create any storage, so multiple ones are allowed. So taking your example:

int x;      // tentative def
int x;      // and again -- ok
int x=303;  // definition -- ok
int x=303;  // multiple definition -- error

If at the end of the file there have been only tentative definitions, the variable is defined once, and set to 0.

This means that if you link to another file which also has a tentative definition of x, you'll have an error according to the standard. Most compilers/linkers have always allowed this, though, and it's defined in the standard as an extension.

With local variables, each declaration is a definition because of scope rules. This, however, is allowed:

void func(void)
{
   int y = 0;
   {
      int y = 1;   // a completely different y
   }
}