Object-oriented Software in Ada 95

68 Procedures and functions
with Ada.Integer_Text_Io;
use Ada.Integer_Text_Io;
procedure Answer_Is( N:in Integer;
Message:in Boolean := True) is
begin
if Message then Put("The answer = "); end if;
Put( N, Width=>1 );
if Message then New_Line; end if;
end Answer_Is;
with Ada.Text_Io, Ada.Integer_Text_Io;
use Ada.Text_Io, Ada.Integer_Text_Io;
procedure Is_A_Int( An_Int:in Integer ) is
begin
Put("The parameter is an Integer: value = ");
Put( An_Int, Width=>1 ); New_Line;
end Is_A_Int;
with Ada.Text_Io, Ada.Float_Text_Io;
use Ada.Text_Io, Ada.Float_Text_Io;
procedure Is_A_Float( A_Float:in Float ) is
begin
Put("The parameter is a Float: value = ");
Put( A_Float, Aft=>2, Exp=>0 ); New_Line;
end Is_A_Float;
The individual procedures have unique names so that they can be identified and re-used in a program. This is a
consequence of each procedure being a separate compilation unit. However, Ada allows the renaming of a
procedure or function. By choosing the same name a user can overload a particular name with several different
definitions. For example, a program unit can be written which renames the three different procedure names
(Is_A_Int, Is_A_Float, Is_A_Char) with the same overloaded name Is_A.
with Is_A_Int, Is_A_Float, Is_A_Char;
procedure Main is
procedure Is_A( The:in Integer ) renames Is_A_Int;
procedure Is_A( The:in Float ) renames Is_A_Float;
procedure Is_A( The:in Character ) renames Is_A_Char;
begin
Is_A( 'A' );
Is_A( 123 );
Is_A( 123.45 );
end Main;
Note: It is possible to write several functions or procedures with the same name directly by using the package
construct.
When run this program would print the type and value of the argument passed to Is_A.
The parameter is a Character: value = A
The parameter is an Integer: value = 123
The parameter is a Float: value = 123.450
Of course, for this to happen, the actual function called must be different in each case. The name Is_A is
overloaded by three different functions. The binding between the called function and its body is worked out by the
compiler at compile-time using the signature of the different functions that have been overloaded to resolve any
conflicts.
© M A Smith - May not be reproduced without permission