[<<Previous Entry]
[^^Up^^]
[Next Entry>>]
[Menu]
[About The Guide]
STATIC
Declare and initialize static variables and arrays
------------------------------------------------------------------------------
Syntax
STATIC <identifier> [[:= <initializer>], ... ]
Arguments
<identifier> is the name of the variable or array to declare static.
If the <identifier> is followed by square brackets ([ ]), it is created
as an array. If the <identifier> is an array, the syntax for specifying
the number of elements for each dimension can be array[<nElements>,
<nElements2>,...] or array[<nElements>] [<nElements2>]... The maximum
number of elements is 4096. The maximum number of dimensions is limited
only by available memory.
<initializer> is the optional assignment of a value to a new static
variable. An <initializer> for a static variable consists of the inline
assignment operator (:=) followed by a compile-time constant expression
consisting entirely of constants and operators or a literal array. If
no explicit <initializer> is specified, the variable is given an initial
value of NIL. In the case of an array, each element is NIL. Array
identifiers cannot be given values with an <initializer>.
Note: The macro operator (&) cannot be used in a STATIC declaration
statement.
Description
The STATIC statement declares variables and arrays that have a lifetime
of the entire program but are only visible within the entity that
creates them. Static variables are visible only within a procedure or
user-defined function if declared after a PROCEDURE or FUNCTION
statement. Static variables are visible to all procedures and functions
in a program (.prg) file (i.e., have filewide scope) if they are
declared before the first procedure or user-defined function definition
in the file. Use the /N compiler option to compile a program with
filewide variable scoping.
All static variables in a program are created when the program is first
invoked, and all values specified in a static <initializer> are assigned
to the variable before the beginning of program execution.
Declarations of static variables within a procedure or user-defined
function must occur before any executable statement including PRIVATE,
PUBLIC, and PARAMETERS. If a variable of the same name is declared
FIELD, LOCAL, or MEMVAR within the body of a procedure or user-defined
function, a compiler error occurs and no object (.OBJ) file is
generated.
The maximum number of static variables in a program is limited only by
available memory.
Notes
. Inspecting static variables within the Debugger: To access
static variable names within the CA-Clipper debugger, you must
compile program (.prg) files using the /B option so that static
variable information is included in the object (.OBJ) file.
. Macro expressions: You may not refer to static variables
within macro expressions or variables. If a static variable is
referred to within a macro expression or variable, a private or
public variable of the same name will be accessed instead. If no
such variable exists, a runtime error will be generated.
. Memory files: Static variables cannot be SAVED to or RESTOREd
from memory (.mem) files.
. Type of a static local variable: Since TYPE() uses the macro
operator (&) to evaluate its argument, you cannot use TYPE() to
determine the type of a local or static variable or an expression
containing a local or static variable reference. The VALTYPE()
function provides this facility by evaluating the function argument
and returning the data type of its return value.
Examples
. This example declares static variables both with and without
initializers:
STATIC aArray1[20, 10], aArray2[20][10]
STATIC cVar, cVar2
STATIC cString := "my string", var
STATIC aArray := {1, 2, 3}
. This example manipulates a static variable within a user-
defined function. In this example, a count variable increments
itself each time the function is called:
FUNCTION MyCounter( nNewValue )
STATIC nCounter := 0 // Initial value assigned once
IF nNewValue != NIL
nCounter:= nNewValue // New value for nCounter
ELSE
nCounter++ // Increment nCounter
ENDIF
RETURN nCounter
. This example demonstrates a static variable declaration that
has filewide scope. In this code fragment, aArray is visible to both
procedures that follow the declaration:
STATIC aArray := {1, 2, 3, 4}
FUNCTION One
? aArray[1] // Result: 1
RETURN NIL
FUNCTION Two
? aArray[3] // Result: 3
RETURN NIL
See Also:
FUNCTION
LOCAL
PARAMETERS
PRIVATE
PROCEDURE
PUBLIC
This page created by ng2html v1.05, the Norton guide to HTML conversion utility.
Written by Dave Pearson