Embed Size (px)
DESCRIPTION
Modules – the Basics. CSCE 110 Influenced by material developed by James Tam & Jennifer Welch. Header. Declarations. const :. Statements. begin end. Where To Define Modules. Module definitions ( procedures & functions ). Procedure definition. Procedures (Basic Case). - PowerPoint PPT Presentation
Citation preview
J. Michael Moore
Modules – the Basics
CSCE 110
Influenced by material developed by James Tam & Jennifer Welch
J. Michael Moore
Where To Define Modules
Header
const
:
Declarations
begin
end.
Statements
Module definitions (procedures & functions)
J. Michael Moore
Procedures (Basic Case)
Procedure call
Procedure definition
No Information Is Passed In/ No Parameters
J. Michael Moore
Defining Procedures (Basic Case – No Parameters)
Format:procedure name;
begin { Statements of the procedure go here } end; { End of procedure name }
Example:
procedure displayInstructions;begin writeln ('The statements in this module will'); writeln (' typically give a high level'); writeln (' overview of what the program as a'); writeln ('whole does');end; (* End of procedure displayInstructions *)
J. Michael Moore
Calling A Procedure (Basic Case – No Parameters)
Format:name;
Example:
displayInstructions;
The name of the procedure is a statement.
J. Michael Moore
Where To Call Modules
It can be done most anywhere in the program – but must be done after its definition.
Header
const
:
Declarations
begin
end.
Main Body
Module definitions
Modules can be called from the main body of the program or from within any module as long as the module is already defined.
J. Michael Moore
Important: A Module Must Be Defined Before It Can Be Called!
program exampleModule (output);
procedure exampleProcedure;
begin
:
end;
begin
exampleProcedure;
end.
First: Defining the module
Second: Calling the module
Correct
J. Michael Moore
Important: A Module Must Be Defined Before It Can Be Called!
program exampleModule (output);
begin
exampleProcedure;
end.
procedure exampleProcedure;
begin
:
end;
Second: Defining the module
First: Calling the module
Code?
Incorrect
J. Michael Moore
Procedures
firstExampleProcedure.pas
program firstExampleProcedure (output);
procedure displayInstructions;begin
writeln ('The statements in this module will typically give a’); writeln (‘high level overview of what the program as a’);
writeln (‘whole does');end; (*Procedure displayInstructions *)
begin displayInstructions; writeln('Thank you, come again!');end. (* Program *)
J. Michael Moore
Procedures
firstExampleProcedure.pas
program firstExampleProcedure (output);
procedure displayInstructions;begin
writeln ('The statements in this module will typically give a’); writeln (‘high level overview of what the program as a’);
writeln (‘whole does');end; (*Procedure displayInstructions *)
begin displayInstructions; writeln('Thank you, come again!');end. (* Program *)
Procedure definition
Procedure call
J. Michael Moore
Declaring Local Variables
Format:procedure name;var
<variable 1 name> : <variable 1 type>; <variable 2 name> : <variable 2 type>; : : begin : end;
Example:procedure proc;var
num1 : integer; num2 : integer;
begin : :
end;
J. Michael Moore
Declaring Local Variables
program secondExampleProcedure (output);procedure proc;var num1 : integer;begin var num2 : integer; num1 := 1; num2 := 2; writeln(num1, ' ', num2);end;begin var num1 : integer; num1 := 10; writeln(num1); proc; writeln(num1);end.
J. Michael Moore
Declaring Local Variables
secondExampleProcedure.pas
program secondExampleProcedure (output);procedure proc;var num1 : integer;begin var num2 : integer; num1 := 1; num2 := 2; writeln(num1, ' ', num2);end;begin var num1 : integer; num1 := 10; writeln(num1); proc; writeln(num1);end.
Local variable: main module
Local variable: procedure ‘proc’
J. Michael Moore
Local Variables Have Limited Scope
procedure getInformation;begin write (‘Enter the principle: ‘); readln (principle);end;
procedure calculateInterest;var amount : integer; principle : integer; interest : integer; time : integer;begin getInformation;end;
These 4 variables are local to procedure ‘calculateInterest’
This variable is unknown here
J. Michael Moore
Passing Information To Modules
• Modules generally aren’t useful unless they can pass information.
computeChange
amount quarters
dimes
pennies
J. Michael Moore
Procedures With Parameters/Information Passed In
Procedure call
P1 P2 …Pn
Procedure definition
J. Michael Moore
Defining Modules (Procedures) With Parameters
Format: procedure name (Name of parameter 1 : type of parameter 1; Name of parameter 2 : type of parameter 2;
: :Name of parameter n : type of parameter n);
begin (* Statements of the procedure go here *) end;
Example: procedure celciusToFahrenheit (celciusValue : real); var fahrenheitValue : real; begin fahrenheitValue := 9 / 5 * celciusValue + 32; writeln(‘temperature in Celsius: ', celciusValue:0:2); writeln(‘temperature in Fahrenheit: ', fahrenheitValue:0:2); end; (* Procedure celciusToFahrenheit *)
FormalParameters
J. Michael Moore
Calling Modules (Procedures) With Parameters
Format: name (Name of parameter 1, Name of parameter 2…Name of
parameter n);
Example: celciusToFahrenheit (celciusValue);
ActualParameters
J. Michael Moore
Formal and Actual Parameters
• Formal parameters: The parameters in the module definition.
• Actual parameters: The parameters in the module call.
• Parameters act like local variables within a module.
J. Michael Moore
Formal and Actual Parameters
• Module call and module definition must have:• same number of parameters
• corresponding parameters must have the same type
• e.g. definition:procedure calc(i: integer, f: real, b:boolean);e.g. call: calc(num, avg, flag)where:—num must be of type integer—avg must be of type real—flag must be of type boolean
J. Michael Moore
Important: The Formal and Actual Parameter Lists Must Match!
• The type and number of parameters must match or there will be a compilation error.
program parameterExample;
procedure proc (num : integer);
begin
num := 10;
end;
begin
var num : integer;
proc (num);
end.
Procedure definition requires an integer parameter
Procedure call passes in an integer parameter
parameters match
J. Michael Moore
Important: The Formal and Actual Parameter Lists Must Match!
• The type and number of parameters must match or there will be a compilation error.
program parameterExample;
procedure proc (num : integer);
begin
num := 10;
end;
begin
proc;
end.
Procedure definition requires one integer parameter
Procedure call passes in zero parameters
Number of parameters
not equal
J. Michael Moore
• The type and number of parameters must match or there will be a compilation error.
program parameterExample;
procedure proc (num : integer);
begin
num := 10;
end;
begin
var ch : char;
proc (ch);
end.
Procedure definition requires an integer parameter
Procedure call passes in a char parameter
Type mismatch
Important: The Formal and Actual Parameter Lists Must Match!
J. Michael Moore
Example Problem
• Write a program that will convert a temperature value from Celsius to Fahrenheit.
• The part of the program that performs that actual conversion should take the form of a separate module.
J. Michael Moore
Procedures: Putting Together The Case Of Procedures With Parameters
temperatureConverter.pas
program temperatureConverter (input, output);
procedure celsiusToFahrenheit (celsiusValue : real);
var
fahrenheitValue : real;
begin
fahrenheitValue := 9 / 5 * celsiusValue + 32;
writeln('Temperature in Celsius: ', celsiusValue:0:2);
writeln('Temperature in Fahrenheit: ', fahrenheitValue:0:2);
end; (* Procedure celsiusToFahrenheit *)
J. Michael Moore
Procedures: Putting Together The Case Of Procedures With Parameters (2)
begin
var celsiusValue : real;
writeln;
writeln('This program will convert a given temperature from a Celsius');
writeln('value to a Fahrenheit value.');
write(‘Enter a temperature in Celsius: ');
readln(celsiusValue);
writeln;
celsiusToFahrenheit(celsiusValue);
writeln('Thank you and come again.');
end. (* Program *)
J. Michael Moore
Pass by Value vs. Pass by Reference
• Each formal parameter is initialized to the value of the corresponding actual parameter.
Called passing parameters.
J. Michael Moore
Pass by Value vs. Pass by Reference
• Let actP be actual and formP be formal• Pass by Value
— actP and formP refer to different memory locations
—contents of actP’s location are copied to formP’s location
—changes to formP are invisible to the caller (i.e. actP)• Pass by Reference
— actP and formP refer to the same memory location
—the address for formP is equated with the address for actP—changes to formP are visible to the caller (i.e. actP)
• By default, Pascal passes variables by value. However, we’ll see how to make it pass by reference.
J. Michael Moore
• procedure larger(i:integer; j:integer; k:integer);begin if (i<j) then i := j; k := i;end;
• Suppose that larger is called with:• a := 3; b := 5; larger(a,b,c);• After calling larger and passing by value, then a = 3, b = 5, c = ?
•
• After calling larger if passing by reference, then a = 5, b = 5, c = 5
Pass by Value vs. Pass by Reference
... ...a,i b,j c,k
... ... ...a b c ji k
J. Michael Moore
Stack Frames
• When a module begins executing, space on the stack, called a stack frame, is allocated for it, to hold• formal parameters
• local variables declared in the method
• return value (for functions)
• When the method finishes executing, the stack frame is de-allocated, and the formal parameters and local variables are no longer accessible.
Module call (local variables get allocated in memory)
The program code in the module executes (the variables are used to store information for the module)
Module ends (local variables get de-allocated in memory)
J. Michael Moore
Stack Frames Example
mainp
main
main calls p
pmain
q
p calls q
pmain
q returns
pmain
r
p calls r
pmain
r
r calls s
s
pmain
r
s returns
pmain
r returns
main
p returns
