Lecture #7: Functions

Computer Programming (7) - Functions

administrivia

Web Page - http://www.cs.tau.ac.il/~efif/courses/ComputerProgramming

what’s a function?

a group of declarations and statements that is assigned a name
- effectively, a named statement block
a sub-program
- we write our program by writing a function named main
- inside which we can use other functions
  - which can themselves use other functions, and so on…

why use functions?

they can break your problem down into smaller sub-tasks
- easier to solve complex problems
they make a program much easier to read
- "abstraction"
  - like printf, we just have to know what a function does without worry about the details of how it works
generalize a repeated set of instructions
- we don’t have to keep writing the same thing over and over

characteristics of functions

name
arguments
body
return value

function name

is an identifier
this is how you refer to the function elsewhere in the program

function arguments

these are variables whose values you specify every time you invoke the function
- so they can have different values each time

function body

these are the declarations and statements that actually do the work
specified in the function definition

return value

a function can optionally return a value.
this value becomes the value of the function call expression
if a function doesn’t return a value, the return type should be void

function declaration

just as with variables, functions can be declared
the declaration contains:
- the function name
- the data types of the arguments
- the data type of the return value

function declaration vs. definition

the definition is the actual function
- it has the function name
- it has the argument declarations
- it specifies the return type
- it has the statements that comprise the function body
the declaration is just a reference to the function
- it has the function name
- it has the argument data types
- it specifies the return type
- it has no code

what does the function declaration do?

it enables you to call a function without having to know the definition
- remember when we used printf?
  - we didn’t know how the function worked
  - but the compiler needed to know that printf was actually a function
  - the file stdio.h contains a declaration for printf

function definition is a declaration

you need to declare a function before you can call it
- at least you do in order to adhere completely to the ANSI standard
you can declare the function by:
- including a function prototype
- including the function definition

function prototype

this is a fancy name for a function declaration that isn’t the function definition
it must include:
- the return type
- the function name
- the data types of the arguments in parentheses
  - optionally with names, but they’re ignored
- and a semicolon after the right parenthesis

an analogy

when you buy a TV, you get a user’s manual
- that manual tells you how to change channels
  - in case you’ve been living in a cave for the past 50 years
- once you’ve read the manual, I can tell you, "change to channel 7" and you know what to do
- or I can say, "change to channel 4"
in this analogy:
- "change the channel" is the function
- the channel number is the argument

another analogy

you know (or can learn) how to calculate the geometric area of an ellipse
- given the major and minor axes
once you know, all I have to do is give you the two values, and you give me back a number
in this analogy:
- "calculate the area of an ellipse" is the function
- the lengths of the 2 axes are the arguments
- the area is the return value

function example

what does this function do?

int multByTwo (int x)
{
  int retval;
  retval = x * 2;
  return retval;
}

it takes a single argument
- an int
it returns the value of that argument multiplied by two
- also an int

how might we call this function?

