Functions

Tian-Li Yu
[email protected]

Department of Electrical Engineering

National Taiwan University
 Objectives

➢ Understand functions
⚫ create
⚫ invoke
⚫ pass parameters to

➢ Pass-by-value, pass-by-reference
➢ Function overloading
➢ Function prototypes & header files
➢ Scope of local and global variables
➢ Inline functions

2
 Introducing Functions

➢ A function is a collection of statements that are

grouped together to perform an operation

3
 Introducing Functions (contd.)

➢ Function signature is the combination of the

function name and the parameter list.

➢ The variables defined in the function header →

formal parameters.

➢ When a function is invoked, you pass a value to

the parameter → actual parameter (argument).

➢ A Function may return one value or void.

4
 Example: max

#include <iostream>
using namespace std;
/** Return the max between two
numbers */ int main() {
int max(int num1, int num2) { int i = 5;
int result; int j = 2;
if (num1 > num2) int k = max(i, j);
result = num1; cout << "The maximum is " << k;
else return 0;
result = num2; }
return result;
}

5
 Struct

➢ If you need to return more than one variable.

⚫ You may use struct.
⚫ But later we’ll learn class in C++, which is easier to
use.

Complex add(Complex c1, Complex c2) {

struct Complex { Complex result;
double re; result.re = c1.re + c2.re;
double im; result.im = c1.im + c2.im;
}; return result;
}

6
Calling Functions

7
Calling Functions (contd.)

i is now 5

8
Calling Functions (contd.)

j is now 2

9
Calling Functions (contd.)

Invoke max(i, j)

10
Calling Functions (contd.)
invoke max(i, j)
Pass the value of i to num1 (num1=5)
Pass the value of j to num2 (num2=2)

11
Calling Functions (contd.)
return result, which is 5

12
Calling Functions (contd.)
Assign the return value to k
int k = 5;

13
Call Stacks

14
Trace Call Stack

15
Trace Call Stack (contd.)

16
Trace Call Stack (contd.)

17
Trace Call Stack (contd.)

18
Trace Call Stack (contd.)

19
Trace Call Stack (contd.)

20
Trace Call Stack (contd.)

21
Trace Call Stack (contd.)

22
Trace Call Stack (contd.)

23
 Pass By Value

➢ When you invoke a function with a parameter,

the value of the argument is passed to the
parameter. This is referred to as pass-by-value.

➢ The actual parameters are not affected,

regardless of the changes made to the formal
parameter inside the function.

➢ If you don’t need a function to return any value,

declare it as void.

TestPassByValue
24
Pass By Value (contd.)

25
 Reference Variables

➢ C++ provides a special type of variable, called a

reference variable.

➢ A reference variable is an alias for another

variable. Any changes made through the
reference variable are actually performed on the
original variable.

➢ To declare a reference variable, place & in front

of the name.

26
 Pass By Reference

➢ Reference variable example

int count = 1;
int &ref_Count = count;

++ref_Count;
cout << "count is " << count << endl;
cout << "ref_Count is " << ref_Count << endl;

➢ We can use reference to modify the actual

parameters in a function.

TestPassByReference
27
 Note

➢ Reference is like an alias.

➢ Reference exists only when the variable which it

refers to exists.

➢ For example, this is invalid.

int & count ;

28
 Overloading Functions

➢ The max function that was used earlier works

only with the int data type.

➢ What if we need to find which of two floating-

point numbers has the maximum value?

➢ Create another function with the same name but

different parameters.

TestFunctionOverloading
29
 Ambiguous Invocation

➢ Sometimes there may be two or more possible

matches for an invocation of a function, but the
compiler cannot determine the most specific
match.

➢ Ambiguous invocation: a compilation error.

30
 Ambiguous Invocation (contd.)

int maxNumber(int num1, double num2) {

return (num1 > num2)? num1: num2;
}

double maxNumber(double num1, int num2) {

return (num1 > num2)? num1: num2;
}

int main() {
cout << maxNumber(1, 2) << endl;
return 0;
}

31
 Function Prototypes

➢ Like variables, a function int f3(int num) {

needs to be declared if (num == 0) return 0;
return f1(num-1);
before it can be used.
}

➢ One way to ensure it is int f2(int num) {

to place the declaration if (num == 0) return 0;
before all function calls. return f3(num-1);
}

