FreeBasic Static Keyword

Last modified April 20, 2026

The FreeBasic Static keyword is used to declare variables that retain their values between function calls. Unlike local variables, static variables persist throughout program execution.

Basic Definition

In FreeBasic, Static modifies variable declarations to give them static storage duration. Static variables are initialized only once and maintain their values between function calls.

Static variables can be declared at procedure level (local static) or module level (global static). They are useful for maintaining state across multiple function invocations.

Static Local Variable

This example demonstrates a static local variable that persists between calls.

Sub Counter()
 Static count As Integer = 0
 count += 1
 Print "Count: "; count
End Sub
Counter()
Counter()
Counter()

The count variable is declared static inside the Counter subroutine. It retains its value between calls, incrementing each time. Without static, it would reset to 0 on each call.

Static vs Non-Static Comparison

This example contrasts static and non-static local variables.

Sub TestVars()
 Static staticVar As Integer = 10
 Dim nonStaticVar As Integer = 10
 
 staticVar += 5
 nonStaticVar += 5
 
 Print "Static: "; staticVar; " Non-static: "; nonStaticVar
End Sub
TestVars()
TestVars()
TestVars()

The static variable maintains its incremented value between calls, while the regular local variable reinitializes each time. This shows the persistence difference between static and automatic variables.

Static Array

Static can be used with arrays to preserve their contents between calls.

Sub ProcessData()
 Static data(3) As Integer = {1, 2, 3, 4}
 
 For i As Integer = 0 To 3
 data(i) *= 2
 Print data(i); " ";
 Next
 Print
End Sub
ProcessData()
ProcessData()
ProcessData()

The static array doubles its values on each call, showing the values persist. Without static, the array would reset to {1,2,3,4} on each invocation.

Static in Recursive Functions

Static variables are useful in recursive functions to track state.

Function Factorial(n As Integer) As Integer
 Static depth As Integer = 0
 depth += 1
 
 Print "Depth: "; depth; " n: "; n
 
 If n <= 1 Then
 Return 1
 Else
 Return n * Factorial(n - 1)
 End If
End Function
Print "5! = "; Factorial(5)

The static depth variable tracks recursion depth across all recursive calls. It demonstrates how static variables maintain state throughout the entire recursion process.

Static Global Variable

Static can limit global variable scope to the current module.

Static sharedValue As Integer = 100
Sub ModifyValue()
 sharedValue += 50
 Print "Modified value: "; sharedValue
End Sub
ModifyValue()
ModifyValue()
Print "Final value: "; sharedValue

The sharedValue is static at module level, making it invisible to other modules. It behaves like a global variable but with restricted scope.

Static in Classes

Static members in classes maintain single instances across all objects.

Type Counter
 Static total As Integer
 Dim instanceCount As Integer
 
 Declare Sub Increment()
End Type
Sub Counter.Increment()
 total += 1
 instanceCount += 1
 Print "Total: "; total; " Instance: "; instanceCount
End Sub
Dim c1 As Counter
Dim c2 As Counter
c1.Increment()
c2.Increment()
c1.Increment()

The static total is shared among all Counter instances, while instanceCount is unique to each object. This demonstrates class- level vs instance-level variables.

Static Initialization

Static variables are initialized only once, at program startup.

Function GetID() As Integer
 Static id As Integer = 100
 id += 1
 Return id
End Function
Print "ID 1: "; GetID()
Print "ID 2: "; GetID()
Print "ID 3: "; GetID()

The id variable initializes to 100 only once. Subsequent calls increment from the last value. This pattern is useful for generating unique IDs or sequence numbers.

Best Practices

• Use sparingly: Static variables can make code harder to understand.
• Thread safety: Be cautious with statics in multi-threaded code.
• Initialization: Static variables initialize only once.
• Naming: Prefix static variables to indicate their nature.
• Alternatives: Consider class members for object persistence.

This tutorial covered the FreeBasic Static keyword with practical examples showing its usage in different scenarios.

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all FreeBasic Tutorials.