# Static (keyword)

static is a reserved word in many programming languages to modify a declaration. The effect of the keyword varies depending on the details of the specific programming language, most commonly used to modify the lifetime (as a static variable) and visibility (depending on linkage), or to specify a class member instead of an instance member in classes.

## Origin

In the predecessors of C, including BCPL and B, there was already a concept of static storage., which meant a storage which is always in existence. However, In B, there wasn't a static keyword, but there was an extrn keyword to specify external storage (external to all functions and must be defined outside a function), which is always static, in contrast with auto keyword, which declared an variable with auto storage - one appears whenever the function is invoked, and disappears when the function is left. All variables must be declared, as one of auto, extrn, or implicitly as function arguments.
C was developed as a successor of B, and the static and register keyword were added as storage class specifiers, along with auto and extern, which kept their meaning from B. However, in C, the concept of linkage for variables outside functions was introduced. A C program can be formed by multiple compilation units and linked together to form a complete program, which a variable or a function can be either specified as having internal linkage (visible to its own compilation unit only), or external linkage (visible to the whole program). These keywords specify both the storage duration and linkage as follows:
| Storage class | Duration | Linkage |
| extern | static (program execution) | external (whole program) |
| static | static (program execution) | internal (translation unit only) for top-level identifier none for block-scope variables |
| auto, register | function execution | none |
Every variable and function has one of these storage classes; if a declaration does not specify the storage class, a context-dependent default is used:
* extern for all top-level declarations in a source file,
* auto for variables declared in function bodies.
So, in C, although the static keyword, when used on variables, always declare a variable with static storage duration, there are two distinct meanings of the keyword, depending on where it is used:
* Top-level declaration: to declare an identifier with internal instead of external linkage, applicable to both variables and functions.
* Block-scoped declaration: to declare a variable with static instead of automatic storage duration. C doesn't support block-scoped functions.
Therefore, in C, the term "static variable" has two meanings which are easy to confuse:
* A variable with the same lifetime as the program, as described above (language-independent); or
* (C-family-specific) A variable declared with storage class static.
Variables with storage class extern, which include variables declared at top level without an explicit storage class, are static in the first meaning but not the second.
In C++ (not C), the static keyword can also be used to declare a member variable in a class to have static storage duration as well, independent from the storage duration of the class object itself, and such a variable must be defined outside the class. The effect is that the variable is shared among all class instances, becoming a class member instead of an instance member. When applied to a member function (method), it specifies that the member function operates independently of an instance, which means it can't access any non-static members of the class nor the this pointer.

## As a storage duration specifier

The static keyword is used in many programming languages to specify a local variable to have a lifetime of the whole program, preserved between function invocations, instead of having its own copy for each function invocation as in automatic storage duration, inherited from the usage in C.
Examples of programming languages which support the usage of static keyword for local variables to be kept across invocation include such as C, C++, Objective-C, C#, PHP.
The following programming languages with C-like syntax do not support static local variables as in C: Java, JavaScript, Dart. In these languages, a variable which is kept for the whole program execution needs to be declared outside functions.

## As a visibility specifier

The static keyword in C, when used as a top-level declaration, makes the variable or function visible to its own compilation unit only. Modern programming languages generally uses namespaces to avoid name clashes, so this use isn't widely adopted apart from programming languages with C compatibility in mind (e.g. C++, Objective-C). Other programming languages which support visibility declarations at top-level use a variety of other keywords to specify different level of visibility, for example, public in Java for classes which can be used everywhere, or internal / file in C#.

## As a class member specifier

The static keyword is used in most programming languages with classes to specify a member to be a class member, instead of an instance member, inherited from the usage of C++.
A static member of a class has the following characteristics:
* Independent from any class instances, can be accessed using the class name instead of an expression having the class object type.
* For fields: exist throughout the program lifetime (i.e. having static storage duration).
* For methods: cannot access any non-static members without an object expression (implicitly referring to the current instance), or the this reference for the current instance.
Some programming languages even go further, allowing the use of static keyword in other places in a class declaration or usage, for example:
* Static initialisers in Java and JavaScript, which are run once when the class is loaded
* Static constructors in C#, which are run once before the class is used
* Static classes in C#, which can't be instantiated.
* Inner classes in Java implicitly carry a this reference to the outer class object and must exist in the context of an outer class instance. By declaring an inner class to be static, it does not carry such a reference and can be used independently to an outer class instance.
* The static keyword can be used in place of an actual class name to access static members to provide class-level polymorphism, called late static bindings

## As a specifier for closures

The static keyword can be used in some programming languages on anonymous functions to prevent capturing states which are captured by default. It is similar to static local variables and static class members in the sense that a static closure does not depend on the running invocation of the containing function.
* PHP: Closures constructed in an instance method have the $this reference automatically bound to it, the static keyword prevents this.
* C#: Closures by default have all local and instance variables captured in it, the static keyword specifies that no outside states to be captured.