mirror of
https://github.com/QB64Official/qb64.git
synced 2024-07-16 18:55:13 +00:00
107 lines
3.4 KiB
Markdown
107 lines
3.4 KiB
Markdown
The STATIC keyword is used in declaration statements to control where variables are stored.
|
|
|
|
## Syntax
|
|
|
|
> STATIC variableName[()] [AS dataType][, ...]
|
|
> STATIC [AS dataType] variableName[()][, ...]
|
|
|
|
## Syntax
|
|
|
|
> {[SUB](SUB)|[FUNCTION](FUNCTION)} procedureName [(parameterList)] STATIC
|
|
|
|
## Description
|
|
|
|
* A STATIC list can be used in [SUB](SUB) and [FUNCTION](FUNCTION) procedures to designate one or more variables to retain their values.
|
|
* Variables and arrays with static storage will retain their values in between procedure calls. The values may also be used recursively.
|
|
* variableName may include a type suffix or use [AS](AS) to specify a type other than the default [SINGLE](SINGLE) type.
|
|
* Arrays with static storage are declared by specifying empty parenthesis following the array name. See [Arrays](Arrays)
|
|
* STATIC can be used after the name of a [SUB](SUB) or [FUNCTION](FUNCTION) in the procedure to force all variables to retain their values.
|
|
* **Recursive procedures may be required to be STATIC to avoid a Stack Overflow error. QB64 programs may just close.**
|
|
* [$STATIC]($STATIC) defined program [arrays](arrays) cannot be [REDIM](REDIM) or use [_PRESERVE](_PRESERVE).
|
|
|
|
## Example(s)
|
|
|
|
*Example 1: Finding the binary bit settings from a 32 bit [LONG](LONG) register return using recursion.
|
|
|
|
```vb
|
|
|
|
INPUT "Enter a numerical value to see binary value: ", num&
|
|
PRINT Bin$(num&)
|
|
|
|
END
|
|
|
|
FUNCTION Bin$ (n&) STATIC 'comment out STATIC to see what happens!
|
|
DIM p%, s$
|
|
IF 2 ^ p% > n& THEN
|
|
p% = 0
|
|
ELSE
|
|
IF n& AND 2 ^ p% THEN s$ = "1" + s$ ELSE s$ = "0" + s$
|
|
IF n& > 2 ^ p% THEN
|
|
p% = p% + 1
|
|
s$ = Bin$(n&) 'recursive call to itself
|
|
ELSE: p% = 0
|
|
END IF
|
|
END IF
|
|
IF s$ = "" THEN Bin$ = "0" ELSE Bin$ = s$
|
|
END FUNCTION
|
|
|
|
```
|
|
|
|
> *Explanation:* The [FUNCTION](FUNCTION) above returns a [STRING](STRING) value representing the bits ON in an [INTEGER](INTEGER) value. The string can be printed to the screen to see what is happening in a port register. **STATIC** keeps the function from overloading the memory "Stack" and is normally REQUIRED when recursive calls are used in QBasic! **QB64 procedures will close without warning or error!**
|
|
|
|
Using a static array to cache factorials, speeding up repeated calculations:
|
|
|
|
```vb
|
|
|
|
PRINT Factorial(0)
|
|
PRINT Factorial(5)
|
|
PRINT Factorial(50)
|
|
|
|
FUNCTION Factorial# ( n AS DOUBLE )
|
|
CONST maxNToCache = 50
|
|
STATIC resultCache() AS DOUBLE
|
|
STATIC firstCall AS INTEGER
|
|
|
|
' The lookup table is initially empty, so re-size it..
|
|
IF firstCall = 0 THEN
|
|
firstCall = -1
|
|
REDIM resultCache(maxNToCache) AS DOUBLE
|
|
|
|
' ..and pre-calculate some factorials.
|
|
resultCache(0) = 1
|
|
resultCache(1) = 1
|
|
resultCache(2) = 2
|
|
END IF
|
|
|
|
' See if we have the result cached. If so, we're done.
|
|
IF n <= maxNToCache THEN
|
|
IF resultCache(n) <> 0 THEN
|
|
Factorial = resultCache(n)
|
|
EXIT FUNCTION
|
|
END IF
|
|
END IF
|
|
|
|
' If not, we use recursion to calculate the result, then cache it for later use:
|
|
resultCache(n) = INT(n) * Factorial(INT(n) - 1)
|
|
Factorial = resultCache(n)
|
|
END FUNCTION
|
|
|
|
|
|
```
|
|
|
|
```text
|
|
|
|
1
|
|
120
|
|
3.041409320171338D+64
|
|
|
|
```
|
|
|
|
## See Also
|
|
|
|
* [DIM](DIM), [REDIM](REDIM), [COMMON](COMMON)
|
|
* [SUB](SUB), [FUNCTION](FUNCTION)
|
|
* [TYPE](TYPE), [Arrays](Arrays)
|
|
* [$STATIC]($STATIC), [$DYNAMIC]($DYNAMIC) ([Metacommand](Metacommand)s)
|
|
* [Data types](Data-types)
|