Static variable

Incomputer programming,astatic variableis avariablethat has beenallocated"statically", meaning that itslifetime(or "extent" ) is the entire run of the program. This is in contrast to shorter-livedautomatic variables,whose storage isstack allocatedand deallocated on thecall stack;and in contrast toobjects,whose storage isdynamically allocatedand deallocated inheap memory.

Variable lifetimeis contrasted withscope(where a variable can be used): "global" and "local" refer to scope, not lifetime, but scope often implies lifetime. In many languages,global variablesare always static, but in some languages they are dynamic, whilelocal variablesare generally automatic, but may be static.

In general,static memory allocationis the allocation of memory atcompile time,before the associated program is executed, unlikedynamic memory allocationorautomatic memory allocationwhere memory is allocated as required atrun time.^[1]

History

Static variables date at least toALGOL 60(1960), where they are known asownvariables:

A declaration may be marked with the additional declaratorown.This has the following effect: upon a re-entry into the block, the values ofownquantities will be unchanged from their values at the last exit, while the values of declared variables that are not marked withownis undefined.
— Revised report on ALGOL 60, section "5. Declarations", p. 14

This definition is subtly different from a static variable: it only specifies behavior, and hence lifetime, not storage: an own variable can be allocated when a function is first called, for instance, rather than at program load time.

The use of the wordstaticto refer to these variables dates at least toBCPL(1966), and has been popularized by theC programming language,which was heavily influenced by BCPL. The BCPL definition reads:

(1) Static data items:
Those data items whose extents lasts as long as the program execution time; such data items have manifest constant Lvalues. Every static data item must have been declared either in a function or routine definition, in a global declaration or as a label set by colon.
— The BCPL Reference Manual, 7.2 Space Allocation and Extent of Data Items

Note that BCPL defined a "dynamic data item" for what is now called anautomaticvariable (local, stack-allocated), not for heap-allocated objects, which is the current use of the termdynamic allocation.

Thestatickeywordis used in C and related languages both for static variables and other concepts.

Addressing

Theabsolute address addressing modecan only be used with static variables, because those are the only kinds of variables whose location is known by the compiler at compile time. When the program (executableorlibrary) isloadedinto memory, static variables are stored in thedata segmentof the program'saddress space(if initialized), or theBSS segment(if uninitialized), and are stored in corresponding sections ofobject filesprior to loading.

Scope

In terms ofscope and extent,static variables have extent the entire run of the program, but may have more limitedscope.A basic distinction is between astatic global variable,which has global scope and thus is in context throughout the program, and astatic local variable,which has local scope. A static local variable is different from a local variable as a static local variable is initialized only once no matter how many times the function in which it resides is called and its value is retained and accessible through many calls to the function in which it is declared, e.g. to be used as a count variable. A static variable may also havemodule scopeor some variant, such asinternal linkageinC,which is a form of file scope or module scope.

Example

An example of a static local variable in C:

#include<stdio.h>

voidFunc(){
staticintx=0;
// |x| is initialized only once across five calls of |Func| and the variable
// will get incremented five times after these calls. The final value of |x|
// will be 5.
x++;
printf("%d\n",x);// outputs the value of |x|
}

intmain(){
Func();// prints 1
Func();// prints 2
Func();// prints 3
Func();// prints 4
Func();// prints 5

return0;
}

Object-oriented programming

Inobject-oriented programming,there is also the concept of astatic member variable,which is a "class variable"of a statically defined class, i.e., amember variableof a given class which is shared across allinstances(objects), and is accessible as a member variable of these objects. A class variable of a dynamically defined class, in languages where classes can be defined at run time, is allocated when the class is defined and is not static.

Object constants known at compile-time, such asstring literals,are usually allocated statically. In object-oriented programming, thevirtual method tablesof classes are usually allocated statically. A statically defined value can also beglobalin its scope ensuring the sameimmutablevalue is used throughout a run for consistency.

Notes

^Jack Rons."What is static memory allocation and dynamic memory allocation?".MeritHub [An Institute of Career Development].Retrieved2011-06-16.The compiler allocates required memory space for a declared variable. By using the addressof operator, the reserved address is obtained and this address may be assigned to a pointer variable. Since most of the declared variables have static memory, this way of assigning pointer value to a pointer variable is known as static memory allocation. Memory is assigned during compilation time.^{[dead link]}

References

Kernighan, Brian W.;Ritchie, Dennis M.(1988).The C Programming Language(2nd ed.). Upper Saddle River, NJ: Prentice Hall PTR.ISBN 0-13-110362-8.
The C++ Programming Language(special edition) byBjarne Stroustrup(Addison Wesley, 2000;ISBN 0-201-70073-5)

[1] Jack Rons."What is static memory allocation and dynamic memory allocation?".MeritHub [An Institute of Career Development].Retrieved2011-06-16.The compiler allocates required memory space for a declared variable. By using the addressof operator, the reserved address is obtained and this address may be assigned to a pointer variable. Since most of the declared variables have static memory, this way of assigning pointer value to a pointer variable is known as static memory allocation. Memory is assigned during compilation time.^{[dead link]}

[1]

v t e Memory management
Memory management as a function of an operating system
Hardware	Memory management unit(MMU) Translation lookaside buffer(TLB) Input–output memory management unit(IOMMU)
Virtual memory	Demand paging Memory paging Page table Virtual memory compression
Memory segmentation	Protected mode Real mode Virtual 8086 mode x86 memory segmentation
Memory allocator	dlmalloc Hoard jemalloc libumem mimalloc ptmalloc
Manual memory management	Static memory allocation C dynamic memory allocation new and delete (C++)
Garbage collection	Automatic Reference Counting Boehm garbage collector Cheney's algorithm Concurrent mark sweep collector Finalizer Garbage Garbage-first collector Mark–compact algorithm Reference counting Tracing garbage collection Strong reference Weak reference
Memory safety	Buffer overflow Buffer over-read Dangling pointer Stack overflow
Issues	Fragmentation Memory leak Unreachable memory
Other	Automatic variable International Symposium on Memory Management Region-based memory management
Memory management Virtual memory Automatic memory management Memory management algorithms Memory management software