➢ What if… int f1(int num) {

if (num == 0) return 0;
return f2(num-1);
}
32
 Function Prototypes (contd.)

➢ The other way is to declare a function prototype

before the function is called.

➢ A function prototype is a function declaration

without implementation. The implementation can
be given later in the program.

33
Function Prototypes (contd.)
int f3(int num);
int f2(int num);
int f1(int num);

int f3(int num) {

if (num == 0) return 0;
return f1(num-1);
}

int f2(int num) {

if (num == 0) return 0;
return f3(num-1);
}

int f1(int num) {

if (num == 0) return 0;
return f2(num-1);
34
}
 Function Prototypes (contd.)

➢ You don’t even need to name the parameters in

function prototypes.

➢ But naming parameters is recommended for

better readability.

// Return (base^exponent)
double pow(double base, double exponent);

double pow(double, double);

35
 Default Arguments

➢ C++ allows you to declare functions with default

argument values. The default values are passed
to the parameters when a function is invoked
without the arguments.

DefaultArgumentDemo

36
 Example: Root Finding By Bisection

➢ Recall our root finding program.

➢ Now let’s make use of function.
➢ DBL_EPSILON
⚫ #include <cfloat> (for C++) or <float.h>
⚫ It’s the minimal difference from 1 that a double can
represent.

BisectionF

37
 Recursive Call

➢ Golden rule
⚫ Base case first
⚫ Then recursive call

38
 Example: Factorial

int factorial(int num){

int result = 1;
Loop Version for (int i=1; i<=num; i++)
result *= i;
return result;
}

int factorial(int num){

if (num == 0) return 1;
Recursion Version return num * factorial(num-1);
}

39
Tracing Factorial

40
 Do Not Abuse Recursion

➢ Fibonacci
⚫ a0 = 0, a1 = 1.
⚫ an = an-1 + an-2

int fibonacci(int x) {
if (x==0) return 0;
if (x==1) return 1;
return fibonacci(x-2)+ fibonacci(x-1);
}

➢ This is bad. Why?

⚫ How many function calls for fibonacci(30)?
41
Tracing Fibonacci

42
 Do Not Abuse Recursion (contd.)

➢ Fibonacci int fibonacci(int x) {

⚫ a0 = 0, a1 = 1. if (x==0) return 0;
⚫ an = an-1 + an-2 . if (x==1) return 1;
int a = 0, b = 1;
➢ Loop version for (int i = 2; i <= x; i++) {
result = a + b;
a = b;
➢ Only 30 b = result;
iterations for }
fibonacci(30) return result;
}

43
Practices

GCD

Double^Int

44
 Header Files

➢ To make your function reusable, you need to

create a header file (*.h)

➢ A header file define the function prototype.

➢ Other programs use #include to use your

functions.

➢ Function implementations can be in separated

cpp files (recommended) or in the header file.

45
 Header File Examples

➢ MyLib.h bool isEven(int number) {

return (number % 2 == 0);
}

#include <iostream>
➢ UseMyLib.cpp #include "MyLib.h"

using namespace std;

int main() {
Note!
cout << isEven(4) << endl;
cout << isEven(5) << endl;
return 0;
}
46
 Header File Examples 2

➢ MyLib.h bool isEven(int number);

➢ MyLib.cpp #include <iostream>

#include "MyLib.h"
bool isEven(int number) {
return (number % 2 == 0); using namespace std;
} int main() {
cout << isEven(4) << endl;
cout << isEven(5) << endl;
return 0;
➢ UseMyLib.cpp →→ }

➢ MyLib.cpp and
UseMyLib.cpp in one project.
47
 Keyword: #define

➢ Preprocessors: #define, #ifdef, #ifndef, #endif

➢ Note: they are NOT statements.

➢ #define is just a text replacement.

➢ #define N 4
int b = a * N; int b = a * 4;

➢ #define square(x) x*x

int b = square(a); int b = a * a; 48
 Keyword: #define (contd.)

➢ #define max(x,y) (x>y)?x:y

int c = max(a, b); int c = (a>b)?a:b;

➢ Why do we need functions then?

⚫ How about #define square(x) x*x

int c = square(3+4); int c = 3+4*3+4; int c = 19;

⚫ How about #define square(x) (x)*(x)

