'"extern" inside a function?

Well, reading "a bit old" book ("The C programming language", second edition, by Dennis Ritchie), I came a cross the following:

An external variable must be defined, exactly once, outside of any function; this sets aside storage for it. The variable must also be declared in each function that wants to access it

and I was like - what?!

"The variable must also be declared in each function that wants to access it". Then, I was shocked one more time:

int max; 
/* ... */
int main()
{
    extern int max;
    /* ... */
}

And one more - what?!

As far as I know (obviously, it's not much and far from enough), extern makes sense only when you define a global variable somewhere and you want to access it through another file (not to define it again).

So:

  • What's the point of this extern int max inside the main or any other function?
  • Does the standard really says, that this is a must (that I need to declare, for this example, this max in each function, that will use it?)
  • Is this the same for C++ (that's why I placed the C++ tag)? This is the first time I see something like this.

Note: this is not the same as What is the use of declaring a static variable as extern inside a function?

c++cglobal-variablesexternkernighan-and-ritchie


Solution 1:[1]

extern int max inside main or function is saying to the compiler "I am not a local variable inside the main or function, I am the global variable defined elsewhere".

If the global is declared in the same file, not useful. In different file,yes, but not in each function, just declare one time in the head file of the source that use this global variable. This is the same in c++.

Solution 2:[2]

The extern is linkage. It means this name, max, is linked to other occurrences of the name, possibly in other files. (That is, when the object modules are linked together to make an executable, all the linked references to this name will be made to refer to the same object.)

The scope of this declaration is the remainder of the function body it is in. That means other functions in this file do not see the name declared by this declaration (unless they declare it themselves).

Scope and linkage are different things.

Solution 3:[3]

Another possible reason for extern inside a function is to make sure that no local variable is shadowing the global variable

Without extern:

int max = 33;
int main()
{
    int max; 
    printf("%d", max); // prints indeterminate value (garbage)
}

With extern

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

Output:

error: redeclaration of ‘max’ with no linkage

Sources

This article follows the attribution requirements of Stack Overflow and is licensed under CC BY-SA 3.0.

Source: Stack Overflow

Solution Source
Solution 1 Fantastic Mr Fox
Solution 2 Eric Postpischil
Solution 3 Rain

Related Questions