TOPIC 5: FUNCTION - … · A larger / complex problem is broken up into smaller problems ... If the function definition is defined before the ... assignment statement,

FUNCTIONCSC128

Introduction

What is function?

Module/mini program/sub-program

Each function/module/sub-program performs specific task

May contains its own variables/statements

Can be compiled/tested independently

An approach to handle complexity in solving problems where:-

A larger / complex problem is broken up into smaller problems (less complex)

The solution to the problem (a module), consists of – a combination of solutions

for the smaller problems (sub modules)

Multiple functions form a larger program

Modular programming

Break 1 large program or 1 module into sub-modules

Introduction

Example

WITHOUT functions

int main()

{

float num1, num2, sum;

cin >> num1 >> num2;

sum = num1 + num2;

cout << "Total Sum: " << sum;

return 0;

}

4

Example

WITH functions 1/2 float num1, num2, sum;

void getInputs();

void calculateSum();

void displaySum();

int main()

{

getInputs();

calculateSum();

displaySum();

return 0;

}5

Variables

declaration

Modules/functions

declaration

Calling

modules/functions

Main function

Example

WITH functions 2/2void getInputs()

{


}

void calculateSum()

{

sum = num1 + num2;

}

void displaySum()

{

cout << "Total Sum: " << sum;

}

6

Function Definitions or

the actual modules are here, right after void

main().

Each module perform

specific task

Example

WITHOUT and WITH functions

Benefits of functions Divide and conquer

Manageable program development

Software reusability

Use existing functions as building blocks for new programs

Abstaction-hide internal details (library functions)

Avoid repetition

Simplify main() function/program

Planning, coding, testing, debugging, understanding, maintaining a

computer program will be easier

Same function can be reused in another program

Prevent function duplication

Reduce time of writing a program

Introduction

TWO (2) types of functions :-

[1] Pre-defined/built-in/library

Required special pre-processor (*.h files – older version)

iostream: cin, cout

cstring: strcpy, strcmp

cmath: sqrt(), pow(), abs()

[2] Programmer-defined/independent

Depends on programmer what kind of task will be performed by the function

Contents

Predefined Function

User – defined Function

Family of function

Predefined

function

Predefined Function

Functions that have been defined by the producer of a compiler.

Declaration of the functions are stored in header file. (.h extension – older version)

Also known as built in functions

Used by the programmers to speed up program writing.

Predefined Function

Programmers may use the existing code to perform

common tasks without having to rewrite any code.

These functions are predefined by the producer of

a compiler, (C++) and are stored in the header files

(.h files) called libraries

To use a pre‐defined function, appropriate library

file must be included in the program using the

#include directive.

Those without the .h is C++ header files while those

with .h are C header files.

This only applies to the standard header files in C++.

The old standard used the #include <filename.h>

syntax. When namespaces and templates were added to

the language, the standard was changed to #include

<filename>

The #include <filename.h> was common in C++ code

prior to the C++ standard. The standard changed it to

#include <filename> with everything from the header

placed in the std namespace.

Predefined FunctionHeader files Functions Descriptions

cmath pow(x, y) Raise to power.

sqrt(x) Compute square root.

floor(x) Round down value.

ceil(x) Round up value.

abs(x) Absolute value

cstring strcpy(x,y) Copy sequence of character

strcmp(x,y) To compare two sequence of character

strcat(x,y) To concatenate sequence of character

Predefined Function iomanip: header file to manipulate

input/output data.

Built-in functions:

17

Function Description

setw(x) Set field width to x

setfill(x) Set the fill character with x

setprecision(x) Set the floating point precision to x

Predefined Function

cstring: header file contains string

manipulation functions.

Built-in functions:

18


strcmp(s1, s2) Compares one string to another

strcpy(s1, s2) Copies one string to another

strlen(s) Calculates the length of a string

strcat(s1, s2) Appends one string to another

Predefined Function cctype: header file for character

handling functions.

Built-in functions:

19


toupper(c)Converts character c from lowercase

to uppercase letter

tolower(c)Converts character c from

uppercase to lowercase letter

isupper(c)Return TRUE if c is an uppercase

letter