int c = square(3+4); int c = (3+4)*(3+4); int c = 49;

int c = square(++a); int c = (++a)*(++a); ?

49
 Keyword: #define (contd.)

➢ In general, use #define as functions is bad.

➢ Why do we need it?

➢ Prevent header files from being included twice:

#ifndef _MY_LIB_H_ Unique identifier
#define _MY_LIB_H_
MyLib.h
bool isEven(int number);

#endif

➢ Recommended way to write a header file. 50

 Scope of Local Variables

➢ Local variable: defined inside a function.

➢ Scope: the part of the program where the

variable can be referenced.

➢ The scope of a variable

⚫ Starts from its declaration
⚫ Continues to the end of the block that contains the
variable.

51
 Scope of Local Variables (contd.)

➢ Variable declared in the initial action part of a for

loop header has its scope in the entire loop.

➢ Variable declared inside a for loop body has its

scope limited in the loop body from its
declaration and to the end of the block that
contains the variable.

52
Scope of Local Variables (contd.)

53
Scope of Local Variables (contd.)

54
 Global Variables

➢ Global variables are declared outside all functions

and are accessible to all functions in its scope.

➢ Local variables do not have default values, but

global variables are defaulted to zero.

➢ Notes:
⚫ Do not rely on “defaulted to zero.” (Always initialize)
⚫ Using global variables is usually not recommended.

VariableScopeDemo
55
 Unary Scope Resolution

➢ If a local variable name is the same as a global

variable name, you can access the global variable
using ::globalVariable.
➢ The :: operator is known as the unary scope
resolution.
int v1 = 10;
int main() {
int v1 = 5;
cout << "local variable v1 is " << v1 << endl;
cout << "global variable v1 is " << ::v1 << endl;
return 0;
}
56
 Static Local Variables

➢ After a function completes its execution, all its

local variables are destroyed.
➢ Sometimes, it is desirable to retain the value
stored in local variables so that they can be used
in the next call.
➢ C++ allows you to declare static local variables.
➢ Static local variables are permanently allocated in
the memory for the lifetime of the program. To
declare a static variable, use the keyword static.

StaticVariableDemo
57
 Function Abstraction

➢ You can think of the Function body as a black box

that contains the detailed implementation for the
Function.

58
 Benefits of Functions

• Write a Function once and reuse it anywhere.

• Information hiding. Hide the implementation
from the user.
• Reduce complexity.

59
Math Functions

60
 Divide and Conquer

➢ Also known as stepwise refinement.

➢ Problem decomposition.

➢ Big, difficult problem → small, easy subproblems.

PrintCalendar

61
 Design Diagram

printMonthName

62
 Implementation: Top-Down

➢ Stubs can be used for the Functions waiting to be

implemented.
➢ A stub is a simple but incomplete version of a
Function.
➢ The use of stubs enables you to test invoking the
Function from a caller.

void printMonth(int year, int month) {

cout << month << " " << year << endl;
}

63
 Implementation: Bottom-Up

➢ Implement one function in the structure chart at

a time from the bottom to the top.

➢ For each function implemented, write a test

program to test it.

➢ Both top-down and bottom-up functions are fine.

➢ Both approaches implement the functions

incrementally and help to isolate programming
errors and makes debugging easy.

➢ Sometimes, they can be used together.

64
 Inline Functions

➢ Implementing a program using functions makes

the program easy to read and easy to maintain,
but function calls involve runtime overhead.

➢ C++ provides inline functions to avoid function

calls.

➢ Inline functions are not called; rather, the

compiler copies the function code in line at the
point of each invocation.

65
Inline Function Example

#include <iostream>
using namespace std;
inline void f(int month, int year) {
cout << "month is " << month << endl;
cout << "year is " << year << endl;
}

int main() {
int month = 10, year = 2008;
f(month, year);
return 0;
}

66
 Final Notes About Inline

➢ Inline functions are desirable for short functions,

but not suitable for long functions.

➢ long inline functions will dramatically increase the

executable code size when it is copied in multiple
places.

➢ C/C++ allows the compilers to ignore the inline

keyword if the function is too long.

67
 Summary

➢ Functions, prototypes, header files.

➢ Pass-by-value, pass-by-reference.

➢ Scope of local, global, and static local variables.

➢ Inline functions.

➢ Divide-and-conquer methodology.

68