CMPT-212 SFU 2008-1
1
Topic: Functions
SFU CMPT-212 2008-1 Topic: Functions
J n Manuch a E-mail: [e-mail] Wednesday 6th February, 2008
Last modied: Wednesday 6th February, 2008, 00:21
2008 J n Ma uch a n
SFU CMPT-212 2008-1
2
Topic: Functions
Functions
Functions are an essential building block of structured and object-oriented programming. Phases in the life cycle of a function:
function prototype (function declaration): describes the shell of a function (name, parameters and return value) return_type function_name(parameters); function denition: describes what the function does
1 2
return_type function_name(parameters) { statements } // function body
function call: using the function within other code function_name(arguments)
Last modied: Wednesday 6th February, 2008, 00:21
2008 J n Ma uch a n
SFU CMPT-212 2008-1
3
Topic: Functions
Function call
Consider a function:
1
double cube(double x) { return x*x*x; } What happens when we call the function?
1 2
double a=1.2; double b=cube(a);
program stores the address of the next instruction copies the values of arguments to the stack (passing the arguments) jumps to the address of the function executes function if needed, places a return value in a specied location (a register or memory) jumps to the saved address
Last modied: Wednesday 6th February, 2008, 00:21
2008 J n Ma uch a n
SFU CMPT-212 2008-1
4
Topic: Functions
Function prototype
describes the function interface to the compiler purpose: the compiler knows what kind of arguments to look for on the stack when it starts executing the function; and knows what return value to retrieve from the specied location after it nishes execution of the function
Note: does not need to provide the names of parameters (just types), and the names can be different from those specied in the function denition Note: you have to specify type for each parameter Example:
1 2
double length(double a, b); // incorrect double length(double a, double b); // correct
automatic conversions: arguments and returned value are automatically converted to types specied in the prototype
Last modied: Wednesday 6th February, 2008, 00:21
2008 J n Ma uch a n
SFU CMPT-212 2008-1
5
Topic: Functions
void
Note. The void type indicates nothing. No variables can be declared as void (but you can declare a pointer void *, which can point to anything). Uses of void:
as the only parameter of a function with no parameters (optional) as the return value of a procedure, a function that does not return any values (mandatory)
Note: in C, an empty parameter list means that function can take any number of arguments (e.g., printf); in C++, it means no parameters! Remark: to see how to declare a function with a variable number of parameters, look at http://www.mycplus.com/tutorial.asp?TID=177
Last modied: Wednesday 6th February, 2008, 00:21 2008 J n Ma uch a n
SFU CMPT-212 2008-1
6
Topic: Functions
Sample questions
What happens when a function is called? Consider the following function
1 2
float cube( double x) { return x*x*x; } and the following line of code int a,b=2; a=cube(b); How many conversions happen when program executes line 2 of the code?
1 2
Last modied: Wednesday 6th February, 2008, 00:21
2008 J n Ma uch a n
SFU CMPT-212 2008-1
7
Topic: Functions
Passing the function arguments
3 possibilities:
by value by address (through a pointer) by reference (C++ feature)
Note. Unless explicitly specied, C++ passes function arguments by value. Example: swap1.cpp Note (Passing arguments by address). Basically, its again passing arguments by value, but the arguments are pointers to data. Example: swap2.cpp
Last modied: Wednesday 6th February, 2008, 00:21 2008 J n Ma uch a n
SFU CMPT-212 2008-1
8
Topic: Functions
Passing arrays
syntax:
1 2
int sum(int array[], int size); // or int sum(int *array, int size); the above declaration are equivalent (remember arrays are pointers).
If we call
1 2
int a[10]; // declaration sum(a); // function call in function sum, array[1] will access directly a[1]. Example: arrfun2.cpp [Prata]
For multidimensional arrays, you have to specify all sizes but the rst in the type:
1 2 3
int data[5][5][5]; // 5x5x5 array // ... int sum(int a[][5][5], int xSize); // prototype of the function
2008 J n Ma uch a n
Last modied: Wednesday 6th February, 2008, 00:21
SFU CMPT-212 2008-1
9
Topic: Functions
const
Question: How to protect elements of an array passed to a function which is not supposed to modify the array? Answer: Use const. Example:
1 2 3 4
int sum(const int array[], int size) { array[1]=10; // compiler error ... }
array is an array to const int, each element of the array has a const value (within function sum) which cannot be modied
Last modied: Wednesday 6th February, 2008, 00:21
2008 J n Ma uch a n
SFU CMPT-212 2008-1
10
Topic: Functions
Note the difference:
1 2 3 4 5 6 7
int a,b; const int *pa=&a; // a pointer to const int int *const pb=&a; // a const pointer to int pa=&b; // VALID pb=&b; // INVALID *pa=10; // INVALID *pb=10; // VALID
Last modied: Wednesday 6th February, 2008, 00:21
2008 J n Ma uch a n
SFU CMPT-212 2008-1
11
Topic: Functions
why to use pointer/array to const data?
protects from programming errors (unwanted modication to data) you can use const arguments in a function call Example:
1 2 3 4 5 6 7 8
int sum(int *array, int size); int sum_const(const int *array, int size); int main() { const int a[asize]={1,2,3,4,5}; sum(a,asize); // compiler error sum_const(a,asize); // OK }
Last modied: Wednesday 6th February, 2008, 00:21
2008 J n Ma uch a n
SFU CMPT-212 2008-1
12
Topic: Functions
Passing structures
recall structures can be assigned one to another (memberwise assignment) when passing structures by value, a copy of the original structure is created
Example: travel1.cpp [Prata]
not efcient: values are copied uselessly pass structure addresses instead (or references, as we will see later): travel_time *sum(travel_time *t1, travel_time *t2)
Last modied: Wednesday 6th February, 2008, 00:21
2008 J n Ma uch a n
SFU CMPT-212 2008-1
13
Topic: Functions
Problem:
sum has to allocate memory for new structure travel_time and the user of sum should remember to free the structure after using it! beware: do not return an address of a local variable!
Local variable scope: Variables declared inside a function are no longer available after the completion of the function call.
there is a better solution: instead of returning the structure its better if the user of sum provides the structure where to write the result
Example: travel2.cpp
Last modied: Wednesday 6th February, 2008, 00:21
2008 J n Ma uch a n
SFU CMPT-212 2008-1
14
Topic: Functions
Passing arguments by reference
Function arguments can be passed by reference using the reference operator &. This operator is different from the address operator. Example: swap3.cpp
Reference variables
1 2
int count; int &c=count; // c is an alias for count Example: rstref.cpp [Prata] Note: You cannot assign value to reference in other place then in declaration:
1 2 3 4
int count,count2; int &c; // compiler error; // reference variable has to be initialized c=count2;
2008 J n Ma uch a n
Last modied: Wednesday 6th February, 2008, 00:21
SFU CMPT-212 2008-1
15
Topic: Functions
Reference properties
What happens if call swap from swap3.cpp as follows:
1 2
int x,y; swap(x+2,y); // compiler error
x+2 creates a temporary variable containing the value of x which is passed to swap the value of y would be lost after swapping (the temporary variable exists only temporarily) hence, the call above is forbidden by compiler
When is a temporary variable created?
the argument is not an Lvalue, i.e., it cannot be assigned a value: either expression, or a constant wrong type argument, requiring conversion
Last modied: Wednesday 6th February, 2008, 00:21 2008 J n Ma uch a n
SFU CMPT-212 2008-1
16
Topic: Functions
Note: A temporary variable can be used as a argument to a reference parameter, but it has to be a const reference. Example:
1 2 3 4 5 6 7 8
double cube(const double &side) { // side += 1; // compiler error: side is const return side*side*side; } int main() { double a=cube(1.2); // ok } Question: If we dont want to modify the value, wouldnt it be easier to use passing by value for side instead? Answer: Yes. However, passing by a const reference make sense when passing big structures, which are not going to be modied. (Passing by value would make a copy of each data member of the structure.)
Last modied: Wednesday 6th February, 2008, 00:21
2008 J n Ma uch a n
SFU CMPT-212 2008-1
17
Topic: Functions
When to use reference arguments?
to be able to modify the object, to avoid copying entire object, to return a reference from a function to an existing object and avoid copying the object.
In all cases we could use pointers too, but using references is easier. Example: travel3.cpp
Last modied: Wednesday 6th February, 2008, 00:21
2008 J n Ma uch a n
SFU CMPT-212 2008-1
18
Topic: from Functions
Returning functions
By default, functions return values by value (travel1.cpp). From the point of view of program ow, the effect of return on a function is similar to the effect of break on a loop. Note. Function calls cannot appear on the left sides of assignments unless a pointer is returned and dereferenced: Lside1.cpp; or a reference is returned: Lside2.cpp.
Note: Never return a reference to a local variable! Example:
1 2 3 4 5
travel_time & estimate() { travel_time t = {4, 32}; return t; // dangerous! }
2008 J n Ma uch a n
Last modied: Wednesday 6th February, 2008, 00:21
SFU CMPT-212 2008-1
19
Topic: Functions
Sample questions
What are the possibilities of passing arguments to functions? Show three short examples for each possibility. What is the difference between the following declarations?
1 2 3
int a; const int *p=&a; int *const p=&a;
In which situation its necessary to use a const reference for a parameter to the function instead of a non-const reference? Which of the following lines will generate a compiler error. Explain why!
1 2 3 4
int i,j; int &k=&j; int *p=&i; *p=&j;
2008 J n Ma uch a n
Last modied: Wednesday 6th February, 2008, 00:21
SFU CMPT-212 2008-1
20
Topic: Functions
What is the advantage of passing an argument by constant reference over passing by value? Whats wrong with the following code?
1 2 3 4 5 6 7
void print(double & a) { cout <<"double: "<<a; } // .. double x=3.1; print(x+0.1); How would you x it?
Last modied: Wednesday 6th February, 2008, 00:21
2008 J n Ma uch a n
SFU CMPT-212 2008-1
21
Topic: Functions
Pointers to Functions
Functions are code entry points in memory, with memory addresses. Function addresses can be assigned to pointer variables.
declaration:
1
return_type ( *pointer_name )( arguments ); Example: double (*pf)(int,int); pf is a pointer to function that takes two ints and returns double Note: double *pf(int,int); is a prototype of a function that takes two ints and returns a pointer to double
taking the address of a function: just use the name of the function Example:
1 2
double add(int,int); // a prototype of function pf=add; // pf points to the add() functio
2008 J n Ma uch a n
Last modied: Wednesday 6th February, 2008, 00:21
SFU CMPT-212 2008-1
22
Topic: Functions
using a pointer to call a function:
1 2
(*pointer_name)( parameters ); // C style pointer_name( parameters ); // C++ style Example:
1 2 3
int i,j; double a=(*pf)(1,2); double b=pf(i,j);
Usage:
generic functions; Example: generic.cpp hooks; Example: atexit.cpp
Last modied: Wednesday 6th February, 2008, 00:21
2008 J n Ma uch a n
SFU CMPT-212 2008-1
23
Topic: Functions
Inline functions
the compiler (probably) replaces the function call with the function code as we have seen when calling a function, there is a certain machinery taking place, which takes time if we have a function with a short code which executes fast (compared to the machinery) and is called often, it makes sense to declare the function as an inline function inline functions are declared with the inline keyword: inline double cube(double x); advantage: faster execution of the function disadvantage: the code of the function will appear in the executable le as many times as the number of places calling the function
Last modied: Wednesday 6th February, 2008, 00:21 2008 J n Ma uch a n
SFU CMPT-212 2008-1
24
Topic: Functions
Default arguments
Function parameters, starting with the last, can be assigned default values. Example: int func(int i, int j=3, int k=5) This way, the number of parameters of a function can be variable up to a maximum number of parameters. Example:
1 2 3
func(5); // calls func(5,3,5) func(5,6); // calls func(5,6,5) func(5,6,7);
Default parameters are allowed either in the function prototype (usually) or the function denition, but not both.
Example: default.cpp
Last modied: Wednesday 6th February, 2008, 00:21 2008 J n Ma uch a n
SFU CMPT-212 2008-1
25
Topic: Functions
Function Overloading (Polymorphism)
the same name can be used for multiple functions with different argument lists (also called function signatures) the compiler will automatically recognize which version of the function to call by the number and types of arguments
Example: overloading.cpp
reference to a type and the type have the same signature if the arguments doesnt match any signature, the compiler tries to use automatic conversions to match them; there can be several ways how to do it: if this happens we get a compiler error ambiguous call (exception: const, see overloading2.cpp)
Usage: functions performing the same task on different forms of data
Last modied: Wednesday 6th February, 2008, 00:21 2008 J n Ma uch a n
SFU CMPT-212 2008-1
26
Topic: Functions
Function templates
Function templates are high-level mechanisms designed for dealing with structurally similar processing for different types of data. Function templates are a code abstraction mechanism. Example: swap4.cpp
Function templates are not functions, they are generic function descriptions.
Note (Implicit instantiation). An instance of a function template is created implicitly by matching parameters of a call with the argument templates. Example:
1 2
int i,j; Swap(i,j);
the compiler generates the int version of function Swap and calls it
Last modied: Wednesday 6th February, 2008, 00:21
2008 J n Ma uch a...