Static (keyword)

Reserved word in some programming languages

This article has multiple issues. Please help improve it or discuss these issues on the talk page. (Learn how and when to remove these messages)

This article needs additional citations for verification. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed.
Find sources: "Static" keyword – news · newspapers · books · scholar · JSTOR (June 2022) (Learn how and when to remove this message)

|

This article is missing information about the use of the static keyword to declare class methods in C++ and Java. Please expand the article to include this information. Further details may exist on the talk page. (April 2014)

|

(Learn how and when to remove this message)

`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

[edit]

In the predecessors of C, including BCPL and B, there was already a concept of static storage.,[1][2] 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.[2] 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:[3]

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:

1. A variable with the same lifetime as the program, as described above (language-independent); or
2. (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

[edit]

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

[edit]

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#.[4]

## As a class member specifier

[edit]

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[5]

## As a specifier for closures

[edit]

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.[6]

## See also

[edit]

* Computer programming portal

## References

[edit]

1. ^ "MUL TIC SYSTEf·-1-PROGRAMMERS' MANUAL" (PDF).
2. ^ a b Kernighan, B. W. A TUTORIAL INTRODUCTION TO THE LANGUAGE B (PDF). Murray Hill, New Jersey: Bell Laboratories. p. 4.
3. ^ "Storage-class specifiers". cppreference.com.
4. ^ "Access Modifiers (C# Programming Guide)". Microsoft.
5. ^ "Late Static Bindings". PHP Manual.
6. ^ "Static anonymous functions". Microsoft.