Static (Class-wide) Members
David Kieras
Prepared for EECS 381, Fall 2004
Non-static (ordinary) member variables
Regular member variables of a class exist in every object. That is, when you declare a class and list
the member variables, you are saying that every object in the class should have its own space in
memory for each member variable.
class Thing {
public:
int x;
int y;
};
...
int main()
{
Thing t1, t2
...
After the declaration of Things t1 and t2, each consists of a piece of memory holding two integers,
so we have t1.x, t1.y, t2.x, t2.y. Each object has its own individual x and y variables.
Static member variables
Sometimes it is handy to have a member variable that is associated with the whole class instead of
individual objects. Such a variable occupies its own piece of memory, by itself, instead of being part
of an individual object. It is essentially a global variable, but its name is contained inside a class
scope, so it goes with the class instead of being known everywhere in the program. Such a member
variable can be made private to a class, meaning that only member functions can access it. A good
name for this property would be something like "class-wide" or "whole-class", but unfortunately,
the overworked keyword "static" was used instead, so we have "static member variables".
Here is an example of a Thing class where a static member variable, named "count", is used to keep
a count how many Things exist. Every time a Thing is created, the constructor will increment the
count; every time a Thing is destroyed, the destructor will decrement the count. Because the count
variable is not part of individual objects, but exists for the entire class, it "lives" past the creation and
destruction of individual objects, retaining its value while the individual objects come and go.
Example:
class Thing {
public:
Thing ()
{count++;} // there is now one more Thing
~Thing ()
{count--;} // there is now one fewer Thing
int x;
int y;:
static int count;
};
In this example, count is a public static member variable whose full name is Thing::count. Even if it
was private, the constructor and destructor member functions can access it because they are
member functions. Because count is static, it is a class-wide member variable, not a member
