CSC103 Programming Fundamentals

Lec 07: Functions

 Introduction

➢ Real world problems are larger, more complex

➢ Top down approach
➢ Modularize – divide and conquer
➢ Easier to take smaller problems/module
➢ Repeated set of instructions

2
 Divide and Conquer Approach

➢ Construct a program from smaller pieces or components

o Place smaller pieces into functions
➢ Pieces are more manageable than one big program
o Makes other functions smaller
o Pieces can be independently implemented and tested

3
 Functions

➢ A function is a self-contained block of statements that

performs a coherent task of some kind.
➢ Functions allow us to
o Modularize a program
o Reuse the code
➢ Two types
o Programmer/user written, called programmer-defined
functions
o Prepackaged functions available in the standard C library

4
Example: Function

5
 Modularizing a Program

➢ Analogy : Hierarchical management

➢ A boss (the calling function or caller) asks a worker (the
called function) to perform a task and report back when
the task is done.

7
 Function

➢ The statements defining the function are written only

once, and the statements are hidden from other
functions.
➢ Functions are invoked by a function call, which specifies
the function name and provides information (as
arguments) that the called function needs to perform its
designated task.

8
 Function

➢ All variables defined in function definitions are local

variables—they can be accessed only in the function in
which they’re defined.
➢ Most functions have a list of parameters that provide the
means for communicating information between
functions.
➢ A function’s parameters are also local variables of that
function.

9
 Components of Function Use

➢ Three steps to implementing a function

1. Function declaration/prototype
▪ If not defined before use
2. Function definition
3. Function call
▪ Either prototype or definition must come first
➢ Prototype and/or definitions can go in either
o Same file as main()
o Separate file so other programs can also use it
• #include
10
 Program Function Definition Structure

➢ main first (preferred)

o Top down design
o Some prototypes required
o Complete prototyping allows
function definition in any order
➢ main is last — lowest level
functions first
o Bottom up design
o Prototypes not required
➢ main in the middle
o Confusing — do not do!

11
 1. Function Declaration/Prototype

➢ An ‘informational’ declaration for compiler

➢ Tells compiler how to interpret calls
➢ Syntax:
<return_type> FnName(<formal-parameter-list>);
➢ Formal parameter syntax:
<data_type> Parameter-Name
➢ Example
char grade(int score);

12
 Function Declaration/Prototype

➢ Placed before any calls

o Generally above all functions in global space
o May be placed in declaration space of calling function
➢ Example

13
 Alternative Function Declaration

➢ Function declaration is 'information' for compiler, so

o Compiler only needs to know
➢ Return type
➢ Function name
➢ Parameter list
➢ Formal parameter names not needed but help readability
➢ Example

14
 2. Function Definition

➢ Actual implementation/code for what function does

o Just like implementing function main()
➢General format –header & basic block:
<return-type> fn-name (parameter-list)
basic block
➢ Example:

15
Example of User-defined Function

16
 Function Definition

➢ Function square is invoked or called in main within the

printf statement
printf("%d ", square(x)); // function call
➢ Function square receives a copy of the value of x in the
parameter y.
➢ Then square calculates y*y.
➢ The result is passed back returned to function printf in
main where square was invoked, and printf displays
the result.
➢ This process is repeated 10 times using the for
statement.
17
 Function Definition

➢ The definition of function square shows that square

expects an integer parameter y.
➢ The keyword int preceding the function name indicates
that square returns an integer result.
➢ The return statement in square passes the value of the
expression y*y (that is, the result of the calculation)
back to the calling function.
➢ int square(int y); // function prototype
▪ The int in parentheses informs the compiler that square
expects to receive an integer value from the caller.
▪ The int to the left of the function name square informs the
compiler that square returns an integer result to the caller.
18
 Function Definition

➢ The compiler refers to the function prototype to check

that any calls to square contain
▪ the correct return type
▪ the correct number of arguments
▪ the correct argument types
▪ the arguments are in the correct order
➢ The function-name is any valid identifier.

▪ The int in parentheses informs the compiler that square

expects to receive an integer value from the caller.
▪ The int to the left of the function name square informs the
compiler that square returns an integer result to the caller.

19
 Function Definition

➢ The return-value-type is the data type of the result returned

to the caller.
➢ The return-value-type void indicates that a function does not
return a value.
➢ Together, the return-value-type, function-name and
parameter-list are sometimes referred to as the function
header.

20
 Function Definition

➢ The parameter-list is a comma-separated list that

