Functions

• Like a mini-program (or subprogram) in its own right
• Can take in special inputs (arguments)
• Can produce an answer value (return value)
• Similar to the idea of a function in mathematics

Why write and use functions?

• Divide-and-conquer
  • Can breaking up programs and algorithms into smaller, more manageable pieces
  • This makes for easier writing, testing, and debugging
  • Also easier to break up the work for team development
• Reusability
  • Functions can be called to do their tasks anywhere in a program, as many times as needed
  • Avoids repetition of code in a program
  • Functions can be placed into libraries to be used by more than one "program"

With functions, there are 2 major points of view

• Builder of the function -- responsible for creating the declaration and the definition of the function (i.e. how it works)
• Caller -- somebody (i.e. some portion of code) that uses the function to perform a task

Using Functions

• The user of a function is the caller.
• Use a function by making calls to the function with real data, and getting back real answers.
• Consider a typical function from mathematics:

    f(x) = 2x + 5
  

  In mathematics, the symbol 'x' is a placeholder, and when you run the function for a value, you "plug in" the value in place of x. Consider the following equation, which we then simplify:

    y = f(10)		// must evaluate f(10)
    y = 2 * 10 + 5	// plug in 10 for x
    y = 20 + 5
    y = 25		// so f(10) gives the answer 25
  

  In programming, we would say that the call f(10) returns the value 25.
   
• C++ functions work in largely the same way. Format of a C++ function call:

    functionName(argumentList)
  

  where the argumentList is a comma-separated list of arguments (data being sent into the function). Use the call anywhere that the returned answer would make sense.
   
• Example. There is a pre-defined math function called sqrt, which takes one input value (of type double) and returns its square root. Sample calls:

    double x = 9.0, y = 16.0, z;
  
    z = sqrt(36.0);	// sqrt returns 6.0 (gets stored in z)
    z = sqrt(x);		// sqrt returns 3.0 (gets stored in z)
    z = sqrt(x + y);	// sqrt returns 5.0 (gets stored in z) 
  
    cout << sqrt(100.0);	// sqrt returns 10.0, which gets printed
  
    cout << sqrt(49);     // because of automatic type conversion rules
  			//  we can send an int where a double is expected
  			//  this call returns 7.0
  
    // in this last one, sqrt(625.0) returns 25.0, which gets sent as the
    //  argument to the outer sqrt call.  This one returns 5.0, which gets
    //  printed
  
    cout << sqrt(sqrt(625.0));	
  

  Try this code here
   
• In keeping with the "declare before use" policy, a function call can be made ONLY if a declaration (or definition) of the function has been seen by the compiler first.
  • This can be done by placing a declaration above the call
  • This is handled in libraries by including the header file for the library with a #include directive

Predefined Functions

• There are many predefined functions available for use in various libraries.
  • These typically include standard libraries from both C and C++
  • These may also include system-specific and compiler-specific libraries depending on your compiler
  • Typically, C libraries will have names that are prefixed with the letter 'c'. (cmath, cstdlib, cstring)
• To make such functions available to a program, the library must be included with the #include directive at the top of your file. Examples:

    #include <iostream>		// common I/O routines
    #include <cmath>		// common math functions
    #include <cstdlib>		// common general C functions
  

Building Functions

Declaring a Function

• A function declaration, or prototype, specifies three things:
  • the function name -- usual naming rules for user-created identifiers
  • the return type -- the type of the value that the function will return (i.e. the answer sent back)
  • the parameter list -- a comma separated list of parameters that the function expects to receive (as arguments)
    • every parameter slot must list a type (this is the type of data to be sent in when the function is called)
    • parameter names can be listed (but optional on a declaration)
    • parameters are listed in the order they are expected
• Declaration Format:

    return-type function-name( parameter-list );
  

