Static Variable Concepts 'C'

Question

After I read about static variables, something confuses me. We can say the keyword static acts to extend the lifetime of a variable to the lifetime of the program because the lifetime of a variable is the period over which it exists.

My questions are:

1. What really happens inside?
2. Is memory allocated specifically for this variable, or is it a kind of pointer?

Answer 1

Depending on how you count, in a traditional memory architecture there are typically up to five different places to store the data used by a C program:

1. On the stack.
2. In the initialized data segment.
3. In the uninitialized data segment ("bss").
4. In the code segment.
5. In the heap.

Variables declared local to functions (those with "automatic" storage duration) are stored in #1, on the stack.

Global variables (those declared outside of a function) are stored in 2, 3, or maybe 4, depending on whether they're initialized, uninitialized (meaning that they default to 0), or const. These variables have "static" duration.

And since static-local variables have static duration, also, they're also stored in 2, 3, or maybe 4.

I mentioned #5 "the heap" for completeness, but no conventionally-declared variables are ever going to be stored there.

See also Difference between static global variable and non-static global variable in C.

Answer 2

We can say the keyword static acts to extend the lifetime of a variable to the lifetime of the program because the lifetime of a variable is the period over which it exists.

This is true for static variables defined inside a function like:

int *my_function() {
     static int my_static_var[4] = {0,0,0,0};

     return my_static_var;
}

Here my_static_var's lifetime is the lifetime of the program never goes out of scope³, so it's valid to access the memory after the function has returned.

However, all calls to this (my_function) function will return the exact same block of memory, so conceptually it's really a global variable that can't be accessed directly outside of the function.

Of course, you can also define variables outside a function:

static int my_static_var[4]; 

Here my_static_var is only accessible within the same translation unit.

That means another "file" cannot directly² access my_static_var; it's bound to the file it was defined in.

Also, all globally defined variables are automatically initialized to 0.¹

Note you cannot declare a static variable, since static variables are intentionally not shared with other parts of your source code. You always have to define (declaration / definition are two different things) it.

The same concept can be applied to static functions:

static int my_function() {
    return 0;
}

Here the function my_function cannot be accessed directly outside the translation unit it was defined in.

I don't know of any other uses for the static keyword in C.

¹ The same applies to static variables defined inside a function.

² It would still be possible through a pointer, for example.

³ Variable goes out of scope, see comment from @Eric Postpischil

Answer 3

There are two different, mostly unrelated, concepts called static in C

• "static storage duration" (sometimes called "static lifetime") which applies to objects
• "static scope", which applies to names. Most places in the spec actually call this "internal linkage" to try to reduce the confusion around "static"

More confusingly, the static keyword can affect either concept, depending on where it is

• outside of any function body, static causes a name declared to have static scope (or internal linkage) instead of global scope (or external linkage), but does not affect the object's lifetime (which will be static for all objects defined outside of functions, regardless of the presence or absence of the keyword)
• inside of a function body, static causes objects defined to have static storage duration (lifetime), but does not affect the name's scope (which will always be local)

Answer 4

In a C program, the static keyword is used to declare

1. Scope a function or a variable within the file it is defined. This function or variable is private to the file.

2. Keep the state of a variable among functions in the same file.