specifies the parameters received by the function when
it’s called.
➢ If a function does not receive any values, parameter-
list is void.
➢ A type must be listed explicitly for each parameter.
➢ The definitions and statements within braces form the
function body, which is also referred to as a block.
➢ Variables can be declared in any block, and blocks can be
nested.

21
 Return Type

➢ Returns control to calling function after function

execution
▪ the function does not return a result, control returns
immediately after the execution of function body
▪ returns after executing the statement return;
▪ returns the value of the expression to the caller by the
statement - return expression;

22
 Return Statements

➢ Syntax: return return-value-expression

➢ Two actions
o Sets return value
o Transfers control back to 'calling' function
➢ Good programming & course requirement:
o One return per function
o Return is last statement

23
 3. Function Call

➢ Using function name transfers control to function

1. Values are passed through parameters
2. Statements within function are executed
3. Control continues after the call
➢ For value-returning functions, either

24
Example 1

25
Example 2

26
Example 3

27
Example 3:

28
Example 4: gcd()

29
Example 4: gcd()

30
 Parameters/Arguments

➢ Formal parameters
o In function declaration
o In function definition's header
o 'Placeholders' for data sent in
o 'Variable name' used to refer to
data in definition of function
➢ Actual arguments
o In function call
➢ X is formal parameter
➢ 5 is argument

31
 Passing Arguments

➢ Arguments to a function can be passed by

o value or
o reference/pointer/address
➢ By default all arguments are passed by value in C

32
 Passing Arguments: Passing by Value

➢ When we pass an argument to a function, function

makes a copy and works on that copy.
o The original argument value is unaffected.

33
Passing Arguments: Passing by Value

34
 Passing Arguments: Passing by Value

➢ The function has a parameter x that takes the value of

the argument a.

➢ The function makes a copy of a and does not affect the

original a variable.

➢ The value of a remains the same before and after the

function call.

➢ The function makes temporary copies of a and works on

those copies, not the argument a itself.

35
 Passing Arguments: Passing by
Reference/Pointer/Address

➢ To change the actual values of arguments a using a

function, we use the pointer type parameter in the
function signature.

➢ When we call the function, we supply the address of the

argument using an address-of operator &.

36
Passing Arguments: Passing by
Reference/Pointer/Address

37
Passing Arguments: Passing by Value &
Pointer

38
Passing Arguments: Passing by Value &
Pointer

39
Return Statement

40
Return Statement

41
Return Statement

42
 Functions Calling Functions

➢ We're already doing this!

o main() is a function calling printf!
➢ Only requirement
o Function's declaration or definition must appear first
➢ Common for functions to call many other functions
o Function can call itself → Recursion

43
 Declaring Void Functions

➢ Similar to functions returning a value

o Return type specified as 'void’
➢ Example prototype:
void showResults(double fDegrees, double cDegrees);
➢ Return-type is ‘void’

44
 Declaring Void Functions

➢ Nothing is returned
o Void functions cannot have return statement with an
expression
▪ Will return at end of function
o Non-void functions must have return statement with an
expression
➢ Example definition:

45
 Calling Void Functions

➢ From some other function, like main():

showResults(degreesF, DegreesC);
showResults(32.5,0.4);
➢ Cannot be used where a value is required
o Cannot be assigned to a variable, since no value returned

46
Calling Void Functions

47
 Function Documentation

➢ Used to aid in program maintenance

➢ Comments at non-main definition header
o Purpose of function
o Parameters
o Return

48
 Scope of Identifier Names

➢ Region of a program where identifier is visible

o Begins at definition within block
o Ends at end of block
➢ Local variables
o Name given to variables defined within function block
o Can have different local variables with same name declared
in different functions
o Cannot have duplicate local names within a function

49
 Scope of Identifier Names

➢ Local variables preferred

o Maintain individual control over data
o Functions should declare whatever local data needed to
'do their job'

50
 Global Scope

➢ Names declared 'outside' function bodies

o Global to all functions in that file
➢ Global declarations typical for constants:
o Declare globally so all functions have scope, can use

51
Global Constants and Global Variables

➢ Global variables?
o Possible, but SELDOM-USED
o Better alternative is to use parameters
o Dangerous: no control over usage!

52
 Block Scope

➢ Declare data inside nested blocks

o Has 'block-scope’
o Note: All function definitions are blocks!

53
 Lifetime

➢ How long does it last

o Allocation → Deallocation
o Normally variables are allocated when defined
o Normally variables are deallocated at the end of block

54
 Static & Lifetime

➢ Variable definition modifier keyword: static

➢ Static variables are only allocated once
➢ Static variables are not deallocated until program ends

55
Math Library Functions

56
More Math Library Functions

57