CS 12 - Fall 2003

CS 12 - Static Keyword

A Lot of Static

Note: We will be having a practical examination in lab today. Download the following code and modify it to read in numbers from the user until the user hits Control D. There is no limit of the amount of numbers that the user can enter, so arrays are not advised. The code for this assignment can be found here.

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.
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.
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.

The Assignment

7 pointsWrite 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. (Thus we have 2 function-level static variables and 1 class-level static variable.)

Assorted Questions

Answer these questions in "questions.txt" unless told otherwise

.2 points What would happen if we removed the static keyword from the first example?
.2 points What is the difference between a static member and a const member?
.2 points What would be the result of making "getNumFoos()" and "resetNumFoos()" non-static in the second example?
.2 points 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.)
.2 points Do some online research and find out the meaning of the static keyword on a global variable.
.2 points When would a static global variable be useful?
.4 points 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. (Note: This is most of the difficulty of the Fibonacci Table assignment.) Turns this in as "allocate.cc"