In Ada, subprograms are essential building blocks that allow you to encapsulate and reuse code. There are two main types of subprograms: procedures and functions. This section will cover the differences between them, how to define and use them, and provide practical examples and exercises.

Key Concepts

Procedures

  • Definition: A procedure is a subprogram that performs a specific task but does not return a value.
  • Syntax:
    procedure Procedure_Name (Parameter_List) is
    begin
       -- Procedure body
    end Procedure_Name;
    
  • Example:
    procedure Print_Message is
    begin
       Put_Line("Hello, Ada!");
    end Print_Message;
    

Functions

  • Definition: A function is a subprogram that performs a specific task and returns a value.
  • Syntax:
    function Function_Name (Parameter_List) return Return_Type is
    begin
       -- Function body
    end Function_Name;
    
  • Example:
    function Add (A, B : Integer) return Integer is
    begin
       return A + B;
    end Add;
    

Parameter Modes

  • In: The parameter is read-only.
  • Out: The parameter is write-only.
  • In Out: The parameter can be read and modified.

Parameter Mode Syntax

procedure Update_Value (X : in out Integer) is
begin
   X := X + 1;
end Update_Value;

Practical Examples

Example 1: Procedure with Parameters

procedure Greet (Name : in String) is
begin
   Put_Line("Hello, " & Name & "!");
end Greet;

-- Usage
begin
   Greet("Alice");
end;

Explanation: This procedure takes a string parameter Name and prints a greeting message.

Example 2: Function with Parameters

function Multiply (A, B : Integer) return Integer is
begin
   return A * B;
end Multiply;

-- Usage
begin
   Put_Line(Integer'Image(Multiply(3, 4)));
end;

Explanation: This function takes two integer parameters A and B, multiplies them, and returns the result.

Exercises

Exercise 1: Create a Procedure

Task: Write a procedure Print_Square that takes an integer parameter and prints its square.

Solution:

procedure Print_Square (X : in Integer) is
begin
   Put_Line(Integer'Image(X * X));
end Print_Square;

-- Usage
begin
   Print_Square(5);
end;

Exercise 2: Create a Function

Task: Write a function Factorial that takes an integer parameter and returns its factorial.

Solution:

function Factorial (N : Integer) return Integer is
begin
   if N = 0 then
      return 1;
   else
      return N * Factorial(N - 1);
   end if;
end Factorial;

-- Usage
begin
   Put_Line(Integer'Image(Factorial(5)));
end;

Exercise 3: Procedure with In Out Parameter

Task: Write a procedure Increment that takes an integer parameter by reference and increments it by 1.

Solution:

procedure Increment (X : in out Integer) is
begin
   X := X + 1;
end Increment;

-- Usage
declare
   Y : Integer := 10;
begin
   Increment(Y);
   Put_Line(Integer'Image(Y)); -- Should print 11
end;

Common Mistakes and Tips

  • Common Mistake: Forgetting to specify the parameter mode.
    • Tip: Always specify in, out, or in out for each parameter.
  • Common Mistake: Using a procedure when a function is more appropriate.
    • Tip: Use functions when you need to return a value and procedures for actions.

Summary

In this section, you learned about procedures and functions in Ada, including their definitions, syntax, and usage. You also practiced creating and using subprograms with various parameter modes. Understanding these concepts is crucial for writing modular and reusable code in Ada. In the next section, we will delve into advanced data types, starting with arrays.

© Copyright 2024. All rights reserved