1 more on modular design: module communications. 2 when a function is invoked, memory is allocated...

1

MORE ON MODULAR

DESIGN: MODULECOMMUNICATIONS

2

WHEN A FUNCTION IS INVOKED, MEMORY IS ALLOCATED LOCALLY FOR THE FORMAL PARAMETERS AND THE VALUE OF EACH ACTUAL PARAMETER IS COPIED INTO THE CORRESPONDING LOCAL MEMORY CELL. THIS IS REFERRED TO AS PASS BY COPY (VALUE).

BECAUSE THE MODULE DOES NOT KNOW THE LOCATION OF THE ACTUAL PARAMETER, IT CAN MANIPULATE THIS LOCAL COPY, BUT IT CAN NOT CHANGE ITS CONTENT.

3

ANOTHER METHOD OF PASSING PARAMETERS IS REFERRING TO MEMORY LOCATIONS BEYOND THE FUNCTION. IN SUCH CASE, THERE IS ONLY ONE MEMORY LOCATION FOR THE DATA, WHICH IS USED BY THE CALLING MODULE AND THE MODULE BEING CALLED. ANY CHANGE THAT A MODULE MAKES TO ITS FORMAL PARAMETERS AFFECTS THE ACTUAL PARAMETERS.

4

RETURN PARAMETERS

THE FUNCTION MAY RETURN A SINGLE VALUE USING A return STATEMENT.

HOWEVER, MORE THAN ONE RESULT MAY BE RETURNED TO THE CALLING MODULE USING PARAMETERS.

5

// FILE: FindAvg2.cpp// Finds the average of three test scores#include <iostream.h>// global data:float test1, test2, test3, average;

