by Jim Rogers
This is part four (of five) of this article. Click here to return to part three, or click here to return to the start of the article.
Looping
Ada provides three different looping constructs.
Simple Loop
The simplest loop in Ada is an unconditional loop.
loop
-- Loop body goes here
end loop;
This loop will continue forever, or until you execute an exit command within the loop. In Ada, the exit command terminates a loop. It does not terminate a program.
loop
if condition then
exit;
end if;
end loop;
This construct is so common that a shortened version is available.
loop
exit when condition;
end loop;
The simple loop combined with an exit statement is the most general form of looping in Ada, allowing you to perform your test at the top, bottom, or middle of each iteration.
While loop
The Ada while loop is like the while loop in most languages. It is a conditional loop that performs the condition test at the top of the loop.
while condition loop
-- Loop body goes here
end loop;
For Loop
The Ada for loop iterates through an explicitly stated range of discrete values. As we discussed earlier, the concept of a range is very important in Ada. A range is specified by the notation lowest_value .. highest_value.
for variable in low_value .. high_value loop
-- Loop body goes here
end loop;
The name of a discrete type can be used in place of the value. In that case the loop will iterate over all values in the type, starting at the lowest value. Ranges always must be expressed as low_value..high_value. They can never be expressed in reverse order. You can iterate backwards through a range by adding the reserved word reverse.
for variable in reverse low_value .. high_value loop
-- Loop body goes here
end loop;
The control variable used in a for loop is only visible within the loop body. It is a read-only variable within the loop body, meaning that you cannot explicitly assign a value to the control variable. You do not declare the control variable before you use it. The compiler determines the data type for the range and creates the control variable to be an instance of that type.
Conditional Statements
If Statements
The Ada if statement is fully blocked.
if condition then
-- statement(s)
end if;
if condition then
-- statement(s)
else
-- statement(s)
end if;
The condition must always evaluate to a Boolean value (False or True).
I will compare this with the C if statement.
In C the if statement controls a conditional jump to the statement immediately following the if statement.
if (condition) /* statement */
In C the statement following the if may be a simple statement or a compound statement. The condition must evaluate to an integer. C has no boolean data type. C considers 0 to be false and any non-zero value to be true. The C if statement presents several opportunities for coding traps. The simplest problem occurs when you place a semicolon directly after the condition:
if (condition);
/* statement */
This is always erroneous, but always legal C code. The semicolon acts as a null statement for the if condition. Execution will always flow to the statement following the semicolon because that statement is not controlled by the if statement. This problem never happens in Ada. If you put the extra semicolon in Ada code the compiler will produce an error message indicating incorrect syntax.
Another problem with the C if statement is how it handles nested if statement with else alternatives.
if (condition)
if(condition 2)
/* statement */
else
/*statement */
In this example the else is associated with the nearest if , not with the outer if. This mistake cannot be made with Ada.
Case Statements
The Ada case statement is used to make one of many choices based upon an expression that evaluates to a discrete type. The Ada case statement must either explicitly deal with all possible values of the discrete type or it must contain an Others clause.
case expression is
when choice list =>
sequence-of-statements
when choice list =>
sequence-of-statements
when others =>
sequence-of-statements
end case;
The Others clause corresponds to the default option in a C switch statement. The Ada case statement does not suffer from fall through like the C switch statement. There is no need to explicitly break at the end of each case as must be done in C to prevent fall through.
type Directions is (North, South, East, West);
Heading : Directions;
case Heading is
when North =>
Y := Y + 1;
when South =>
Y := Y - 1;
when East =>
X := X + 1;
when West =>
X := X - 1;
end case;
In this example the Others clause is not used because all possible values of the Directions type are explicitly handled.
Subprograms
Ada provides two kinds of subprograms, and makes a strong distinction between the two.
Procedures never return a value through a return statement, but may pass parameters out through their parameter list. Procedure parameters must have a passing mode. There are three passing modes: IN, OUT, and IN OUT. IN parameters are treated as constants within a subprogram. They may be read from but not written to. OUT parameters have no reliable initial value upon entering the procedure, but are expected to be written to. IN OUT parameters have an initial value and may be written to. If no mode is specified, the default mode is IN.
procedure Swap(Left, Right : IN OUT Integer) is
Temp : Integer := Left;
begin
Left := Right;
Right := Temp;
end Swap;
Functions always return a value (except when the function raises an exception). Function parameters can only have the IN mode.
function Count_Letters(Item : String) return Natural is
Count : Natural := 0;
begin
for I in Item'Range loop
if Is_Letter(Item(I)) then
Count := Count + 1;
end if;
end loop;
return Count;
end Count_Letters;
This function will count all the letters in any size string passed to it. The for loop determines the range to iterate through by inspecting the Range attribute of the string. Remember that a string is merely an array of characters.
Procedure parameter modes tell the compiler what you want to do with the parameters. They also document for the programmer what your intent is. Any parameter passed with an IN mode can cause no side effects in the calling code block. Any parameter passed with an OUT or IN OUT mode can be expected to change.
Actual parameters to a subprogram may be passed by position, as in C, or using named notation. It is even possible to mix the notations, with some restrictions. In general, most Ada programmers prefer to use named notation when there are multiple parameters. The Put procedure that writes an unsigned integer type to standard output is defined as:
procedure Put(Item : in Num;
Width : in Field := Default_Width;
Base : in Number_Base := Default_Base);
This procedure declares three formal parameters. The last two have default values. This means that you do not need to provide values for those parameters if you are happy with the defaults. When calling this procedure using all defaults you would use one of the following formats:
Put(Count); Put(Item => Count);
Both procedure calls above accomplish the same thing. The first one uses positional notation. The actual parameter Count is passed into the formal parameter Item. This is made explicit with the second call. Clearly, there is no great advantage to using named notation in this instance. If, however, you want to output your integer value in base 2 you must pass the value 2 to the Base formal parameter. In this case named notation is very useful.
Put(Item => Count, Base => 2); Put(Base => 2, Item => Count); Put(Count, Base => 2);
All three forms are allowed. The first form is generally preferred. Note that the use of named notation allows you to specify parameters in any order you choose. The last example shows a mixture of named and positional notation. This form has an important rule. All the positional parameters must be passed before any named parameter. Named notation is useful for code maintenance. It documents exactly what the original programmer meant to do without requiring the maintenance programmer to look up the subprogram definition to understand which parameters were receiving which value.
Packages are all around us
The primary structure used for encapsulation in Ada is called a package . Packages are used to group data and subprograms. Packages can be hierarchical, allowing a structured and extensible relationship for data and code. All the standard Ada libraries are defined within packages.
Package definitions usually consist of two parts, a package specification and a package body. The package specification declares all the public and private components in a package including data types, constants, functions, and procedures. Ada’s notion of private is actually closer to the C++ or Java notion of protected. Most package specifications require a corresponding package body. The exception is a package defining only constants. Package bodies contain the implementation of all the procedures, functions, protected types, and task types defined in a package specification. Package bodies can also declare and define data types, variables, constants, functions, and procedures not declared in the package specification. Anything declared withing a package body is visible only to functions, procedures, protected types, and task types defined in the same package body. Variables and constants declared in a package body correspond to private members of C++ or Java classes.
I will repeat the code shown earlier about operators. This code clearly demonstrates the use of a user defined package.
The first part is the package specification for a package named Operator_Example . This package defines two data types and the procedures and functions associated with those data types. No private data is defined in this package.
---------------------------------------------------------------
-- Ada operator examples
---------------------------------------------------------------
package Operator_Examples is
type Days is (Monday, Tuesday, Wednesday, Thursday, Friday,
Saturday, Sunday);
procedure Print_Message(For_Day : in Days);
type Daily_Sales is array(Days) of Float;
function Total(Sales : in Daily_Sales) return Float;
function Geometric_Mean(Sales : in Daily_Sales)
return Float;
end Operator_Examples;
The second part is the package body for Operator_Example. The functions and procedures defined within this package need to call functions and procedures from other packages. The with clause is used to identify which packages are needed. The use clause is used to simplify the naming of those functions and procedures from other packages. For instance, without the clause
use Ada.Text_Io;
The Print_Message procedure below would need to be written as follows:
procedure Print_Message(For_Day : in Days) is
begin
if For_Day in Saturday..Sunday then
Ada.Text_Io.Put_Line("Go Fishing!");
else
Ada.Text_Io.Put_Line("Go To Work!");
end if;
end Print_Message;
With clauses must be placed before the beginning of the package body or specification. They cannot be scattered throughout the code. A use clause may be placed in the same area as the with clause, or it may be placed in the declarative region of a code block. If it is placed in the declarative region of a code block its influence is restricted to that code block.
with Ada.Text_Io; use Ada.Text_Io;
with Ada.Numerics.Elementary_Functions;
use Ada.Numerics.Elementary_Functions;
package body Operator_Examples is
procedure Print_Message(For_Day : in Days) is
begin
if For_Day in Saturday..Sunday then
Put_Line("Go Fishing!");
else
Put_Line("Go To Work!");
end if;
end Print_Message;
function Total(Sales : in Daily_Sales) return Float is
Sum : Float := 0.0;
begin
for I in Sales'range loop
Sum := Sum + Sales(I);
end loop;
return Sum;
end Total;
function Geometric_Mean(Sales : in Daily_Sales)
return Float is
Product : Float := 1.0;
begin
for I in Sales'range loop
Product := Product * Sales(I);
end loop;
return Product**(1.0 / Float(Sales'Length));
end Geometric_Mean;
end Operator_Examples;
The last part is not a package at all, but a stand-alone procedure with no parameters. Ada requires you to create a stand-alone procedure with no parameters as the starting point of your program. This procedure needs to use types and subprograms from several packages. The appropriate with clauses are placed before the beginning of the procedure. Note that the with clause does not work like the preprocessor for C or C++. The contents of a package specification are not copied into the code at the point of a with clause. The C and C++ preprocessor will generate duplicate symbol names if a file is included into the same source file multiple times. Ada avoids that problem altogether.
---------------------------------------------------------------
-- The driver procedure to exercise the
-- Operator_Examples package.
---------------------------------------------------------------
with Ada.Text_Io; use Ada.Text_Io;
with Ada.Float_Text_Io; use Ada.Float_Text_Io;
with Operator_Examples; use Operator_Examples;
procedure Operator_Exerciser is
My_Sales : Daily_Sales;
begin
My_Sales(Monday) := 1234.56;
My_Sales(Tuesday) := 1342.65;
My_Sales(Wednesday) := 1432.55;
My_Sales(Thursday) := 1332.44;
My_Sales(Friday) := 2345.67;
My_Sales(Saturday) := 2222.00;
My_Sales(Sunday) := 1232.33;
for Day in Days loop
Put(Days'Image(Day) & ": ");
Print_Message(Day);
end loop;
Put("Total sales: ");
Put(Item => Total(My_Sales), Aft => 2, Exp => 0);
New_Line;
Put("Mean Sales: ");
Put(Item => Geometric_Mean(My_Sales), Aft => 3, Exp => 0);
New_Line;
end Operator_Exerciser;
Record Definitions
You can create a composite type containing multiple fields, each with possibly a different type, using a record. A record is very much like a struct in C.
type Address is record
Street : Unbounded_String;
City : Unbounded_String;
Postal_Code : String(1..10);
end record;
My_Address : Address;
The Address type shown above has three fields. The variable My_Address is an instance of the Address type. Record fields are accessed using a simple dot (.) notation.
A.Street := To_Unbounded_String("1700 Pennsylvania Avenue");
A.City := To_Unbounded_String("Washington, D.C.");
A.Postal_Code := "00000-0000";
An access type corresponds to a Java reference.
type Address_Ref is access Address;
A_Ref := new Address;
A_Ref.Street := To_Unbounded_String("17 Raven Road");
A_Ref.City := To_Unbounded_String("San Anselmo");
A_Ref.Postal_Code := "94960-1234";
Unlike C, there is no notational difference for accessing a record field directly or through an access value. To refer to the entire record accessed by an access value use the following notation:
Print(A_Ref.all);
What? Ada Has No Class?
Ada provides tools and constructs for extending types through inheritence. The most unusual feature about Ada’s approach to constructing classes and objects is that Ada has no class reserved word. In many object oriented languages the concept of a class is overloaded. It is both the unit of encapsulation and a type definition. Ada separates these two concepts. Packages are used for encapsulation. Tagged types are used to define extensible types. This allows some interesting flexibilities. It is entirely legal to define more than one tagged type in a package. This ability is most useful when you need to define mutually referencing (or circular referencing) types.
Defining a Tagged Type
A tagged type definition is syntactically simply an extension of record type definition.
type Person is tagged record
Name : String(1..20);
Age : Natural;
end record;
Such a type definition is performed in a package. Immediately following the type definition must be the procedures and functions comprising the primitive operations defined for this type. Primitive operations must have one of its parameters be of the tagged type, or for functions the return value can be an instance of the tagged type, allowing you to overload functions based upon their return type. This is a stark contrast to C++ and Java which do not allow you to overload based upon the return type of a function. The tagged type is extended by making a new tagged record based upon the original type.
type Employee is new Person with record
Employee_Id : Positive;
Salary : Float;
end record;
Type Employee inherits all the fields and primitive operations of type Person.
This ends part four of this article. Click here to continue with part five, Concurrent Programming.
