Why can we declare multiple identically named variables globally but not locally in C?

Question

When I declare a global variable multiple times, I do not get any error.

#include <stdio.h>

int i;
int i;

int main()
{
    printf("%d",i);
}

But if I declare a local variable multiple times, I get an error. Why is it so?

#include <stdio.h>

int main()
{ 
    int i;
    int i;
    printf("%d",i);
}

Can you clarify when we can have multiple declarations without any error?

I do not get the meaning of "I except to clarify when we can have multiple declarations without any error." please review for clarity and readability. — Yunnosch, Nov 10 '22 at 10:13
I presume `studio.h` is supposed to be `stdio.h`. Always copy/paste the code! — Weather Vane, Nov 10 '22 at 10:14
Related: [About **Tentative** definition](https://stackoverflow.com/questions/3095861/about-tentative-definition) — Weather Vane, Nov 10 '22 at 10:16
Related: [Why don't tentative definitions cause errors due to multiple definitions?](https://stackoverflow.com/questions/69877611/why-dont-tentative-definitions-cause-errors-due-to-multiple-definitions) — Weather Vane, Nov 10 '22 at 10:21
You can [edit] your question. Most times it helps to read help pages. ;-) And to look around, do you see that words below your question? — the busybee, Nov 10 '22 at 13:28

Eric Postpischil · Answer 1 · 2022-11-10T13:49:29.800

Early in the history of C, compilers were written by different people for different environments using their own notions of how they wanted the language to behave, and the language developed organically rather than by design. When the C committee wrote the C standard, it allowed for varying behaviors in existing C implementations. In consequence, the semantics of declarations are somewhat complicated.

Outside of any function, int c; is a declaration, not a definition. It is a special kind of declaration called a tentative definition, but, in spite of that name, it is not actually a definition. A declaration of an identifier for an object that is not a definition only tells the compiler about the identifier and the object; it does not cause space to be reserved for the object. Since it is only a declaration, it may be repeated multiple times. This simply repeats the information to the compiler without defining the object.

Inside a function, int c; is a definition. It causes space to be reserved for the object. Since it is a definition, it should not be repeated. Again, the reasons for this are due to the history of the development of C, not due to planned design.

I suspect part of the reason things developed in this way is that multiple header files that wanted to use an external variable would declare it, as with int errno;, and, once this practice had developed, compilers had to allow it. A program would typically include multiple headers, and sometimes multiple headers would declare the same identifier, intending to use the same object as other headers. In contrast, inside a function, we do not typically include headers. All the code for a function is usually written at one point in one file, and so we do not get multiple declarations like int i; coming from different places. So, inside a function, int i; can be made a regular definition.

A tentative definition will cause a definition to be created if, at the end of the translation unit (the source file being compiled, along with everything it includes), there is no definition for the identifier.

Why can we declare multiple identically named variables globally but not locally in C?

1 Answers1