• Examples:

    // GOOD function prototypes
    int Sum(int x, int y, int z); 
    double Average (double a, double b, double c);
    bool InOrder(int x, int y, int z);
    int DoTask(double a, char letter, int num);
  
    double Average (double, double, double);    // Note: no parameter names here
  					      //       okay on a declaration
  
    // BAD prototypes (i.e. illegal) 
    double Average(double x, y, z);  // Each parameter must list a type 
    PrintData(int x);                // missing return type 
    int Calculate(int)               // missing semicolon 
    int double Task(int x);	   // only one return type allowed!
  

Defining a Function

• a function definition repeats the declaration as a header (without the semi-colon), and then adds to it a function body enclosed in a block
  • The function body is actual code that is implemented when the function is called.
  • In a definition, the parameter list must include the parameter names, since they will be used in the function body. These are the formal parameters
• Definition Format:

    return-type function-name( parameter-list ) 
    { 
       function-body (declarations and statements) 
    } 
  

• To send the return value out, use the keyword return, followed by an expression that matches the expected return type

    return expression;
  

• Definition Examples:

    int Sum(int x, int y, int z)
    // add the three parameters together and return the result
    {
       int answer;
       answer = x + y + z;
       return answer;
    }
   
    double Average (double a, double b, double c)
    // add the parameters, divide by 3, and return the result
    {
       return (a + b + c) / 3.0;
    }
  

• More than one return statement may appear in a function definition, but the first one to execute will force immediate exit from the function.

    bool InOrder(int x, int y, int z)
    // answers yes/no to the question "are these parameters in order,
    //  smallest to largest?"  Returns true for yes, false for no.
    {
       if (x <= y && y <= z)
  	return true;
       else
  	return false;
    }
  

• Sample code using the functions above:
  • Example 1 -- this file uses a layout that works, but is not as desirable
  • Example 2 -- this file illustrates a better layout for satisfying declare-before-use

Scope of Identifiers

• The scope of an identifier (i.e. variable) is the portion of the code where it is valid and usable
• A global variable is declared outside of any blocks, usually at the top of a file, and is usable anywhere in the file from its point of declaration.
  • "When in doubt, make it global" == BAD PROGRAMMING PRACTICE
  • Best to avoid global variables (except for constants, enumerations. Sometimes)
  • Function names usually global. (prototypes placed at the top of a file, outside any blocks)
• A variable declared within a block (i.e. a compound statement) of normal executable code has scope only within that block.
  • Includes function bodies
  • Includes other blocks nested inside functions (like loops, if-statements, etc)
  • Does not include some special uses of block notation to be seen later (like the declaration of a class -- which will have a separate scope issue)
• Variables declared in the formal parameter list of a function definition have scope only within that function.
  • These are considered local variables to the function.
  • Variables declared completely inside the function body (i.e. the block) are also local variables
• Example showing variables with different scopes
• A trickier example. Be careful!

void functions and empty parameter lists

• Parameter lists
  • Mathematical functions must have 1 or more parameters
  • C++ functions can have 0 or more parameters
  • To define a function with no parameters, leave the parentheses empty
  • Same goes for the call. (But parentheses must be present, to identify it as a function call)
• Return types
  • A mathematical function must return exactly 1 answer
  • A C++ function can return 0 or 1 return value
  • To declare a function that returns no answer, use void as the return type
  • A void function can still use the keyword return inside, but not with an expression (only by itself). One might do this to force early exit from a function.
  • To CALL a void function, call it by itself -- do NOT put it in the middle of any other statement or expression
• Sample declarations:

    char GetALetter();				// no parameters
    void PrintQuotient(int x, int y);		// void return type
    void KillSomeTime();				// both
  

• Code example with definitions and calls for these functions
• Here's an interesting void function -- see if you can figure out what it does. (It will illustrate an important thing about passing parameters).

Functions and the compiler

• The reason for the declare-before-use rule is that the compiler has to check all function CALLS to make sure they match the expectations.
  • the "expectations" are all listed in a function declaration
  • function name must match
  • arguments passed in a call must match expected types and order
  • returned value must not be used illegally
• Decisions about parameters and returns are based on type-checking.
  • legal automatic type conversions apply when passing arguments into a funcion, and when checking what is returned against the expected return type
• Try this example -- see if you can predict which calls the compiler considers legal and which ones are illegal