islower(c) Return TRUE if c is a lowercase

letter

Predefined Function

cctype: header file for character

handling functions.

Built-in functions:

20


isdigit(c) Return TRUE if c is digit

isalpha(c)Return TRUE if c is an alphanumeric

character

isspace(c)Return TRUE if c is a space

character

Predefined Function cmath: header file for mathematical

functions.

Built-in functions:

21

Functions

pow(x, y) sin(x) acos(x) cosh(x)

sqrt(x) cos(x) atan(x) tanh(x)

ceil(x) tan(x) log(x) log10(x)

floor(x) asin(x) sinh(x) exp(x)

fabs(x)

Predefined Function

Function call: is used to call or to invoke a function.

z and y are called parameters or arguments of the

function pow.

# include<iostream>

# include<cmath>

using namespace std;

void main()

{

int x,y,z;

y = 2, z = 4;

x = pow(z,y);

cout<<“x:”<<x;

}

Function call

Predefined Function

#include <iostream>

#include <cmath>


void main()

{

cout << pow(2, 3);

}

23

Pre-processor

files

Power function

retrieved from cmath

cout function

retrieved from iostream

Defining and Calling

Functions

Function call: statement causes a

function to execute

Function definition: statements that make

up a function

Function Definition

Definition includes:

return type: data type of the value that function returns to the part of the program that called it

name: name of the function. Function names follow same rules as variables

parameter list: variables containing values passed to the function

body: statements that perform the function’s task, enclosed in {}

Function Definition

Note: The line that reads int main() is the

function header.

Variables

Variables

Two types of variables:

1) Local variable

2) Global variable

Variables – local variable

Variable that is declared within a body of

a function definition.

Variable that is declared within the

main() function are said to be local to

main function.


Example:

#include <iostream>


void main()

{

int a;

…

}

Local variable


Variables – global variable

Variable that is declared outside and above main function.

Accessible to all function in the program.

Its value can be changed at any point during execution

New value will replace old value assigned to a particular global variable

It is not wise to use global variables any more than you have to.


Example:

#include <iostream>


int a;

void main()

{

…

}

global variable


User – defined

function

User-defined function

Functions that are defined / written by the programmer / user in a program.

Characteristics of user-defined function:

A function name is named with unique name.

Can be called from other function

A function performs a specific task.

Task is a discrete job that the program must perform as part of its overall operation.

A function is independent.

A function may receive values from the calling program (function call).

A function may return value to the calling program (function call).


In general a function has the following syntax:

returnValueType functionName(list of parameters)

{

…

}


void/ value returning function.

With/ without parameters.

returnValueType functionName(list of parameters)

{

…

}


To create a user defined function, you must write

the following:

1) Function prototype (function’s declaration)

2) Function definition

3) Function call

If the function definition is defined before the

main function, you may not need the function

prototype.

User-defined Function

Requirements

40

variable declarations; //global

void functionA();

void main()

{

variable declarations; //local

functionA();

statements; //other statements

}

void functionA()

{

statements;

}

1) Function

prototype

declarations

2) Function call

3) Function

definitions


Requirements

41

int calculateSum(int, int);

void main()

{

int num1, num2;


cout << calculateSum(num1, num2);

}

void calculateSum (int x, int y)

{

int total = x + y;

return total;

}

1) Function

prototype

declarations

2) Function

call

3) Function

definitions


Requirements

42

int calculateSum(int, int);

void calculateSum (int x, int y)

{

int total = x + y;

return total;

}

void main()

{

int num1, num2;


calculateSum(num1, num2);

}

1) Function

prototype

declarations

2) Function call

3) Function

definitions

1) Function prototype

Is used to declare a function.

Problem statement: to create a function to

calculate total of 2 numbers.

Steps:

1) Identify function name.

2) void/ value returning function?

3) With/ without parameter?

1) Function prototype..cont.

void function without parameter

void function with parameter

Value returning function, without parameter. (return integer value)

Value returning function, with parameter. . (return integer value)

void calculateSum();

void calculateSum (int x, int y);

int calculateSum();

int calculateSum (int x, int y);

Can you see the differences ?

?

1) Function prototype..cont.

