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

Records

Next ►
►

In Ada, records are composite data types that allow you to group related data items of different types under a single name. They are similar to structs in C or classes in other object-oriented languages but without methods. Records are useful for modeling complex data structures and improving code readability and maintainability.

Key Concepts

  1. Definition of Records: How to define a record type.
  2. Record Components: The fields or components that make up a record.
  3. Record Initialization: How to create and initialize record variables.
  4. Accessing Record Components: How to access and modify the fields of a record.
  5. Nested Records: Using records within records.
  6. Operations on Records: Common operations you can perform on records.

  1. Definition of Records

To define a record in Ada, you use the record keyword within a type declaration. Here is the basic syntax:

type Record_Name is record
    Field1 : Data_Type1;
    Field2 : Data_Type2;
    -- More fields as needed
end record;

Example

type Person is record
    Name  : String(1..50);
    Age   : Integer;
    Email : String(1..100);
end record;

In this example, Person is a record type with three fields: Name, Age, and Email.

  1. Record Components

Each field in a record is called a component. Components can be of any data type, including other records, arrays, or access types.

Example

type Address is record
    Street  : String(1..100);
    City    : String(1..50);
    ZipCode : String(1..10);
end record;

type Employee is record
    ID      : Integer;
    Name    : String(1..50);
    Address : Address;  -- Nested record
end record;

In this example, Employee has a nested record Address.

  1. Record Initialization

You can initialize a record when you declare it or later in the code.

Example

declare
    John : Person := (Name => "John Doe", Age => 30, Email => "[email protected]");
begin
    -- Code using John
end;

You can also initialize fields individually:

declare
    Jane : Person;
begin
    Jane.Name := "Jane Smith";
    Jane.Age := 25;
    Jane.Email := "[email protected]";
end;

  1. Accessing Record Components

To access or modify a field in a record, use the dot notation.

Example

declare
    Employee1 : Employee;
begin
    Employee1.ID := 101;
    Employee1.Name := "Alice Johnson";
    Employee1.Address.Street := "123 Main St";
    Employee1.Address.City := "Wonderland";
    Employee1.Address.ZipCode := "12345";
end;

  1. Nested Records

Records can contain other records as fields, allowing for complex data structures.

Example

type Company is record
    Name     : String(1..100);
    CEO      : Person;
    Location : Address;
end record;

declare
    MyCompany : Company;
begin
    MyCompany.Name := "Tech Innovators";
    MyCompany.CEO.Name := "Eve Adams";
    MyCompany.CEO.Age := 45;
    MyCompany.CEO.Email := "[email protected]";
    MyCompany.Location.Street := "456 Innovation Drive";
    MyCompany.Location.City := "Tech City";
    MyCompany.Location.ZipCode := "67890";
end;

  1. Operations on Records

You can perform various operations on records, such as assignment, comparison, and passing them to subprograms.

Example

declare
    Employee1, Employee2 : Employee;
begin
    Employee1 := Employee2;  -- Assignment

    if Employee1 = Employee2 then  -- Comparison
        -- Code if employees are the same
    end if;
end;

Practical Exercise

Exercise 1: Define and Use a Record

  1. Define a record type Book with the following fields:

    • Title (String of length 1..100)
    • Author (String of length 1..50)
    • ISBN (String of length 1..13)
    • Year (Integer)

  2. Declare a variable of type Book and initialize it with appropriate values.

  3. Write a procedure Print_Book that takes a Book record as a parameter and prints its details.

Solution

with Ada.Text_IO; use Ada.Text_IO;

procedure Main is

    type Book is record
        Title  : String(1..100);
        Author : String(1..50);
        ISBN   : String(1..13);
        Year   : Integer;
    end record;

    procedure Print_Book(B : Book) is
    begin
        Put_Line("Title: " & B.Title);
        Put_Line("Author: " & B.Author);
        Put_Line("ISBN: " & B.ISBN);
        Put_Line("Year: " & Integer'Image(B.Year));
    end Print_Book;

    MyBook : Book := (Title => "Ada Programming", Author => "John Doe", ISBN => "1234567890123", Year => 2023);

begin
    Print_Book(MyBook);
end Main;

Explanation

  1. The Book record type is defined with four fields.
  2. A variable MyBook of type Book is declared and initialized.
  3. The Print_Book procedure takes a Book record as a parameter and prints its details using Put_Line.

Conclusion

In this section, you learned about records in Ada, including how to define, initialize, and use them. Records are powerful tools for organizing related data and improving code readability. You also practiced defining and using records through a practical exercise. In the next section, you will learn about enumerations, another important data type in Ada.

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