Procedures
Solving a complex problem may involve breaking it down into a set of simpler problems.
Example:
Problem: calculate the sum of two whole numbers by hand.
Solution: the algorithm for fixed addition breaks down the operation into a set of simpler operations: process the units column, then the tens column, then the hundreds column, and so on.
The same procedure is used to process each of the columns.
Developing a complex program may involve breaking it down into a set of simpler subprograms.
The program will be made up of modules (subprograms): this is the principle of modular programming.
A procedure is a named subprogram that can be called within the program to trigger the execution of the sequence of instructions that make up the body of the procedure.
Example: calculate the perimeter and the area of a circle.
program example;
const
pi = 3.14;
var
r, p, s : real;
procedure read_radius; { procedure declaration }
begin
writeln('enter radius:');
readln(r);
end;
procedure perimeter; { procedure declaration }
begin
p := 2 * pi * r;
writeln('perimeter : ', p : 8 : 2);
end;
procedure area; { procedure declaration }
begin
s := pi * sqr(r);
writeln('area : ', s : 8 : 2);
end;
begin { main program }
read_radius; { calling the procedure }
perimeter;
area;
end.
Local variable
A variable that is useful only in a given procedure will be defined in the local declarations of that procedure.
Such a variable is said to be local to the procedure.
Example
program example;
var
a, b : integer;
procedure write_description;
begin
writeln('permute values of two integer variables a and b');
end;
procedure read_data;
begin
writeln('enter a :');
readln(a);
writeln('enter b :');
readln(b);
end;
procedure permute;
var
t : integer; { local variable }
begin
t := a;
a := b;
b := t;
end;
procedure write_results;
begin
writeln('permutation of values of variables a and b');
writeln('value of a : ', a);
writeln('value of b : ', b);
end;
begin { main program }
write_description;
read_data;
permute;
write_results;
end.
Scope of a variable
A local variable exists only during the execution of the procedure, and is used only by that procedure.
The main program does not have access to a local variable of a procedure.
A procedure does not have access to a local variable of another procedure.
A variable declared in the declarations part of the main program (the var part) is called a global variable. It exists during the entire execution of the program and is accessible everywhere.
A variable that is local to a procedure and having the same name as a global variable, hides the global variable during the execution of that procedure.
Procedure with parameters
When we write the write(n) statement in a program, we call the standard procedure write and pass it the value of the variable n.
To pass values to a procedure, we declare parameters in the procedure header. The values passed to the procedure will be assigned to these parameters.
Example: the following program successively displays the Fibonacci numbers.
A procedure calculates and displays one Fibonacci number.
program example;
var
n, k : integer;
{ procedure with a parameter }
procedure fibonacci_number(m : integer);
var
{ local variables }
fibo, pred0, pred1, i : integer;
begin
if (m = 0) or (m = 1) then fibo := 1
else
begin
pred0 := 1;
pred1 := 1;
for i := 2 to m do
begin
fibo := pred0 + pred1;
pred0 := pred1;
pred1 := fibo;
end;
end;
write(fibo,' ');
end;
begin
writeln('Fibonacci sequence');
writeln('enter an integer:');
readln(n);
for k := 0 to n do
fibonacci_number(k);
end.
Formal parameter and actual parameter
A formal parameter of a procedure is an identifier whose type is specified in the procedure header.
An actual parameter, or argument, is the value passed to a procedure and assigned to a formal parameter when the procedure is called.
Actual parameters must match the formal parameters in order, number, and type.
Example: in the procedure call statement, the argument is the variable k, and its value is assigned to the parameter m.
{ procedure header }
procedure fibonacci_number(m : integer);
{ ... }
{ procedure call }
fibonacci_number(k);
Parameter passing
Parameter passing (or parameter transmission) refers to the mechanism by which actual parameters are assigned to the formal parameters of a procedure at the time of calling the procedure.
A parameter is passed either by value or by variable (also called by reference).
Passing parameters by value
In the procedure call statement, the actual parameter is a value, variable, or expression that is evaluated at the time the procedure is called.
A parameter passed by value corresponds to a local variable initialized with the value of the actual parameter at the time the procedure is called.
Example: m is the formal parameter and k is the actual parameter.
{ procedure header }
procedure fibonacci_number(m : integer);
{ ... }
{ procedure call }
fibonacci_number(k);
Passing a parameter by value does not allow a result to be passed to another procedure or to the main program via the actual parameter, since the content of the latter is not modified during the execution of the procedure.
Passing parameters by variable
In the procedure call statement, the actual parameter is a variable whose value is likely to be modified by the procedure.
A parameter passed by variable has its name preceded by the keyword var in the procedure header.
Example: the following program finds the largest of three integers.
The parameter m is passed by variable.
program example;
var
a, b, c, max : integer;
procedure maximum(x, y : integer; var m : integer);
begin
if (x > y) then m := x else m := y;
end;
begin
a := 1; b := 2; c := 3;
maximum(a, b, max);
maximum(c, max, max);
writeln('maximum : ', max);
end.