Topics to Cover

• Function prototypes
• Function definitions
• Function calls
• Input parameters vs arguments
• Scope of local variables in a function definition
• Pass by value

Motivating Example: Code reuse

• If we're writing a program to compute gcd's, we'd ask the user twice to enter in a positive number. This program illustrates how we'd have to do it.

int main()
{
  int a = getposint(), b = getposint();
  
  // Compute gcd
  while(b != 0)
  {
    int r = a % b;
    a = b;
    b = r;
  }

  // Write out gcd
  cout << "The gcd is " << a << endl;

  return 0;
}

This is a tremendous improvement! Unfortunately, such a function is not a part of any of the standard libraries. Therefore, it's up to us to make it!

Prototypes

double cos(double x);

//  double           cos      ( double  x );
// \______/         \___/       \________/
// return type  function name  input parameter

Prototype of a user defined function

• It must be defined outside of the main block.
• It must appear before you ever use the function.

Now, in the getposint function we'd envisioned earlier, there's nothing that the function takes as input from the program, and it should evaluate to or return the positive integer it's read in from the user, so the right prototype would be:

int getposint();

Function Definitions

int getposint()
{
  int k;
  cout << "Enter a positive integer: ";
  cin >> k;
  while(k <= 0)
  {
    cout << "I said *positive*, try again: ";
    cin >> k;
  }

  return k;
}

Function call

cos(45)/2

1. cos(45) is a function call.
2. Recall the prototype of function cos().

   
     double cos(double x);
     

   Since cos takes a double object as input, the integer 45 is converted to double 45.0.
3. Evaluating cos results in a double object as specified by the prototype.
4. Since cos returns a double object, the integer 2 is promoted to a double 2.0 before division.
5. We get double division and a double result.

Input parameter vs. argument

First, we need a prototype that specifies that our function (we'll call it factorial) takes an integer value and returns an integer value:

int factorial(int x);

int factorial(int x)
{
  int f = 1;
  while (x > 0)
  {
    f = f*x;
    x--;
  }
  return f;
}

int y = factorial(4);

Scope and Functions

int f();

int main()
{
  int a, b;
  a = 0;
  b = f();
  cout << "a = " << a << endl;

  return 0;
}

int f()
{
  int a = 2;
  return -1;
}

Local variables

Since they are in different scopes, however, there is no confusion or conflict. We say that variables like this are local to the functions in which they are defined, i.e. they don't exist outside of the functions in which they are defined. The way that you want to think of this is that each function call is like a piece of paper with boxes for each of the function's local variable. When a function is called a new piece of paper is stacked on the others. The computer only actually works on the function call represented by the top paper on the stack. This animated image helps you think about how variable scope works with function calls. In the case of calling the function f() in evaluating b = f(), you should be thinking of this ...

Pass by value

int main()
{
  int y = 4;
  int z = factorial(y); 
  cout << y << endl;
  return 0;
}

Answer (drag your mouse): 4  

• (scope of y) Note that y is in the stack of main.
• (function call) Recall that when factorial is called, a new stack for factorial will be created on top of the main function.
• (scope of x) Note that x is in the stack of factorial.
• Therefore, x and y are different objects! It's just that the value of y was copied to x when the function was called.

Vocabulary

function prototype - The prototype tells us what we need to know to use the function ... everything except what the function actually does! If you are presented with only a prototype there is usually some documentation that describes what task the function accomplishes. function definition - This is where we provide the code that determines how the function operates, i.e. how it does whatever it does. argument to a function - when we use a function ("call" a function) and we provide an expression whose value will be passed into the function, that expression is called an argument to the function. function parameter - a function gives a name (and a type) for the value that is going to be passed into the function. That name is called a parameter. It's what is used inside the function definition to refer to the value that was passed into the function when the function was called. function call - also called application - the point in the execution of a program at which the function expression is evaluated and, as a result, the function body executed.

• pass a value to a function - this is often how we refer to the argument that a function receives when it is called.
• pass-by-value - see above. Describes the basic function calling mechanism for C++, in which the function receives a copy of whatever argument object appears where the function is called, not the actual argument object itself.
• function call site - the location in the source code of the expression that uses the function.
  Note: Often we say "function call" when we mean "call site". It just requires some context. When we are talking about a location or a specific expression in the source code, we mean "call site". When we are talking about something that happens while the program is executing, we mean "call".
• function's return value - also called result - the object that results from evaluating the function call expression.

Mandatory Practice Problems

int main()
{
  int a = getposint(), b = getposint();
  cout << "The gcd is " << gcd(a,b) << endl;
  return 0;
}

Other Practice Problems

1. Marathon Times
2. Date Calculator
3. Approximating e
4. Adjective Endings for Numbers
5. Writing zip codes in words