Static vs global

Question

If I have a C file like below, what is the difference between i and j?

#include <stdio.h>
#include <stdlib.h>

static int i;
int j;

int main ()
{
    //Some implementation
}

Solution 1

i has internal linkage so you can't use the name i in other source files (strictly translation units) to refer to the same object.

j has external linkage so you can use j to refer to this object if you declare it extern in another translation unit.

Solution 2

i is not visible outside the module; j is globally accessible.

That is, another module, which is linked to it, can do

extern int j;

and then be able to read and write the value in j. The same other module cannot access i, but could declare its own instance of it, even a global one—which is not visible to the first module.

Solution 3

The difference is that i has internal linkage, and j has external linkage. This means you can access j from other files that you link with, whereas i is only available in the file where it is declared.

Solution 4

i will have static linkage, i.e., the variable is accessible in the current file only.

j should be defined as extern, that is

extern int j;

in another header file (.h), and then it will have external linkage, and can be accessed across files.

Solution 5

Scope of static variable/function is within the same file despite you include the file as part of a different source file.

Scope of global variable is throughout the files in which it is included. To include the variable in a different source file, we use extern before the variable declaration. No memory is allocated again for the variable in this case.

extern is used to declare a C variable without defining it. extern keyword extends the visibility of the C variables and C functions. Since functions are visible through out the program by default, the use of extern is not needed in function declaration/definition. Its use is redundant.

View more solutions

Comments

[avakar]

Read answers to this question: stackoverflow.com/questions/1358400/…

[phuclv]

Difference between static, auto, global and local variable in the context of c and c++

[Thomas Matthews]

Is the 'extern' declaration necessary?

[wallyk]

It depends on the implementation. Use of extern is guaranteed to not cause trouble, provided one module has the symbol as non-extern and public (which allocates it). Early Unix implementations merged symbols with the same name—much like a Fortran common—so extern was not required.

[Jupiter]

Note that "Not visible" doesn't mean its out of scope. That means that if you would declare an i in a different compilation unit and you would remove the static i from your .c file the global i would be visible to your .c file. In contrast, if the global i were out of scope it wouldn't matter if you would have a static i declared in your .c file. The global one would never be visible. static i taking precedence over a global i defined in another compilation unit is called 'shadowing'. It also happens with function locals and is not a c++/c-only thing.

[Florian Castellane]

there shouldn't be a runtime difference if you are doing the same thing, as the compiler might generate the same code. Compilation might be slightly longer with a global though, since it has a wider scope.

[pmor]

Is it possible to programmatically determine the linkage of any arbitrary variable at compile time (potentially using compiler's extension) or at run time? See: stackoverflow.com/q/65520719/9881330.

[Abdel Aleem]

Why do I need to use "extern" to declare "j"? Does this mean that "int j;" is a defintion and not a declaration?