How global and local with same static variable names stored in C internally memory?

Question

#include<stdio.h>
static int a=5;
main()
{
     static int a=15;
     printf("%d\n",a);
}

So, how are both variables a stored in internal memory?

How are global and local variables with the same variable names stored internally in memory?

They have different scope. – user2736738 Mar 03 '18 at 10:55 — user2736738, Mar 03 '18 at 10:55

yajiv · Accepted Answer · 2018-03-03T11:11:14.580

1

#include<stdio.h>
static int a=5;
int main()
{
    printf("%p\n",(void *)&a);
    static int a=15;
    printf("%p\n",(void *)&a);
    return 0;
}

Output for the upper program is

0x564e6b67a030
0x564e6b67a034

So you can see that both are stored in different addresses. As one is a global variable and other is local.

edited Mar 03 '18 at 11:11

answered Mar 03 '18 at 11:01

yajiv

2,901
2
15
25

1

You make the point well, but don't use `%d` to print pointer addresses: that's undefined behaviour! You'll have the downvoters after you. – Bathsheba Mar 03 '18 at 11:02
1

Thanks for changing that. (Did you notice how the output values changed? Let's keep that a secret.) Have an upvote. – Bathsheba Mar 03 '18 at 11:04
1

You forgot the `void*` cast - it is needed. – user2736738 Mar 03 '18 at 11:10

score 1 · Answer 2 · answered Mar 03 '18 at 11:16

The names are only of interest to the human reader and the compiler/linker translating that code to machine executable code. The final object code resolves these to addresses and the names no longer exist.

The compiler distinguishes these the same way you do - by scope; when two identical symbols in the same namespace are in scope simultaneously, the symbol with the most restrictive scope is visible (i.e. may be accessed via the name).

For symbols with external linkage (in your example there are none other then main), the compiler retains the symbol name in order to resolve links between separately compiled modules. In the fully linked executable the symbol names cease to exist (except in debug build symbol meta-data).

@SudeepPatel : No - not at all. The variable `a` has _internal_ linkage due to the `static` _linkage specifier_. Removing the `static` qualifier will cause it to have _external_ linkage - the `extern` keyword is not necessary, but would not cause an error (likely to cause a warning because it is an unusual and unnecessary use of `extern`). It cannot of course be both `static` and `extern` since they specify opposing linkage. Since you did not say what the error was I am left guessing. — Clifford, Mar 03 '18 at 14:19

Bathsheba · Answer 3 · 2018-03-03T11:06:14.990

The facetious answer is that they are stored in different places.

Remember that the names of variables do not (normally) form part of the compiled program, so the compiler just follows the normal rules of variable shadowing. So in your case your print function (that's not a standard C function by the way - did you mean printf?) outputs the a declared in main. The fact that you've used the same name will not bother the compiler at all.

Finally C provides no way of accessing the global scoped a once the other declaration is encountered in main as it's static. (It is wasn't static you could use extern.) See How can I access a shadowed global variable in C?

score 0 · Answer 4 · answered Mar 03 '18 at 11:00

The thing is the scope don't let them mess up. The first one has file scope and the other has block scope. (They are different variables - they are stored in separate memories.)

When you use it in the block - compiler checks whether this reference is resolved by anything in the same block. It gets one. And done.

And in case it is in some other function - if it doesn't find anything named a - the search ends in file scope where it finds the name a. That is where the story ends.

Both being static their storage duration is same. They live till the program exists. But their scope is different. If the scope was same too - compiler would have shown you error message.

Here if you compile with -Wshadow option - it will warn you about shadowing a variable. You shadowed the outer a with the inner on that block. That's it.

How global and local with same static variable names stored in C internally memory?

4 Answers4