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

Access Types and Pointers

Next ►
►

In this section, we will delve into access types and pointers in Ada. Understanding these concepts is crucial for managing dynamic memory and creating complex data structures.

Key Concepts

  1. Access Types: These are types that provide a way to reference dynamically allocated objects.
  2. Pointers: Variables that store the address of another variable.
  3. Dynamic Memory Allocation: The process of allocating memory during the runtime of the program.

Access Types

Access types in Ada are similar to pointers in other programming languages. They allow you to create references to dynamically allocated objects.

Declaring Access Types

To declare an access type, you use the access keyword. Here is the syntax:

type Access_Type is access Target_Type;
  • Access_Type: The name of the access type.
  • Target_Type: The type of the object that the access type will point to.

Example

with Ada.Text_IO; use Ada.Text_IO;

procedure Access_Type_Example is
   type Integer_Ptr is access Integer;
   Ptr : Integer_Ptr;
begin
   Ptr := new Integer'(10);
   Put_Line("Value: " & Integer'Image(Ptr.all));
   Ptr.all := 20;
   Put_Line("Updated Value: " & Integer'Image(Ptr.all));
   -- Free the allocated memory
   Unchecked_Deallocation(Integer, Ptr);
end Access_Type_Example;

Explanation

  • type Integer_Ptr is access Integer;: Declares an access type for integers.
  • Ptr : Integer_Ptr;: Declares a pointer of type Integer_Ptr.
  • Ptr := new Integer'(10);: Allocates memory for an integer and initializes it to 10.
  • Ptr.all: Dereferences the pointer to access the value it points to.
  • Unchecked_Deallocation(Integer, Ptr);: Frees the allocated memory.

Dynamic Memory Allocation

Dynamic memory allocation in Ada is done using the new keyword. This allows you to allocate memory for a variable at runtime.

Example

with Ada.Text_IO; use Ada.Text_IO;

procedure Dynamic_Memory_Allocation is
   type String_Ptr is access String;
   Ptr : String_Ptr;
begin
   Ptr := new String'("Hello, Ada!");
   Put_Line("String: " & Ptr.all);
   -- Free the allocated memory
   Unchecked_Deallocation(String, Ptr);
end Dynamic_Memory_Allocation;

Explanation

  • type String_Ptr is access String;: Declares an access type for strings.
  • Ptr : String_Ptr;: Declares a pointer of type String_Ptr.
  • Ptr := new String'("Hello, Ada!");: Allocates memory for a string and initializes it.
  • Ptr.all: Dereferences the pointer to access the string.
  • Unchecked_Deallocation(String, Ptr);: Frees the allocated memory.

Practical Exercises

Exercise 1: Basic Pointer Operations

Task: Create a program that uses an access type to allocate memory for an integer, modify its value, and then deallocate the memory.

Solution:

with Ada.Text_IO; use Ada.Text_IO;

procedure Basic_Pointer_Operations is
   type Integer_Ptr is access Integer;
   Ptr : Integer_Ptr;
begin
   Ptr := new Integer'(5);
   Put_Line("Initial Value: " & Integer'Image(Ptr.all));
   Ptr.all := 15;
   Put_Line("Modified Value: " & Integer'Image(Ptr.all));
   Unchecked_Deallocation(Integer, Ptr);
end Basic_Pointer_Operations;

Exercise 2: Dynamic Array Allocation

Task: Create a program that dynamically allocates memory for an array of integers, initializes the array, and then deallocates the memory.

Solution:

with Ada.Text_IO; use Ada.Text_IO;

procedure Dynamic_Array_Allocation is
   type Integer_Array is array (Natural range <>) of Integer;
   type Integer_Array_Ptr is access Integer_Array;
   Ptr : Integer_Array_Ptr;
begin
   Ptr := new Integer_Array'(1 => 10, 2 => 20, 3 => 30);
   for I in Ptr'Range loop
      Put_Line("Element " & Integer'Image(I) & ": " & Integer'Image(Ptr(I)));
   end loop;
   Unchecked_Deallocation(Integer_Array, Ptr);
end Dynamic_Array_Allocation;

Common Mistakes and Tips

  1. Forgetting to Deallocate Memory: Always ensure that you deallocate memory to avoid memory leaks.
  2. Dereferencing Null Pointers: Always check if a pointer is null before dereferencing it.
  3. Unchecked_Deallocation: Use Unchecked_Deallocation carefully to avoid dangling pointers.

Conclusion

In this section, we covered the basics of access types and pointers in Ada. We learned how to declare access types, allocate and deallocate memory dynamically, and perform basic pointer operations. These concepts are fundamental for managing dynamic memory and creating complex data structures in Ada. In the next module, we will explore modular programming in Ada, starting with packages.

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