The static
storage class serves different purposes, depending on the location of the declaration in the file:
To confine the identifier to that translation unit only (scope=file).
/* No other translation unit can use this variable. */
static int i;
/* Same; static is attached to the function type of f, not the return type int. */
static int f(int n);
To save data for use with the next call of a function (scope=block):
void foo()
{
static int a = 0; /* has static storage duration and its lifetime is the
* entire execution of the program; initialized to 0 on
* first function call */
int b = 0; /* b has block scope and has automatic storage duration and
* only "exists" within function */
a += 10;
b += 10;
printf("static int a = %d, int b = %d\n", a, b);
}
int main(void)
{
int i;
for (i = 0; i < 5; i++)
{
foo();
}
return 0;
}
This code prints:
static int a = 10, int b = 10
static int a = 20, int b = 10
static int a = 30, int b = 10
static int a = 40, int b = 10
static int a = 50, int b = 10
Static variables retain their value even when called from multiple different threads.
Used in function parameters to denote an array is expected to have a constant minimum number of elements and a non-null parameter:
/* a is expected to have at least 512 elements. */
void printInts(int a[static 512])
{
size_t i;
for (i = 0; i < 512; ++i)
printf("%d\n", a[i]);
}
The required number of items (or even a non-null pointer) is not necessarily checked by the compiler, and compilers are not required to notify you in any way if you don't have enough elements. If a programmer passes fewer than 512 elements or a null pointer, undefined behavior is the result. Since it is impossible to enforce this, extra care must be used when passing a value for that parameter to such a function.