#include <stdio.h>
int multByTwo (int x);
int main (void)
{
  int i;

  for (i = 0; i < 10; ++i) {
    int j;

    j = multByTwo (i);
    printf ("%d times two is %d\n", i, j);
}

note this

variable names
- inside multByTwo, the argument is named x
- when we call it, we pass a variable named i
- there is no correspondence between the name of what we pass in and what we call it inside the function

function call expression

we now have a new expression: the function call
- the expression is evaluated by executing the statements in the function
- the value of the function call expression is determined by the first return statement encountered in the function

function call expression example

so given the code:
i = multByTwo (37) + 4;
- the statement is an assignment expression statement
  - operator is =
  - operands are i and the expression multByTwo(37) + 4
  - the sub-expression is an arithmetic expression
    - operator is +
    - operands are the expression multByTwo(37) and 4
  - multByTwo(37) is an expression
    - it is evaluated by calling the function multByTwo, with the argument 37

function call expression example continued

when the computer evaluates the expression

multByTwo (37)

it invokes the function:

int multByTwo (int x)
{
  int retval;
  retval = x * 2;
  return retval;
}

function call

int multByTwo (int x)
{
  int retval;
  retval = x * 2;
  return retval;
}

the local variable x is set to the value of the argument
- which in this case was a constant, 37
- retval is set to 74
- the value 74 is returned, which means the value of the expression multByTwo(37) becomes 74

expression evaluation

i = multByTwo (37) + 4;

so the value of the expression
multByTwo (37) + 4
becomes 78
and this is what i gets set to

return statement

this is the statement that causes the function to return a value
- it must return a value that can be converted into the data type specified as the function return value
a function may have any number of return statements, but the first one encountered will end the execution of the function and return the value

return statement example

double absolute_value (double d)
{
  if (d >= 0)
    return d;
  else
    return -d;
}

function arguments

each argument declares a local variable that is only accessible from inside the function
- its value is set using the value that is specified in the call
- it ceases to exist after the return statement is executed
  - usually…
Important concept here:
- the local variable inside the function is totally distinct from the variable whose value was used to call the function
  - so if the function changes the value of one of its arguments, it doesn’t affect the variable used to call the function

pass-by-value

this is the term that means that function arguments are passed into the function by copying their values
- rather than giving the function direct access to the actual variables
  int AddOne (int i) { i = i + 1; return i; }
- so if I call this function like this:
  a = AddOne (b);
- it does not change the value of b

let’s review functions

a function is like a small program within the program
you pass data into the function via its arguments
you get data back from the function via its return value
you call the function using a function call expression

function example

/*
 * power: calculate m to the n-th power
 */
int power (int m, int n)
{
  int i;
  int product=1;

  for (i = 1; i <= n; ++i)
    product *= m;
  return product;
}

function example – arguments

int getopt(int argc, char * argv[], const char * opts)
{
  register char c;
  ...
}

arguments

the functions argument define variables for the function
- these variables are only available from inside the function
- their values are set to whatever values are “passed in” when the function is called
- these are copies of the values that are passed. Changing the value of an argument does not change the value of the variable whose value was passed in

function example – return value

int getopt(int argc, char * argv[], const char * opts)
{
  register char c;
  ...
}

return value

the function can return a single value
- its data type is defined as part of the function declaration
- if the function is declared as returning a value, it must return a value
- if you don’t want to return a value, the return type should be void

function call expression

you invoke a function when the computer evaluates a function call expression
- function name followed by arguments in parentheses
- commas separate multiple arguments
- if no arguments, just empty parentheses

let’s look at an example

#include <stdio.h>

int power (int, int);
void print_heading (void);
void print_table (int);

int main (void)
{
  print_heading ();
  print_table (7);
  return 0;
}

void print_heading (void)
{
  printf ("\nTable of Powers\n");
}

void print_table (int n)
{
  int i, j;

  for (i = 1; i <= n; ++i) {
    for (j = 1; j <= n; ++j) {
      int pwr = power (i, j);
      if (j == 1)
        printf ("%1d", pwr);
      else
        printf ("%9d", pwr);
    }
    printf ("\n");
  }
}

int power (int m, int n)
{
  int i;
  int product = 1;

  for (i = 0; i < n; ++i)
    product *= m;
  return product;
}

example

Function 1: main()

Function 2: print_heading()

function #2 is named print_heading
- we have to declare it
- it takes no arguments, void in the declaration
- we call it using a function call expression

Function 3: print_table()

function #3 is named print_table
- it takes a single argument, an int
- we have to declare it too
- we call it

Function 4: power()

function #4 is called power
- it takes 2 arguments
- we declare it
- we call it

function declaration issues

we must declare a function before we can call it
- we can use a function prototype
  int power (int, int); void print_heading (void); void print_table (int);
- or we can use the function definition as a declaration
  - but only so long as the definition comes before the call
  - so in our example, we used prototypes because our function definitions came after the function calls

example

function definition order

but if we had introduced the functions in a different order, we wouldn’t need to use prototypes
- because the definition also declares the function

example (rearranged)

#include <stdio.h>

int power (int m, int n)
{
  int i;
  int product = 1;

  for (i = 0; i < n; ++i)
    product *= m;
  return product;
}

void print_heading (void)
{
  printf ("\nTable of Powers\n");
}

void print_table (int n)
{
  int i, j;

  for (i = 1; i <= n; ++i) {
    for (j = 1; j <= n; ++j) {
      int pwr = power (i, j);
      if (j == 1)
        printf ("%1d", pwr);
      else
        printf ("%9d", pwr);
    }
    printf ("\n");
  }
}

int main (void)
{
  print_heading ();
  print_table (7);
  return 0;
}

each call comes after the function definition

prototype issues

there are some issues here…
- this can be harder to read
  - since main now comes at the end
  - it’s kind of Reverse Polish Notation for programs
- it only works within a single file
  - we’ve only seen programs that fit in a single file
  - but we can use multiple .C files to write our program
  - every function must be defined in a single file
  - but each function could be in a different file

example

main.C:

void print_heading (void);
void print_table (int);

int main (void)
{
  print_heading ();
  print_table (7);
  return 0;
}

void print_table (int n)
{
  int i, j;

  for (i = 1; i <= n; ++i) {
    for (j = 1; j <= n; ++j) {
      int pwr = power (i, j);
      if (j == 1)
        printf ("%1d", pwr);
      else
        printf ("%9d", pwr);
    }
    printf ("\n");
  }
}

int power (int m, int n)
{
  int i;
  int product = 1;

  for (i = 0; i < n; ++i)
    product *= m;
  return product;
}

print_table.C

#include <stdio.h>

int power (int, int);

void print_heading (void)
{
  printf ("\nTable of Powers\n");
}

variable declarations

we can now revisit variable declarations, and discuss some issues we passed over the first time

variable concepts

scope
visibility
extent

scope

the region of the program code in which declaration has effect
- local variables: declaration through to end of block
- global variables: declaration through to end of file
- parameters: through to end of function

what does this mean?

it means that when you declare a variable, it doesn’t mean the variable is available everywhere

example – local scope

main.C:

void print_heading (void);
void print_table (int);

int main (void)
{
  print_heading ();
  print_table (7);
  return 0;
}

void print_table (int n)
{
  int i, j;

  for (i = 1; i <= n; ++i) {
    for (j = 1; j <= n; ++j) {
      int pwr;
      pwr = power (i, j);
      if (j == 1)
        printf ("%1d", pwr);
      else
        printf ("%9d", pwr);
    }
    printf ("\n");
  }
}

int power (int m, int n)
{
  int i;
  int product = 1;

  for (i = 0; i < n; ++i)
    product *= m;
  return product;
}

print_table.C

#include <stdio.h>

int power (int, int);

void print_heading (void)
{
  printf ("\nTable of Powers\n");
}

example – parameter scope

main.C:

void print_heading (void);
void print_table (int);

int main (void)
{
  print_heading ();
  print_table (7);
  return 0;
}

void print_table (int n)
{
  int i, j;

  for (i = 1; i <= n; ++i) {
    for (j = 1; j <= n; ++j) {
      int pwr = power (i, j);
      if (j == 1)
        printf ("%1d", pwr);
      else
        printf ("%9d", pwr);
    }
    printf ("\n");
  }
}

int power (int m, int n)
{
  int i;
  int product = 1;

  for (i = 0; i < n; ++i)
    product *= m;
  return product;
}

print_table.C

#include <stdio.h>

int power (int, int);

void print_heading (void)
{
  printf ("\nTable of Powers\n");
}

example – global scope

main.C:

void print_heading (void);
void print_table (int);
int table_size = 7;

int main (void)
{
  print_heading ();
  print_table (table_size);
  return 0;
}

void print_table (int n)
{
  int i, j;

  for (i = 1; i <= n; ++i) {
    for (j = 1; j <= n; ++j) {
      int pwr = power (i, j);
      if (j == 1)
        printf ("%1d", pwr);
      else
        printf ("%9d", pwr);
    }
    printf ("\n");
  }
}

int power (int m, int n)
{
  int i;
  int product = 1;

  for (i = 0; i < n; ++i)
    product *= m;
  return product;
}

print_table.C

#include <stdio.h>

int power (int, int);

void print_heading (void)
{
  printf ("\nTable of Powers\n");
}

the variable table_size is available to all functions in file main.C
- which, in this particular case, is only
  main()

examples

command line options

Maintained by Efi Fogel. Last modified: November 16 2003.