Is placed in between preprocessor directives and main

function.

#include <iostream>


void calculateSum ();

void main()

{

…

}

2) Function definition

Is a block of code (statements) that perform specific

task.

Statements are usually declaration and/or executable

statements.

Must be declared 1st before it can be used

Place it BEFORE or AFTER main()

2) Function definition..cont.

47

Syntax:

returnType functionName (type parameter_list)

{

declaration(s);

statement(s);

return expression;

}

Function

body

Function

header


48

Example using void return type:

void sumNumbers(int, int, int)

{

int total = a + b + c;

cout << total;

}If you use void in

function header, you must NOT have return

statement inside

function body


49

Example using int return type:

int sumNumbers(int, int, int)

{

int total = a + b + c;

return total;

} If you use int/float/double/long/char

in function header, you MUST HAVE return statement inside

function body

3) Function call

When a function is called, the program control is passed

to the called function and the statements inside the

function will be executed until control is passed back

the calling function

To call a function, specify the function name and the

values of the parameters [if any]

3) Function call..cont.

51

[3a]Function call that returns no value

Contains void return type on function

header

Once complete execute last statement

in function definition, the control is

passed back to the statement that calls

the function in the calling function

Then, next statement will be executed

3) Function call..cont.

52

[3b]Function call that returns a value

Contains other than void on function header

When execute of function definition is complete, control is passed back to the calling function with a value

That returned value can be used:

In an arithmetic expression, logical expression, assignment statement, output statement

Recap…

53

No return value Return value

Without parameters void calculateSum () int calculateSum ()

With parameters void calculateSum (int a, int b) int calculateSum (int a, int b)

void function without

parameter

General syntax:


parameter

Example:

void calTotal()

{

int a, b, result;

a = 1, b = 2;

result = a + b;

cout<<result;

}

return_type

function_name parameter_list

function_body

Function header


parameter

Function call: is used to invoke/ to call a function to

execute task.

Is placed inside main function.

Example:

int main()

{

calTotal();

return 0;

}


parameter

Full code:

#include<iostream>


void calTotal();

int main()

{

calTotal();

return 0;

}

void calTotal()

{

int a, b, result;

a = 1, b = 2;

result = a + b;

cout<<result;

}

Function call

Function prototype

Function definition

Function header


parameter

Exercise 1: using void function,

write a program to calculate an

average of 3 numbers.


Parameter:

Parameter is ways how calling function and

called function are communicated.

Through parameter, data can pass from calling

function to called function and from called

function to calling function.

Formal parameters are optional

Two types of parameter:

Value parameter

Reference parameter


Value parameter

A formal parameter that receives a copy of the

content of the corresponding actual parameter.

Reference parameter*

A formal parameter that receives the location of

the corresponding parameter.

void function with parameter (value)

void calTotal(int x, int y)

{

int result;

result = x + y;

cout<<result;

}

Formal parameter


#include<iostream>


void calTotal(int, int);

void main()

{

int a; int b;

a = 2, b = 3;

calTotal(a, b);

}

void calTotal(int x, int y)

{

int result;

result = x + y;

cout<<result;

}

Actual parameter


Example:void findStatus(int);

void main()

{

int mark;

cout<<“enter mark:”;

cin>>mark;

findStatus(mark);

}

void findStatus(int value)

{

if (value>=80)

cout<<“excellent”;

else if(value>=60)

cout<<“good”;

else if(value>=50)

cout<<“pass”;

else

cout<<“fail”;

}


Exercise 2: using void function with parameter, write a

program that require a user to input 2 numbers and

determine the maximum number.

Value returning function

Is a function that after completing its assigned task,

return precisely one value to the calling function

(function call).

Why we return a value?

To use it for further calculation or process.

Is used in an assignment statement or in an output

statement.


Function definition:

int calTotal(int x, int y)

{

int result;

result = x + y;

return result;

}

Return type or data type

Value returning function#include<iostream.h>

int calTotal(int, int);

void main()

{

int a,b,z;

a = 2, b = 3

z = calTotal(a, b);

cout<<“total :”<<z;

}


{

int result;

result = x + y;

return result;

}

