Wednesday, November 22, 2006 Monday, November 27, 2006

Function Analysis

Topics

• Function Analysis
• You can catch a number of logical error just by analyzing the formal parameters and local variables inside a function.
• Function analysis can be done quickly by just scanning a function's text.
• Since functions normally should be short, about a screen full of code only, you can usually analyze a function's variables quite quickly.
• Once you get used to doing this analysis, you do it almost automatically as you write your function.  It prevents many logic errors.
• It can also find "silly" code.  Silly code does not cause a logical bug, but is doesn't accomplish anything either, except making your code unnecessarily complex.
• Analysis of local variables and formal parameters
• A local variable is any variable declared inside the curly braces of a function.  They are not formal parameters, although formal parameters are nearly identical to local variables.
• The analysis of local variables depends on your ability to recognize a use and a change of a variable. 
• A use of a variable occurs in the following ways (99% of the time):
•        A variable appears in the rvalue of an assignment statement, to the right of the = operator.
•        A variable appears in a condition of an if, switch, or loop statement.  That is, inside the parentheses (   ) 
•        A variable is used in an output statement (which is really just a pass by value argument in a function call -- see the next line)
•        A variable is used as the argument that is passed by value in a function call , that is, an IN ONLY argument.
•  
• A change of a variable occurs in the following ways (99% of the time):
•        A variable appears in the lvalue of an assignment statement, to the left of the = operator.
•        A variable is used in an input statement (which is really just a pass by reference argument in a function call -- see the next line)
•        A variable is used as the argument that is passed by reference in a function call , that is, an IN / OUT or an OUT ONLY argument.  
•     
• An initialization is just the first change of a variable, often done when the variable is declared, but not required then.  Formal parameters are just local variables that are initialized automatically with the value of the corresponding argument in the function call.
• The important part:
• Local variables and formal parameters almost always should follow the following pattern inside a function.  If this pattern is broken it is almost always a logical error.
•         Initialzation (just the first change.  Done automatically for formal parameters)
•         Use, Use, Use, ....   (any number of times)
•         Change    (once only)
•         Use, Use, Use, ....   (any number of times)
•         Change    (once only)
•         Use, Use, Use, ....   (any number of times)
•         Change    (once only)
•         Use, Use, Use, ....   (any number of times)
•         ....  and so on.
•        .
• The following patterns usually signify a problem:
•         Use, Use, Use, ....   (any number of times)
•         Change   
•         Change   
•         Use, Use, Use, ....   (any number of times)
•  
•         Why make the first change if you don't use it?  Just get rid of the first change.  It is probably "silly code".
•  
•  For Local Variables and pass by value formal parameters only:
•     returntype functionname(datatype parameter)
•     {
•         Initialization (just the first change.  Done automatically for formal parameters)
•         Use, Use, Use, ....   (any number of times)
•         Change    (once only)
•         Use, Use, Use, ....   (any number of times)
•         Change    (once only)
•      }
•  
•          What is the point of the last change?  If the variable is a pass by reference this would make sense because the change would actually be to the calling function's argument variable, and could be used after the function returns to the calling function.  However it is "silly code" if the variable is local or a pass by value formal parameter.
• For pass by value formal parameters only:
•     returntype functionname(datatype parameter)
•     {
•         Change    (once only)
•         Use, Use, Use, ....   (any number of times)
•         Change    (once only)
•         Use, Use, Use, ....   (any number of times)
•      }
•         Why pass a parameter by value if the first thing you do is change it?  This variable probably should be a local variable, not a formal parameter.
•  
• For pass by reference formal parameters only:
•     returntype functionname(datatype& parameter)
•     {
•         Use, Use, Use, ....   (any number of times)
•         Use, Use, Use, ....   (any number of times)
•      }
•  
•      Why pass by reference if all you are going to do is use the variable and not change it?  If no changes to the original variable in the calling function, there is no point to pass by reference.  Pass by value instead.
• For local variables only:
•     returntype functionname()
•     {
•         Use, Use, Use, ....   (any number of times)
•         Change    (once only)
•         Use, Use, Use, ....   (any number of times)
•      }
•         You should recognize this a the common problem of forgetting to initialize a local variable.  It must be changed to its initial value before it can be used.
•  

Readings