Static
Defines variables, objects and arrays having static storage
Syntax
`
Static symbol [ (array-dimensions) ] As DataType [, ...]
or
Type typename
Static symbol [ (array-dimensions) ] As DataType [, ...]
...
End Type
Dim typename.symbol [ (array-dimensions) ] As DataType [= initial-value] [, ...]
or
Sub|Function procedurename ( parameters ) [As DataType] Static
...
End Sub|Function
`
Parameters
`symbol`
variable or array symbol name.
`array-dimensions`
`lower-bound To upper-bound [, ...]`
Description
Specifies static storage for variables, objects and arrays; they are allocated at program startup and deallocated upon exit. Objects are constructed once when they are defined, and destructed upon program exit.
When declaring static arrays, only numeric literals, Constants or Enumerations may be used as subscript range values. Static variable-length arrays must be declared empty (no subscript range list) and resized using `ReDim` before used.
In both iterative and recursive blocks, like looping control flow statements or procedures, static variables, objects and arrays local to the block are guaranteed to occupy the same storage across all instantiations of the block. For example, procedures that call themselves - either directly or indirectly - share the same instances of their local static variables.
A static variable may only be initialised with a constant value: its starting value is set at the start of the program before any code is run, and so it cannot depend on any variables or functions in it.
When used with module-level and member procedure declarations, `Static` specifies static storage for all local variables, objects and arrays.
At module-level variable declaration only, the modifier `Shared` may be used with the keyword `Static` to make module-level static variables visible inside procedures.
When used with UDT, each `Static` member variable needs an explicit definition as well as a declaration. The declaration inside the UDT is the prototype that is visible to every module seeing the UDT declaration (like with methods). The definition - which must be done outside the type declaration code, and appear only once in a single module - allocates static space for - and optionally initializes - the static variable.
A `Static` member variable is visible throughout the entire program (inside any procedure) even if the modifier `Shared` is not specified in the definition (`Static` and `Shared` are useless in the definition). So, `Static` member variables can be called directly anywhere in code, or on objects of type `typename`.
`Static (Member)` is also used in member procedure declarations to specify static member procedures.
Example
`
Sub f
'' static variables are initialized to 0 by default
Static i As Integer
i += 1
Print "Number of times called: " & i
End Sub
'' the static variable in f() retains its value between
'' multiple procedure calls.
f()
f()
`
Will output:

    Number of times called: 1
    Number of times called: 2

`
'Assign an unique ID to every instance of a Type (ID incremented in order of creation)
Type UDT
Public:
Declare Property getID () As Integer
Declare Constructor ()
Private:
Dim As Integer ID
Static As Integer countID
End Type
Dim As Integer UDT.countID = 0
Property UDT.getID () As Integer
Property = This.ID
End Property
Constructor UDT ()
This.ID = UDT.countID
UDT.countID += 1
End Constructor
Dim As UDT uFirst
Dim As UDT uSecond
Dim As UDT uThird
Print uFirst.getID
Print uSecond.getID
Print uThird.getID
`
Differences from QB

- QuickBASIC allows variables and arrays to be declared using the `Static` keyword within procedures and `DEF FN` routines only.
- `Static` forces local visibility of variables and arrays in QuickBASIC `DEF FN` routines. FreeBASIC supports neither `DEF FN` routines nor this usage of `Static`.
- Using `Static` to specify static member variables (and also `Static` member procedures) is new to FreeBASIC.

See also

- `Static (Member)`
- `Dim`, `ReDim`
- `Shared`
- `Sub (Module)`, `Function (Module)`
- `Sub (Member)`, `Function (Member)`
- `Option Static`
- `Storage Classes`