Function call: Assignment

statement

Function prototype

Value returning function#include<iostream.h>

int calTotal(int, int);

void main()

{

int a,b;

a = 2, b = 3

cout<<“total :”<< calTotal(a, b);

}


{

int result;

result = x + y;

return result;

}

Function call: Output

statement

Passing Value Between

Functions

69

int calcSum(int, int);

void main()

{

int a, b;

cin >> a >> b;

cout << calcSum(a, b);

}

int calcSum(int x, int y)

{

return (x + y);

}

a = x = 1

b = y = 1

return 2

cout 2

Example using return

statement


Exercise 3: using value returning function, write a

program to determine maximum value of two numbers.


Exercise 4: using value returning function write a

program to calculate an average of three numbers.

Function

(reference

parameter)

Function – reference

parameter

If a formal parameter is a reference parameter It receives the address (memory location) of the

corresponding actual parameter

During program execution to manipulate the data The address stored in the reference parameter directs it to the

memory space of the corresponding actual parameter

Can pass one or more values from a function

Can change the value of the actual parameter


parameter

A reference parameter receives and stores the address

of the corresponding actual parameter

Reference parameters are useful in three situations:

Returning more than one value

Changing the actual parameter

When passing the address would save memory space and

time.


parameter

Function – value parameter#include <iostream>


void addFour(int a, int b);

void main()

{

int num1,num2;

num1 = 3;

num2 = 1;

cout<< num1<<num2<<endl;

addFour(num1,num2);

cout<<num1<<num2<endl;

}

void addFour(int a, int b)

{

a = a + 4;

b++;

cout<<a<<b<<endl;

}

Value parameter

In main BEFORE calling

addFour function

3num1

In addFour function

7a

In main AFTER calling

addFour function

1num2 2b

3num1

1num2


parameter

Reference parameter

When the value of a

changes, value num1

changes as well

#include <iostream>


void addFour(int& a, int b);

void main()

{

int num1,num2;

num1 = 3;

num2 = 1;

cout<< num1<<num2<<endl;

addFour(num1,num2);

cout<<num1<<num2<endl;

}

void addFour(int &a, int b)

{

a = a + 4; //line 1

b++; //line 2

cout<<a<<b<<endl;

}


addFour function

3num1

In addFour function

7a

In main AFTER calling

addFour function

1num2 2b

7num1

1num2

Reference parameter


parameter

How it works?


addFour functionIn addFour function

3num1 a

1num2 1b

Before statement in line 1 execute!!

In main BEFORE

calling addFour function

In addFour function

7num1 a

1num2 2b

In function addFour, after statement in line 1 and line 2 execute!!

Scope of a local and global

variable#include <iostream>

void calTotal();


void main()

{

int a;

…

}

void calTotal()

{

int a;

}

Variable a in function main() is different from variable a in

Function calTotal()

Global variable

#include <iostream>


void calTotal();

int num1;

void main()

{ int num2;

total = num1 + num2

…

}

void calTotal()

{

int num2;

total = num1 – num2;

}

Variable num1 is a global variable that are accessible to all function

definitions in the file.

Summary

void function: a function that does not have a data type

A return statement without any value can be used in a void function to exit function early

The heading of a void function starts with the word void

To call a void function, you use the function name together with the actual parameters in a stand-alone statement

Summary (continued)

Two types of formal parameters: value parameters and

reference parameters

A value parameter receives a copy of its corresponding

actual parameter

A reference parameter receives the address (memory

location) of its corresponding actual parameter

Summary (continued)

If a formal parameter needs to change the value of an

actual parameter, in the function heading you must

declare this formal parameter as a reference parameter

Variables declared within a function (or block) are

called local variables

Variables declared outside of every function definition

(and block) are called global variables

Summary (continued)

If a formal parameter needs to change the value of an

actual parameter, in the function heading you must

declare this formal parameter as a reference parameter

Variables declared within a function (or block) are

called local variables

Variables declared outside of every function definition

(and block) are called global variables

Documents

TOPIC 5: FUNCTION - … · A larger / complex problem is broken up into smaller problems ... If the function definition is defined before the ... assignment statement,