Static Variables

• Normally the lifetime of a variable is over a single invocation of the procedure.
• These are automatic variables as we discussed before.
• We can make the lifetime of a variable persist through ALL calls to the routine.
• Such a variable is called a static variable.

• 
  void foo () {
     static int x=0;
  
     x++ ; 
     cout  << " in foo  x = " << x << endl;
  }
  

• On the first call, x is initialized to 0.
• On each additional call, x is not reinitialized, but maintains its value.

Namespaces

• A namespace is another term for scope.
• In C++ the namespace command allows us to bring a set of identifiers into the scope of the program.

• using namespace std;
  

• Notice, we have been using these like global constants.
• You will get more on this when you talk about classes, next semester.

Side Effect

• Side Effect is any effect of one function on another that is not part of the explicitly defined interface between them.
• Side Effect creates bugs that are hard to detect.
• It always involves the global use of a variable.
• It does not occur when you pass parameters

• int a;
  
  void foo() {
     a ++;
  }
  

• We cause side effect when we do input or output in a routine without passing the file stream handle. This is ok (to some extent)

Ignoring the Return Value of a Function

• If you have a value returning function, you don't always need to do something with the value it returns.
• This is often the case if you write a routine to do something, and return true on success or false on failure.

Stubs and Drivers

• When designing and coding a problem, you may want to start coding before you have finished the design.
• When doing a functional decomposition, you might have the main routine, but not have written the lower level routines.
  • In this case you write a stub.
  • This is a function with the right name and parameters
  • It returns without doing something
  • Or possibly with a single result (not necessarily the correct result)
  • This lets you check the overall correctness of your design without messing in the low level details.
• When doing a Object Oriented Design, you may have some utility functions, but not the main routine.
  • In this case, you write a driver
  • This is a program that exercises the lower level routines.
  • It calls them with all possible inputs, to see if they work.