The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Enumerations

Next ►
►

Enumerations in Ada are a way to define a type by listing its possible values. This is particularly useful for representing a set of related constants with meaningful names, improving code readability and maintainability.

Key Concepts

  1. Definition of Enumerations:

    • Enumerations are defined using the type keyword followed by the type name and the list of possible values enclosed in parentheses.

  2. Usage of Enumerations:

    • Enumerations can be used in variables, control structures, and as parameters in subprograms.

  3. Attributes of Enumerations:

    • Ada provides several attributes for enumeration types, such as 'Pos, 'Val, 'Succ, and 'Pred.

Defining Enumerations

To define an enumeration type in Ada, you use the following syntax:

type Day is (Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday);

In this example, Day is an enumeration type with seven possible values.

Using Enumerations

Declaring Variables

You can declare variables of an enumeration type as follows:

declare
   Today : Day;
begin
   Today := Monday;
end;

Control Structures

Enumerations can be used in control structures like case statements:

declare
   Today : Day := Monday;
begin
   case Today is
      when Monday    => Put_Line("Start of the week!");
      when Tuesday   => Put_Line("Second day of the week.");
      when Wednesday => Put_Line("Midweek.");
      when Thursday  => Put_Line("Almost there.");
      when Friday    => Put_Line("End of the work week!");
      when Saturday  => Put_Line("Weekend!");
      when Sunday    => Put_Line("Rest day.");
   end case;
end;

Subprogram Parameters

Enumerations can be used as parameters in procedures and functions:

procedure Print_Day(D : Day) is
begin
   case D is
      when Monday    => Put_Line("Monday");
      when Tuesday   => Put_Line("Tuesday");
      when Wednesday => Put_Line("Wednesday");
      when Thursday  => Put_Line("Thursday");
      when Friday    => Put_Line("Friday");
      when Saturday  => Put_Line("Saturday");
      when Sunday    => Put_Line("Sunday");
   end case;
end;

begin
   Print_Day(Tuesday);
end;

Attributes of Enumerations

Ada provides several useful attributes for enumeration types:

  • 'Pos: Returns the position number of the enumeration value.
  • 'Val: Returns the enumeration value at a given position.
  • 'Succ: Returns the successor of the enumeration value.
  • 'Pred: Returns the predecessor of the enumeration value.

Example

declare
   Today : Day := Monday;
begin
   Put_Line("Position of Monday: " & Integer'Image(Day'Pos(Today))); -- Outputs: Position of Monday:  0
   Put_Line("Value at position 1: " & Day'Image(Day'Val(1))); -- Outputs: Value at position 1:  Tuesday
   Put_Line("Successor of Monday: " & Day'Image(Day'Succ(Today))); -- Outputs: Successor of Monday:  Tuesday
   Put_Line("Predecessor of Tuesday: " & Day'Image(Day'Pred(Tuesday))); -- Outputs: Predecessor of Tuesday:  Monday
end;

Practical Exercises

Exercise 1: Define an Enumeration

Define an enumeration type Traffic_Light with values Red, Yellow, and Green. Write a procedure Print_Light that prints the current light.

Solution:

type Traffic_Light is (Red, Yellow, Green);

procedure Print_Light(Light : Traffic_Light) is
begin
   case Light is
      when Red    => Put_Line("Red Light");
      when Yellow => Put_Line("Yellow Light");
      when Green  => Put_Line("Green Light");
   end case;
end;

begin
   Print_Light(Red);
   Print_Light(Yellow);
   Print_Light(Green);
end;

Exercise 2: Use Enumeration Attributes

Using the Traffic_Light enumeration, write a program that prints the position of each light and its successor.

Solution:

declare
   Light : Traffic_Light := Red;
begin
   for Light in Traffic_Light loop
      Put_Line("Light: " & Traffic_Light'Image(Light));
      Put_Line("Position: " & Integer'Image(Traffic_Light'Pos(Light)));
      if Light /= Green then
         Put_Line("Successor: " & Traffic_Light'Image(Traffic_Light'Succ(Light)));
      else
         Put_Line("No Successor for Green");
      end if;
      Put_Line("");
   end loop;
end;

Common Mistakes and Tips

  • Forgetting to handle all enumeration values in a case statement: Ensure that all possible values are covered, or use when others to handle unexpected values.
  • Using enumeration attributes incorrectly: Remember that 'Pos and 'Val are zero-based, meaning the first value has a position of 0.

Conclusion

Enumerations in Ada provide a powerful way to define and use a set of related constants. They enhance code readability and maintainability by allowing meaningful names for values. Understanding how to define, use, and manipulate enumerations, along with their attributes, is essential for writing clear and effective Ada programs. In the next module, we will explore more advanced data types, starting with arrays.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved