static
The
static keyword has several
distinct meanings. Normally, variables defined local to a function disappear at
the end of the function scope. When you call the function again, storage for the
variables is created anew and the values are re-initialized. If you want a value
to be extant throughout the life of a program, you can define a function’s
local variable to be static and give it an initial value. The
initialization is performed only the first time the function is called, and the
data retains its value between function calls. This way, a function can
“remember” some piece of information between function
calls.
You may wonder why a global variable
isn’t used instead. The beauty of a static variable is that it is
unavailable outside the scope of the function, so it can’t be
inadvertently changed. This localizes errors.
Here’s an example of the use of
static variables:
//: C03:Static.cpp
// Using a static variable in a function
#include <iostream>
using namespace std;
void func() {
static int i = 0;
cout << "i = " << ++i << endl;
}
int main() {
for(int x = 0; x < 10; x++)
func();
} ///:~
Each time func( ) is called
in the for loop, it prints a different value. If the keyword static is
not used, the value printed will always be ‘1’.
The second meaning of static is
related to the first in the “unavailable outside a certain scope”
sense. When static is applied to a function name or to a variable that is
outside of all functions, it means “This name is unavailable outside of
this file.” The function name or variable is local to the file; we say it
has file
scope.
As a demonstration, compiling and linking the following two files will cause a
linker error:
//: C03:FileStatic.cpp
// File scope demonstration. Compiling and
// linking this file with FileStatic2.cpp
// will cause a linker error
// File scope means only available in this file:
static int fs;
int main() {
fs = 1;
} ///:~
Even though the variable fs is
claimed to exist as an extern in the following
file, the linker won’t find it because it has been declared static
in FileStatic.cpp.
//: C03:FileStatic2.cpp {O}
// Trying to reference fs
extern int fs;
void func() {
fs = 100;
} ///:~
The static specifier may also be
used inside a class. This explanation will be delayed until you learn to
create classes, later in the
book.