void main (){ // functions used: void Get_data (); void Find_average (); void Display_results (); // function calls: Get_data (); Find_average (); Display_results (); return;}

PROGRAM FindAvg (REVISITED)

6

FUNCTION Find_average ..void Find_average(){ // Calculates the average const int NUMBER_OF_TESTS = 3; average = (test1 + test2 + test3) / NUMBER_OF_TESTS; return;} // end Find_average()..

THE VALUE OF average IS RETURNED TO THE CALLING MODULE BY WAY OF GLOBAL VARIABLE.

7

FUNCTION Find_averageRECODED TO RETURNtotal AND average

// FILE: FindTotAvg.cpp// Finds the total and average of three numbers

:void Find_tot_avg (float num1, float num2, float num3, // IN: 3 values float &total, // OUT: total of the values float &average) // OUT: average of the values{ // Calculates total and average const int NUMBER_OF_VALUES = 3; total = num1 + num2 + num3; average = total / NUMBER_OF_VALUES; return;} // end Find_tot_avg()

8

THE FUNCTION CALL

Find_tot_avg (test1, test2, test3, total, average);

9

// Finds the total and average of three test scores

void Find_tot_avg (float, float, float, // IN: values for 3 tests float &, // OUT: total of test scores float &); // OUT: average of test scores

THE FUNCTION PROTOTYPE

10

ACTUAL PARAMETERS FORMAL PARAMETERS

test1 num1 test2 num2 test3 num3 total total average average

PARAMETER CORRESPONDENCE

11

STATE OF MEMORYALLOCATION

(BEFORE EXECUTION OF FUNCTION)

90.0

addressof total

addressof average

85.0

80.0

test1

test2

test3

total

average

num1

num2

num3

total

average

ACTUALPARAMETERS

FORMALPARAMETERS

?

?

85.0

90.0

80.0

12

STATE OF MEMORYALLOCATION

(AFTER EXECUTION OF FUNCTION)

90.0

85.0

80.0

test1

test2

test3

total

average

num1

num2

num3

ACTUALPARAMETERS

FORMALPARAMETERS

255.0

85.0

85.0

90.0

80.0

addressof total

addressof average

total

average

13

PARAMETERS ARE PASSED IN EITHER OF TWO WAYS: 1. BY VALUE 2. BY REFERENCE

PARAMETER CATEGORIES

14

IN CASE OF THE VALUE ITSELF BEING PASSED,

ONLY A COPY OF WHAT IS STORED ON THE

MEMORY, AND NOT THE LOCATION, IS SHARED. A

SEPARATE MEMORY CELL IS ALLOCATED TO

HOLD THE CORRESPONDING FORMAL

PARAMETERS.

15

WITH REFERENCE PARAMETERS (DENOTED WITH THE &

SYMBOL FOLLOWING THE TYPE OF THE FORMAL PARAMETER),

THERE IS ONLY ONE MEMORY LOCATION FOR THE DATA,

WHICH IS USED BY THE CALLING MODULE AND THE

MODULE BEING CALLED. ANY CHANGE THAT A MODULE

MAKES TO ITS FORMAL PARAMETERS AFFECTS THE

ACTUAL PARAMETERS.

16

CAN BE CATEGORIZED INTO THREE TYPES:

1. DATA IMPORT: WHAT THE CALLING MODULE HAS THAT THE CALLED MODULE NEEDS.

2. DATA EXPORT: WHAT THE CALLED MODULE COMPUTES AND RETURNS TO THE CALLING MODULE.

3. DATA IMPORT/ EXPORT: WHAT THE CALLING MODULE HAS THAT THE CALLED MODULE NEEDS, CHANGES, AND RETURNS TO THE CALLING MODULE.

DATA FLOW DESIGNFOR MODULES

17

ANY OBJECT THAT CAN BE CLASSIFIED AS IMPORT

SHOULD BE PASSED BY VALUE.

ITEMS IN THE REMAINING TWO CATEGORIES

(EXPORT AND IMPORT/EXPORT) MUST BE PASSED

BY REFERENCE.

18

SUGGESTED GUIDELINESFOR PARAMETER

PASSING(VALUE)

WHEN DATA IS PASSED TO A FUNCTION AND IS NOT TO BE CHANGED, THEN FORMAL PARAMETER SHOULD BE A VALUE PARAMETER.WHEN DATA IS PASSED TO A FUNCTION AND IS CHANGED, BUT THE CHANGE IS NOT TO AFFECT THE VALUE OUTSIDE THE FUNCTION, THEN THE FORMAL PARAMETER SHOULD BE A VALUE PARAMETER.

19

SUGGESTED GUIDELINESFOR PARAMETER

PASSING(REFERENCE)

WHEN DATA IS PASSED TO A FUNCTION AND IS CHANGED AND IS TO BE RETURNED, THEN FORMAL PARAMETER SHOULD BE A REFERENCE PARAMETER.WHEN INFORMATION IS GENERATED IN A FUNCTION AND IS TO BE RETURNED, THEN THE FORMAL PARAMETER SHOULD BE A REFERENCE PARAMETER.

20

1. TO MAKE THE DATA FLOW DESIGN CLEAR.

2. TO PREVENT UNWANTED SIDE EFFECTS

3. TO HAVE ACTUAL PARAMETERS AS CONSTANTS OR EXPRESSIONS (IF NEEDED).

ADDITIONAL REASONS FOR USING

VALUE PARAMETERS

21

EXPRESSIONS AS ACTUAL

PARAMETERS

Find_tot_avg (test1 + extra_credit_1, test2 + extra_credit_2, test3 + extra_credit_3, total, average);

22

1. MULTIPLE RESULTS RETURNED FROM MODULES CAN ONLY BE PASSED BACK THROUGH REFERENCE PARAMETERS.

2. MORE EFFICIENT MEMORY MANAGEMENT.

ADDITIONAL REASONS FOR USING REFERENCE

PARAMETERS

23

PARAMETER CORRESPONDENCE

THE CORRESPONDENCE BETWEEN ACTUAL AND FORMAL PARAMETERS IS DETERMINED BY THE POSITION. ALSO, THERE SHOULD BE CONSISTENCY WITH RESPECT TO THE PARAMETER TYPE.

24

TYPE CONVERSION

ALTHOUGH IDENTICAL MATCH BETWEEN ACTUAL AND FORMAL PARAMETER TYPE IS DESIRABLE, IN THE CASE OF MISMATCH, THE COMPILER MAY PERFORM A CONVERSION (THE RESULT PRODUCED MAY NOT BE THE DESIRED ONE).

WHEN NECESSARY, EXPLICIT CONVERSION USING CASTING OPERATORS SHOULD BE USED.

25

EXAMPLE:

IF total_grade IS A float VARIABLE, THE EXPRESSION

int (total_grade)

CREATES A COPY OF total_grade OF TYPE int.

float MAY BE USED TO CREATE A FLOATING POINT COPY OF AN int VALUE.

26

A TRANSLATION-TIME CONCERN. DETERMINES WHERE IN A PROGRAM A GIVEN OBJECT MAY BE ACCESSED.

THE FOUR SCOPES FOR AN OBJECT ARE:

1. FILE SCOPE

2. FUNCTION SCOPE

3. BLOCK SCOPE

4. FUNCTION-PROTOTYPE SCOPE

SCOPE OF OBJECTS

27

SCOPE RULES:FILE SCOPE

AN OBJECT DECLARED OUTSIDE ANY FUNCTION IS ACCESSIBLE FROM ALL FUNCTIONS THAT FOLLOW ITS DECLARATION.GLOBAL VARIABLES, CLASSES, FUNCTION DEFINITIONS, AND FUNCTION PROTOTYPES PLACED OUTSIDE A FUNCTION ALL HAVE FILE SCOPE.

28

SCOPE RULES:FUNCTION SCOPE

LABELS (i.e. case LABELS IN switch STATEMENT) ARE THE ONLY OBJECTS WITH FUNCTION SCOPE. LABELS CAN BE REFERENCED ONLY IN THE FUNCTION IN WHICH THEY APPEAR.

29

SCOPE RULES:BLOCK SCOPE

AN OBECT DECLARED INSIDE A BLOCK IS ACCESSIBLE FROM ITS DECLARATION TO THE END OF THE BLOCK (THE RIGHT BRACE “}”).LOCAL VARIABLES AND FUNCTION PARAMETERS HAVE BLOCK SCOPE.

30

SCOPE RULES:FUNCTION-PROTOTYPE

SCOPE

OBJECTS USED IN THE PARAMETER LIST OF A FUNCTION PROTOTYPE (NOT REQUIRED) HAVE FUNCTION-PROTOTYPE SCOPE. THOSE OBJECTS CAN BE REUSED ELSEWHERE IN THE PROGRAM.

31

NAMING CONFLICTS

ANY BLOCK MAY CONTAIN OBJECT DECLARATIONS. WHEN BLOCKS ARE NESTED, AND THE SAME OBJECT NAME IS INCLUDED IN MORE THAN ONE BLOCK, ACCESS IS GIVEN TO THE OBJECT WITHIN THE BLOCK THAT IS CURRENTLY IN EXECUTION.

32

// FILE: SimpleScope.cpp#include <iostream.h>

float a, b, c;int d;

void main (){ void Average (float, float, float, int &);

cin >> a >> b >> c; Average (a, b, c, d); cout << d << endl; return;} // end of main ()

void Average (float x, float y, float z, int &w){ float total;

total = x + y + z; w = total / 3; // result is automatically converted to int return;} // end of Average ()

EXAMPLE:

33

ANOTHER EXAMPLE:// FILE: NestedScope.cpp

float number;

void main (){ :} // end of main ()

void Module_one (){ float total; :} // end of Module_one ()

float Module_two (){ float total;

: { int sum; : sum = sum + total; } :} // end of Module_two ()

34

ANY EFFECT OF ONE MODULE ON ANOTHER MODULE

THAT IS NOT A PART OF THE EXPLICITLY DEFINED

DATA FLOW BETWEEN THEM.

WHEN A MODULE ACCESSES INFORMATION OUTSIDE

OF ITS OWN BLOCK IN A MANNER OTHER THAN

THROUGH ITS PARAMETERS, THE POTENTIAL

EXISTS FOR UNWANTED SIDE EFFECTS.

SIDE EFFECTS

35

IT IS ALSO POSSIBLE FOR UNWANTED SIDE EFFECTS

TO OCCUR IF A FORMAL REFERENCE PARAMETER IS

USED WHERE A VALUE PARAMETER WILL SUFFICE.

36

AVOIDING SIDE EFFECTSMODULES SHOULD ACCESS NONLOCAL VARIABLES

THROUGH THEIR PARAMETER LISTS AND FUNCTION

RESULTS, AND ALL IMPORTS ONLY PARAMETERS

SHOULD BE PASSED AS VALUE PARAMETERS.

37

MAIN PROGRAM (OR OTHER

CALLING MODULE)

CALLEDMODULE

AVOIDING SIDE EFFECTS

VALUE PARAMETERS

REFERENCE PARAMETERS

NON-PARAMETERRELATIONSHIP

FUNCTION RESULT

38

// FILE: SideEffect.cpp#include <iostream.h>

void Char_count (); // counts characters read

int count; // counts input lineschar ch; // input character

EXAMPLE:

39

void main (){ count = 0; ch = ' '; while ( !cin.eof() ) // a class function, // checks for the end // of file { count ++; Char_count (); } cout << count << " lines of input." << endl; return;} // end of main ()

40

void Char_count ()// counts the number of characters read{ count = 0; // side effect ch = ' ’; // intialize ch while ((!cin.eof()) && (ch != '\n')) { cin >> ch; // global variable access count ++; // side effect } // end of while cout << count // global access to count << " characters in this line." << endl; return;} // end of Char_count ()

41

ESCAPE SEQUENCE

\n NEWLINE\t HORIZONTAL TAB\r CARRIAGE RETURN (CURRENT LINE)\a ALERT (SYSTEM BELL)\\ BACKSLASH\” DOUBLE QUOTE

42

IT IS ACCEPTABLE TO REFERENCE NAMED CONSTANTS

GLOBALLY SINCE THE VALUES OF GLOBAL

CONSTANTS CAN NOT BE CHANGED DURING

PROGRAM EXECUTION.

THERE ARE TWO ADVANTAGES TO GLOBALLY

REFERENCING CONSTANTS : EASE OF CHANGE

AND CONSISTENCY.

GLOBAL CONSTANTS AND SIDE EFFECTS

43

IF A CONSTANT IS ONLY NEEDED IN ONE MODULE,

THEN IT SHOULD BE DEFINED LOCALLY WITHIN

THAT MODULE.

LOCAL CONSTANTS

44

AN EXECUTION-TIME CONCERN. REFERS TO LIFE SPAN OF OBJECTS DECLARED WITHIN FUNCTIONS.

COVERS THE PERIOD OF TIME FROM THE CONSTRUCTION TO THE DESTRUCTION OF AN OBJECT.

OBJECT LIFETIME

45

CONSTRUCTION OF DATAOBJECTS

A MEMORY LOCATION IS ASSOCIATED WITH THE DATA OBJECT. THEN, THE DATA OBJECT IS INITIALIZED TO A SPECIFIC VALUE (EVENTUALLY).

46

{ : int counter; : counter = 1;

// the following is a loop while (counter <= 10) { : } :}

EXAMINE THE DATA OBJECT counter IN THEFOLLOWING CODE SEGMENT:

47

THE CONSTRUCTION OF THE DATA OBJECTcounter TOOK PLACE AS FOLLOWS :

1. A MEMORY LOCATION WAS ASSOCIATED WITH counter.2. THAT MEMORY LOCATION WAS INITIALIZED TO 1

48

DESTRUCTION OF DATAOBJECTS

A MEMORY ALLOCATION IS DISASSOCIATED FROM THE DATA OBJECT.

49

WHAT INDICATES THE END OF counter LIFETIME?

THE DESTRUCTION OF THE DATA OBJECT counterTAKES PLACE BY DISASSOCIATING IT FROM THE

MEMORY ALLOCATION.

50

AUTOMATIC OBJECTS(DEFAULT STORAGE CLASS-- ALSO CALLED LOCAL)

CONSTRUCTED WHEN EXECUTION ENTERS THE BLOCK IN WHICH THEY ARE DECLARED AND DESTROYED AT EXIT FROM SAME BLOCK.

STORAGE CLASSES

51

STATIC OBJECTS

CONSTRUCTED WHEN PROGRAM BEGINS EXECUTIONAND DESTROYED WHEN PROGRAM TERMINATES.

52

{ int i = 1; : }

EXAMPLE: AUTOMATIC OBJECTS

53

while (logical_expression){ int i = 1; :}

FOR EACH ITERATION, i IS CONSTRUCTED AT THE BEGINNING OF THE LOOP AND DESTROYED ATTHE END !!!

54

{ static int i = 1; : }

i IS CONSTRUCTED AT THE BEGINNING OF PROGRAMEXECUTION AND DESTROYED AT THE END.

EXAMPLE: STATIC OBJECTS

55

RecursionA recursive function is a function that calls itself, either

directly, or indirectly (through another function).

e.g. Factorial function (Fig 3.14)Fibonacci function (Fig 3.15)

56

Recursion VS Iteration

Recursion is expensive in terms of processor time and memory usage than iteration.

57

• Inline functions• Setting Default argument

58

Function Overloading• You can use same function name as long as it has

different signature than the other function that has same name.

E.g. square functionOr sqrt(int)Sqrt (long)Sqrt (double)