Getting the work done

Functions

    returnType className::functionName(argument list)
    {
        functionBody;
    }

• All functions (except the constructor and destructor in classes) must have a return type.
• Return type can be void but must be declared.
• Return type can be any of the primitive data types or pointers to structures or classes.
• You must use the return val; keyword and value syntax to return a value.
• All return paths from the function MUST return a value of the appropriate type. The compiler will warn you ("Not all paths return a value.") if you do not do this. You should pay attention to warnings from the compiler.
• If the return type is void you can exit from the function at any point with just the return command.

• All functions that are defined as part of a class in a class definition file (.h) must have the class name before the functionName and separated by two colons. (If you forget this you will get some strange compiler errors because even if the function is in the .cpp file it will not be recognized as part of the class.)

• Can be anything you want.
• Try not to be overly verbose, e.g. don’t use something like calculateTheSumOfSquaresRecursively() when you can use sumOfSquares()
• While not required the "traditional" format is to capitalize each word in the function name except for the first.
• Should be meaningful, e.g. sumOfSquares() not SOS() or function1().

• All arguments in the format dataType argName.
• If parentheses are empty the function has no arguments. Old style function definitions required you to use the word “void”. You can do that now but it is not required.
• Try to avoid too many arguments.

• Some say if the function is more than 50 lines it should be broken down into smaller functions. Others say 25, or 100, etc. Use your own judgement.
• Old style C required declaring all variables at the beginning of the function before any other code. You can now declare variables anywhere. This is good because it lets you declare a variable close to where it will be used. But, it can be confusing because it may make it difficult to find where a variable you see being used is actually declared.

Function Prototypes

Default Arguments to Functions

    void someFunction(int x, double d, char c, long l)
    {
         // function body here
    }

    void someFunction(int x=0, double d=1.5, char c='a', long l=1)

	someFunction(1, 2.5, ‘z’, 32);   // normal calling format
	someFunction(1, 2.5, ‘z’);       // 3 args (arg l takes default value)
	someFunction(1, 2.5);            // 2 args (args c and l take default values)
	someFunction(1);                 // 1 arg (args d, c, l take default values)
	someFunction();                  // 0 args (all take default values)

	someFunction(1, 2.5, 32);   // left out a char argument

Variable Argument Lists

• You must include the header file <cstdarg> this gives you the ability to parse out all the arguments.
• You must have some way of indicating the number of arguments in each call.
  
  • Pass in the number of args in a call as the first argument as in the example above.
  • Pass in some other indicator such as the format string in a call to printf().
• In the function use the following global variables and data types defined in cstdarg:
  
  • va_list to create a list of the arguments.
  • va_start(list, argFirst) to initialize the list to all arguments after argFirst
  • va_arg(list, dataType) to fetch each argument. Note, all args must be of the same data type unless there is some indication of what each type will be as in the format specifier string in printf().
  • va_end(list) to clean up after fetching all the arguments

Function Pointers

    void myFunction(int x)
    {
        cout << "x = " << x << endl;
    }

    void(*funcPtr)(int);     // Declare a function pointer called funcPtr
    funcPtr = myFunction;    // Store the address of myFunction in the pointer
    funcPtr(255);            // Call myFunction using the pointer

Virtual Functions

• If a function is declared virtual in a parent class the sub-classes are forced to implement the function.
• A good programmer is aware that if you just make sure you add a draw() function to all sub-classes you override the draw() in the parent class so virtual is not really needed.
• A smart programmer also knows:
  • If you reference a CRectangle or a CCircle object with a CRectangle pointer or a CCircle pointer respectively there is no problem.
  • You may want to have a Vector of CShape objects and iterate through the Vector with a CShape reference calling the draw() function in each.
  • But, if you want to do that and the function in CShape has not been declared as virtual then the compiler won’t know which CShape sub-class is being referenced to it will compile a call to the one in the parent. This is called Early or Static or Compile Time Binding.
  • If you make the draw() function in the parent class virtual however, the compiler will create different code and produce what is called Late or Dynamic or Run-Time Binding. This means when you call a function the code will check the type of sub-class object the parent class pointer is pointing to and call the appropriate sub-class function.
  • The process of treating a sub-class object as if it were an instance of its’ parent class is called upcasting.