CS 12 - Spring 2003

A Lot of Static

Note: We will be having a practical examination in lab this week, as a result the in lab exercises will not be graded. It is still mandatory that you remain in lab the entire period.

Reminder: There will be no lab next week (May 26-30) due to the Memorial Day holiday. We highly recommend that you make up the lab period by finding a programming project for yourself. Taking an active role in your learning is a good way to master programming, or any other discipline. Try to use your break constructively.

Static

The static keyword in C++ has many features, which are useful in differing circumstances. Generally you can think of static as meaning "Only one copy," although there are some uses that don't quite fit this description. Lets look at some of the uses for the "static" modifier.

Objects: Static member variables:
```
class Foo
{
public:
  static int numFoos;
  Foo() { numFoos++; }
  ~Foo() { numFoos--; }
};

int Foo::numFoos = 0;
  
```
In the above example, we declare "numFoos" to be a static member of class Foo. When a member variable is declared static, it means that there is only one instance of that variable for all instances of the class. This means that the numFoos member of any object of type Foo will be the same. One of the most common (and easily understood) uses for this is to implement a counter for the number of instantiated objects, which is what the Foo example does. Every time a new Foo is created, numFoos is incremented. Every time a Foo is destroyed, numFoos is decremented. In this way, the numFoos member always stores the number of Foos in existence.

Note that static members need to be specially initialized outside of the class definition, as above.

Question (easy): What would happen if we removed the static keyword from the above example?
Objects: Static member functions:
```
class Foo
{
public:
  Foo() { numFoos++; }
  ~Foo() { numFoos--; }
  static int getNumFoos() { return numFoos; }
  static void resetNumFoos() { numFoos = 0; }

private:
  static int numFoos;
};

int Foo::numFoos = 0;
  
```
A static function is often useful when you want a function that operates on static variables of a class, or that can operate when there is no instance of the class. For example, with the above version of Foo, either of the following will return the number of objects with type Foo that have been created:
```
Foo myFoo;
cout << "Num foos = " << myFoo.getNumFoos() << endl;
```
or
```
cout << "Num foos = " << Foo::getNumFoos() << endl;
```
For non-static member functions, there is no method of calling a function equivalent to the second example here.

Question (easy): What would be the result of making "getNumFoos()" and "resetNumFoos()" non-static in the above example?

Question (hard): Why can you not call Object::function() for non-static functions? (HINT: Try to think like the compiler, knowing that you have to prevent any problems at compile time.)
Static variables:A third use for the static keyword is to declare static variables. Static variables are variables that are local to a given scope that do not reset their value when they go out of scope. For example:
```
void myFunction()
{
   static int numCalled = 0;
   ... // Does some stuff

   numCalled++;
   cout << "Function myFunction has been called " << numCalled
        << " times." << endl;
}
```
demonstrates a simple (and sometimes useful) reason to use a static variable.

Question (hard): Write a function "void staticAllocator(int size)" that has two static members, "static int allocated;" and "static int* array;". Every time the function is called, check to see if size is larger than what has been allocated, and if not, delete the contents of array and re-allocate with the larger size.

Assorted Questions

Easy What is the difference between a static member and a const member?
Google for a good online tutorial or reference on the differences and uses of the various types of static.
Medium Write a class that counts how many instances of that class are currently allocated. Give that class two constructors, each of which has a static variable that counts how many times that constructor has been called. Check that the sum of those two values is equal to the counter.
Think of a good reason to have a member of an object be both static and const. (Hint: think of efficiency.)
Hard Write an efficient function that computes the Fibonacci sequence using static variables. Use the allocation style introduced in the section on static functions to store the results of previous Fibonacci calculations.