Ada (язык программирования)

Материал из Национальной библиотеки им. Н. Э. Баумана
Последнее изменение этой страницы: 02:09, 4 марта 2017.
Ada (язык программирования)
Разработчики:
  • MIL-STD-1815/Ada 83: Жан Ишбиа.
  • Ada 95: Такер Тефт.
  • Ada 2005: Такер Тефт
Постоянный выпуск: Ada 2012
Операционная система: Кросс-платформенное ПО
Веб-сайт www.adaic.org

А́да (Ada) — язык программирования, созданный в 1979—1980 годах в ходе проекта Министерством обороны США с целью разработать единый язык программирования для встроенных систем (то есть систем управления автоматизированными комплексами, функционирующими в реальном времени). Имелись в виду прежде всего бортовые системы управления военными объектами (кораблями, самолётами, танками, ракетами, снарядами и т.п.).

Содержание

Библиотека и компилируемые модули

В общем случае, программа на языке Ада представляет собой один или несколько программных модулей, которые могут компилироваться как совместно, так и раздельно. Кроме того, программные модули являются основой построения библиотек Ады, поэтому их также называют библиотечными модулями. Программные модули бывают четырех видов:

  • Подпрограммы - Являются основным средством описания алгоритмов. Различают два вида подпрограмм: процедуры и функции. Процедура - это логический аналог некоторой именованной последовательности действий. Функция - логический аналог математической функции - используется для вычисления какого-либо значения.
  • Пакет - Основное средство для определения набора логически взаимосвязанных понятий. В простейшем случае в пакете специфицируются описания типов и общих объектов. В более общем случае в нем могут специфицироваться группы взаимосвязанных понятий, включающих подпрограммы, причем, некоторые описываемые в пакете сущности могут быть "скрыты" от пользователя, что дает возможность предоставления доступа только к тем ресурсам пакета, которые необходимы пользователю и, следовательно, должны быть для него доступны.
  • Задача или задачный модуль - Средство для описания последовательности действий, причем, при наличии нескольких таких последовательностей они могут выполняться параллельно. Задачи могут быть реализованы на многомашинной или многопроцессорной вычислительной конфигурации, либо на единственном процессоре в режиме разделения времени. Синхронизация достигается путем обращения ко входам, которые подобно подпрограммам могут иметь параметры, с помощью которых осуществляется передача данных между задачами.
  • Настраиваемые модули - Средство для параметризации подпрограмм или пакетов. В ряде случаев возникает необходимость обрабатывать объекты, которые отличаются друг от друга количеством данных, типами или какими-либо другими количественными или качественными характеристиками. Если все эти изменяемые характеристики вынести из подпрограммы или пакета, то получится некоторая заготовка (или шаблон), которую можно настроить на конкретное выполнение. Непосредственно выполнить настраиваемый модуль нельзя. Но из него можно получить экземпляр настроенного модуля (подпрограмму или пакет), который пригоден для выполнения.

Каждый программный модуль обычно состоит из двух частей: спецификации и тела. Спецификация описывает интерфейс к модулю, а тело - его реализацию. Примечательно, что спецификация и тело программного модуля являются самостоятельными компилируемыми модулями, то есть, они могут компилироваться раздельно. Разбиение модуля на спецификацию и тело, а также возможность раздельной компиляции позволяют разрабатывать, кодировать и тестировать любую программу или систему как набор достаточно независимых компонентов. Такой подход полезен при разработке больших программных систем.

Методы Ады: подпрограммы, операции и знаки операций

Методами Ады являются подпрограммы (процедуры и функции), а также операции и знаки операций (возможно более корректно будет звучать: с помощью подпрограмм осуществляется реализация действий, выполняемых операциями и знаками операций). Необходимо отметить, что стандарт Ады строго различает понятия знаков операций (operators) и операций (operations).

Знаки операций представляются следующими символами (или комбинациями символов): "=", "/=", "<", ">", "<=", ">=", "&", "+", "-", "/", "*". Другие знаки операций выражаются зарезервированными словами: "and", "or", "xor", "not", "abs", "rem", "mod", - или могут состоят из нескольких зарезервированных слов: "and then", "or else". Ада позволяет осуществлять программисту совмещение (overloading) знаков операций (в современной литературе по Си++ это часто называется как "перегрузка операторов").

В общем случае, совмещением (overloading) называют механизм, который позволяет различным сущностям использовать одинаковые имена.

Использование "use type" делает знаки операций именованных типов локально видимыми. Кроме того, их можно сделать локально видимыми используя локальное переименование.

Операции включают в себя присваивание, проверку принадлежности диапазону и любые другие именованные операции. Операции, также как и знаки операций, допускают совмещение.

Следует заметить, что Ада накладывает некоторые ограничения на использование совмещений: совмещения не допускаются для операций присваивания и проверки принадлежности диапазону, а также для знаков операций "and then" и "or else".

Операция присваивания обозначается комбинацией символов ":=". Она предопределена для всех нелимитированных типов. Операция присваивания не может быть совмещена или переименована. Присваивание запрещено для лимитированных типов. Необходимо подчеркнуть, что операция присваивания в Аде, в отличие от языков C/C++, не возвращает значение и не обладает побочными эффектами.

Еще одной разновидностью операций является операция проверки принадлежности диапазону, которая обозначается с помощью зарезервированного слова "in". Для выполнения проверки на не принадлежность "in" может комбинироваться с "not" - "not in". Проверка на принадлежность диапазону разрешена для всех типов Ады, включая лимитированные.

Другие операции могут быть описаны программистом. Как правило, описания таких операций выполняются в спецификации пакета, а реализация операций выполняется с помощью соответствующих подпрограмм.

Типы данных

 Все типы
 |
 |- Простые типы
 |    |
 |    |- Скалярные типы
 |    |    |
 |    |    |- Вещественные (Real)
 |    |    |    |
 |    |    |    |- Универсальный Вещественный (Universal_Real)    -- все вещественные
 |    |    |    |                                                 -- литералы
 |    |    |    |
 |    |    |    |- Корневой Вещественный      (Root_Real)         -- только Ada95
 |    |    |         |
 |    |    |         |- с плавающей точкой     (Floating Point)
 |    |    |         |- с фиксированной точкой (Fixed Point)
 |    |    |              |
 |    |    |              |- с обычной фиксированной точкой
 |    |    |              |      (Ordinary Fixed Point)
 |    |    |              |
 |    |    |              |- с десятичной фиксированной точкой    -- только Ada95
 |    |    |                     (Decimal Fixed Point)
 |    |    |
 |    |    |- Дискретные типы
 |    |         |
 |    |         |- Целые типы
 |    |         |     |
 |    |         |     |- Универсальный Целый (Universal_Integer)  -- все
 |    |         |     |                                           -- целочисленные
 |    |         |     |                                           -- литералы
 |    |         |     |
 |    |         |     |- Корневой Целый (Root_Integer)            -- только Ada95
 |    |         |         |
 |    |         |         |- Знаковые Целые
 |    |         |         |- Модульные Целые (Modular Integer)    -- только Ada95
 |    |         |
 |    |         |- Перечислимые
 |    |              |
 |    |              |- Символьные   (Character, Wide_Character)
 |    |              |- Логический   (Boolean)
 |    |              |- Определяемые пользователем
 |    |
 |    |-- Ссылочные типы / указатели   (Access)
 |          |
 |          |- Ссылки на объекты
 |          |- Ссылки на подпрограммы                         -- только Ada95
 |
 |- Составные типы
      |
      |-- Массивы (Array)
      |     |
      |     |- Строки  (String)
      |     |- Другие, определяемые пользователем массивы
      |
      |-- Записи  (Record)
      |
      |-- Тэговые Записи (Tagged Record)                      -- только Ada95
      |
      |-- Задачи  (Task)
      |
      |-- Защищенные типы  (Protected)                        -- только Ada95 

Целочисленные типы

Предопределенный тип Integer

Предопределенный целочисленный тип Integer описан в пакете Standard (пакет Standard не нужно указывать в инструкциях спецификации контекста with и use). Точный диапазон целочисленных значений, предоставляемых этим типом, зависит от конкретной реализации компилятора и/или оборудования. Однако, стандарт определяет минимально допустимый диапазон значений для этого типа от -(2 ** 15) до +(2 ** 15 - 1) (например, в случае 32-битных систем, таких как Windows или Linux, для реализации компилятора GNAT диапазон значений типа Integer будет от -(2 ** 31) до +(2 ** 31 - 1)).

Тип Universal_Integer

Для предотвращения необходимости явного преобразования типов при описании целочисленных констант, Ада предлагает понятие универсального целого типа - 'Universal_Integer'. Все целочисленные литералы принадлежат типу 'Universal_Integer'. Многие атрибуты языка (обсуждаемые позже) также возвращают значения универсального целого типа. Установлено, что тип 'Universal_Integer' совместим с любым другим целочисленным типом, поэтому, в арифметических выражениях, компилятор будет автоматически преобразовывать значения универсального целого типа в значения соответствующего целочисленного типа.

Описание целочисленных констант

При хорошем стиле программирования, принято присваивать целочисленным значениям символьные имена. Это способствует улучшению читабельности программы и, при необходимости, позволяет легко вносить в нее изменения. Приведем простой пример описания константы (именованного числа):

 
Max_Width : constant := 10_000; -- 10_000 - имеет тип Universal_Integer
                                -- это не тип Integer 

Тип Root_Integer

Модель целочисленной арифметики Ады базируется на понятии неявного типа 'Root_Integer'. Этот тип используется как базовый тип для всех целочисленных типов Ады. Другими словами - все целочисленные типы являются производными от типа 'Root_Integer'. Диапазон значений типа Root_Integer определяется как 'System.Min_Int..System.Max_Int'. Все знаки арифметических операций описаны так, чтобы они могли выполняться над этим типом.

При описании нового целочисленного типа возможны два различных подхода, которые можно проиллюстрировать на следующем примере:

 
type X is new Integer range 0 .. 100;
type Y is range 0 .. 100; 
Здесь, тип X описывается как производный от типа Integer с допустимым диапазоном значений от 0 до 100. Исходя из этого, для типа X базовым типом будет тип Integer.

Тип Y описывается как тип с допустимым диапазоном значений от 0 до 100, и при его описании не указан тип-предок. В таком случае, он будет производным от типа 'Root_Integer', но его базовый диапазон не обязательно должен быть таким же как у 'Root_Integer'. В результате, некоторые системы могут размещать экземпляры объектов такого типа и его базового типа в одном байте. Другими словами, определение размера распределяемого места под объекты такого типа возлагается на компилятор.

Примеры целочисленных описаний

 
-- описания целочисленных статических переменных

Count           : Integer;
X, Y, Z         : Integer;
Amount          : Integer := 0;


-- описания целочисленных констант (иначе - именованных чисел)

Unity           : constant Integer := 1;
Speed_Of_Light  : constant := 300_000; -- тип Universal_Integer
A_Month         : Integer range 1..12;


-- описания целочисленных типов и подтипов
-- ( см. разделы "Подтипы" и "Производные типы" )

subtype Months is Integer range 1..12;        -- огранниченный тип Integer
-- подтипы - совместимы с их базовым типом (здесь - Integer)
-- например, переменная типа Month может быть "смешана" с переменными
-- типа Integer

type File_Id is new Integer; -- новый целочисленный тип, производный
                             -- от типа Integer

type Result_Range is new Integer range 1..20_000;
-- производный тип с объявлением ограничения

type Other_Result_Range is range 1..100_000;
-- тип производный от Root_Integer
-- при этом, компилятор будет выбирать подходящий размер целочисленного значения
-- для удовлетворения требований задаваемого диапазона 

Предопределенные знаки операций для целочисленных типов

 
+, -               унарные плюс и минус
+, -, *, /         сложить, вычесть, умножить и разделить
**                 возведение в степень (только целые значения степени)
mod                модуль
rem                остаток
abs                абсолютное значение  

Модульные типы

Все целочисленные типы, которые мы рассматривали ранее, известны как целые числа со знаком. Для таких типов соблюдается правило - если в случае вычисления результат выходит за диапазон допустимых значений типа, то генерируется ошибка переполнения. Такие целочисленные типы были представлены стандартом Ada83.

Стандарт Ada95 разделяет целочисленные типы на целые числа со знаком и модульные типы. По существу, модульные типы являются целыми числами без знака. Характерной особенностью таких типов является свойство цикличности арифметических операций. Таким образом, модульные типы соответствуют целочисленным беззнаковым типам в других языках программирования (например: Byte, Word... - в реализациях Паскаля; unsigned_short, unsigned... - в C/C++).

В качестве простого примера рассмотрим следующий фрагмент кода:

  . . .
type  Byte  is mod 2 ** 8;    -- (2 ** 8) = 256
    Count : Byte := 255;
begin
    Count := Count + 1;
    . . .  

Здесь не производится генерация ошибки в результате выполнения сложения. Вместо этого, переменная Count, после выполнения сложения, будет содержать 0.

Кроме этого, с модульными типами удобно использовать знаки битовых операций "and", "or", "xor" и "not". Такие операции трактуют значения модульного типа как битовый шаблон. Например:

 
type  Byte  is mod 2 ** 8;    -- (2 ** 8) = 256
    Some_Var_1  : Byte;
    Some_Var_2  : Byte;
    Mask        : constant := 16#0F#
begin
    . . .
    Some_Var_2 := Some_Var_1 and Mask;
    . . . 

Поскольку модульные типы не имеют отрицательных значений, для них допускается смешивание знаков битовых операций со знаками арифметических операций в одном выражении.

Следует заметить, что хотя при описании модульных типов зачастую используют степень двойки, использование двоичной системы счисления при описании модульных типов не является обязательным требованием.

Ада допускает выполнение преобразований беззнаковых чисел модульных типов в числа со знаком и обратно. При этом, производится проверка результата преобразования на допустимость диапазону значений типа назначения. В случае неудачи будет сгенерировано исключение 'Constraint_Error'. Например:

 
type  Unsigned_Byte  is mod 2 ** 8;    -- (2 ** 8) = 256
type  Signed_Byte    is range -128 .. +127;

U : Unsigned_Byte := 150;
S : Signed_Byte   := Signed_Byte(U);  -- здесь будет сгенерировано исключение
                                      --   Constraint_Error 

Этот код будет вызывать генерацию исключения 'Constraint_Error'.

Дополнительные целочисленные типы системы компилятора GNAT

Стандарт языка Ада допускает определять в реализации Ада-системы собственные дополнительные целочисленные типы. Таким образом, в пакете 'Standard' системы компилятора GNAT определены дополнительные целочисленные типы:

 
type   Short_Short_Integer is range -(2 ** 7) .. +(2 ** 7 - 1);
type   Short_Integer       is range -(2 ** 15) .. +(2 ** 15 - 1);
type   Long_Integer        is range -(2 ** 31) .. +(2 ** 31 - 1);
type   Long_Long_Integer   is range -(2 ** 63) .. +(2 ** 63 - 1); 

Кроме этого, стандарт требует наличия определения дополнительных 8-, 16-, 32- и 64-битных целочисленных типов в пакете Interfaces:

  
type   Integer_8     is range   -2 **  7 .. 2 **  7 - 1;
type   Integer_16    is range   -2 ** 15 .. 2 ** 15 - 1;
type   Integer_32    is range   -2 ** 31 .. 2 ** 31 - 1;
type   Integer_64    is range   -2 ** 63 .. 2 ** 63 - 1;

type   Unsigned_8    is mod   2 **  8;
type   Unsigned_16   is mod   2 ** 16;
type   Unsigned_32   is mod   2 ** 32;
type   Unsigned_64   is mod   2 ** 64;

Вещественные типы

Ада предусматривает два способа представления вещественных чисел: представление вещественных величин с плавающей точкой и представление вещественных величин с фиксированной точкой. Кроме этого вы можете использовать типы вещественных величин с десятичной фиксированной точкой.

Вещественные типы с плавающей точкой, тип Float

Вещественные типы с плавающей точкой имеют неограниченный диапазон значений и точность, определяемую количеством десятичных цифр после запятой. Представление чисел с плавающей точкой имеет фиксированную относительную погрешность.

Пакет Standard предоставляет предопределенный вещественный тип с плавающей точкой Float, который обеспечивает точность в шесть десятичных цифр после запятой:

  
type  Float  is digits 6 range -16#0.FFFF_FF#E+32 .. 16#0.FFFF_FF#E+32;
                         --    -3.40282E+38 ..  3.40282E+38

В пакете Standard компилятора GNAT, для 32-битных систем Linux и Windows, дополнительно представлены еще несколько вещественных типов с плавающей точкой (фактические значения констант для различных платформ отличаются):

  
type  Short_Float     is digits 6
  range -16#0.FFFF_FF#E+32 .. 16#0.FFFF_FF#E+32;
  --    -3.40282E+38 ..  3.40282E+38

type  Long_Float      is digits 15
  range -16#0.FFFF_FFFF_FFFF_F8#E+256 .. 16#0.FFFF_FFFF_FFFF_F8#E+256;
  --    -1.79769313486232E+308 ..  1.79769313486232E+308

type  Long_Long_Float is digits 18
  range -16#0.FFFF_FFFF_FFFF_FFFF#E+4096 .. 16#0.FFFF_FFFF_FFFF_FFFF#E+4096;
  --    -1.18973149535723177E+4932 ..  1.18973149535723177E+4932

Ниже следуют примеры описаний вещественных величин с плавающей точкой.

  
X         : Float;
A, B, C   : Float;
Pi        : constant Float := 3.14_2;
Avogadro  : constant := 6.027E23;        -- тип Universal_Float

subtype Temperatures is Float range 0.0..100.0;
type Result is new Float range 0.0..20_000.0;

type Velocity is new Float;
type Height is new Float;
-- нельзя случайно смешивать Velocity и Height
-- без явного преобразования типов.

type Time is digits 6 range 0.0..10_000.0;
-- в этом диапазоне требуемая точность - шесть десятичных цифр
-- после точки

type Degrees is digits 2 range -20.00..100.00;
-- требуемая точность - две десятичных цифры после точки

Следующие знаки операций предопределены для каждого вещественного типа с плавающей точкой.

  
+, -, *, /
**                 возведение в степень (только целые значения степени)
abs                абсолютное значение

Вещественные типы с фиксированной точкой, тип 'Duration'

Представление чисел с фиксированной точкой имеет более ограниченный диапазон значений и указанную абсолютную погрешность, которая задается как 'delta' этого типа.

В пакете Standard предоставлен предопределенный вещественный тип с фиксированной точкой 'Duration', который используется для представления времени и обеспечивает точность измерения времени в 50 микросекунд:

  
type Duration is delta 0.000000001
     range -((2 ** 63 - 1) * 0.000000001) ..
           +((2 ** 63 - 1) * 0.000000001);

Ниже следуют примеры описаний вещественных типов с фиксированной точкой.

 
type Volt is delta 0.125 range 0.0 .. 255.0;

type Fraction is delta System.Fine_Delta range -1.0..1.0;        -- Ada95
        -- Fraction'Last = 1.0 - System.Fine_Delta 

Последний пример показывает полезную способность вещественных типов с фиксированной точкой - четкое определение насколько тип должен быть точным. Например, это позволяет контролировать ошибки, возникающие при округлении.

Вещественные типы с десятичной фиксированной точкой

Следует учитывать, что поскольку от реализации компилятора Ады не требуется обязательное обеспечение поддержки вещественных величин с десятичной фиксированной точкой, то это может вызвать трудности при переносе программного обеспечения на другую систему или при использовании разных компиляторов. Примером описания вещественного типа с десятичной фиксированной точкой может служить следующее:

  
type Money is delta 0.01 digits 15; -- десятичная фиксированная точка,
                                    -- здесь величина, задаваемая в delta,
                                    -- должна быть степенью 10
subtype Salary is Money digits 10;  

Типы Universal_Float и Root_Real

Подобно тому как все целочисленные литералы принадлежат универсальному классу 'Universal_Integer', все вещественные численные литералы принадлежат универсальному классу 'Universal_Float'. Этот универсальный тип совместим с любым вещественным типом с плавающей точкой и любым вещественным типом с фиксированной точкой. Такой подход избавляет от необходимости выполнения различных преобразований типов при описании вещественных констант и переменных.

Модель вещественной арифметики Ады основывается на анонимном типе 'Root_Real'. Этот анонимный тип используется как базовый тип для всех вещественных типов. Тип 'Root_Real' имеет точность, которая определяется значением константы 'Max_Base_Digits' пакета System (System.Max_Base_Digits). Такой подход использован для облегчения переносимости программ.

Пакеты для численной обработки

Полное обсуждение поддержки численной обработки в Аде - весьма обширная тема. Здесь приведем список пакетов для численной обработки, которые предоставляются поставкой компилятора GNAT:

  
Ada.Numerics
Ada.Numerics.Aux
Ada.Numerics.Float_Random
Ada.Numerics.Discrete_Random

Ada.Numerics.Complex_Types
Ada.Numerics.Complex_Elementary_Functions
Ada.Numerics.Elementary_Functions

Ada.Numerics.Generic_Complex_Types
Ada.Numerics.Generic_Complex_Elementary_Functions
Ada.Numerics.Generic_Elementary_Functions

Ada.Numerics.Long_Complex_Types
Ada.Numerics.Long_Complex_Elementary_Functions
Ada.Numerics.Long_Elementary_Functions

Ada.Numerics.Long_Long_Complex_Types
Ada.Numerics.Long_Long_Complex_Elementary_Functions
Ada.Numerics.Long_Long_Elementary_Functions

Ada.Numerics.Short_Complex_Types
Ada.Numerics.Short_Complex_Elementary_Functions
Ada.Numerics.Short_Elementary_Functions

Следует заметить, что пакет 'Ada.Numerics.Aux', который указан выше, не предназначен для непосредственного использования в программах пользователя, и упоминается только с целью полноты показанного выше списка.

Преобразование численных типов

Поскольку тип Float и тип Integer - различные типы, то Ада не допускает смешивания величин этих типов в одном выражении. Однако, встречаются случаи, когда нам необходимо комбинировать значения этих типов. В таких ситуациях нам необходимо производить преобразование значений одного численного типа в значения другого численного типа. Ада позволяет явно указывать необходимость преобразования значения типа 'Float' в значение типа 'Integer', и наоборот. Для выполнения такого преобразования используется синтаксис подобный синтаксису вызова функции:

  
X : Integer := 4;
Y : Float;

Y := Float(X);

  . . .

X := Integer(Y);

В этом случае компилятор, во время трансляции, добавит необходимый код для преобразования типов. Такое преобразование типов всегда возможно, и будет успешным если значение результата не будет нарушать границ допустимого диапазона значений.
Следует заметить, что при преобразовании вещественного значения Float в целое значение Integer Ада использует традиционные для математики правила округления.

Организация циклических вычислений

При решении реальных задач часто возникает необходимость в организации циклических вычислений. Все конструкции организации циклических вычислений в Аде имеют форму "loop ... end loop" с некоторыми вариациями. Для выхода из цикла может быть использована инструкция 'exit'.

Простые циклы (loop)

Примером простейшего цикла может служить бесконечный цикл:

  
loop

    -- инструкции тела цикла

end loop;

Цикл while

Во многих случаях, прежде чем выполнять действия которые описываются инструкциями тела цикла, необходимо проверить какое-либо условие. Для таких случаев Ада предусматривает конструкцию цикла 'while'.

Цикл 'while' идентичен циклу 'while' в языке Паскаль. Проверка условия выполнения цикла производится до входа в блок инструкций составляющих тело цикла. При этом, если результат вычисления логического выражения будет 'True', то будет выполнен блок инструкций тела цикла. В противном случае, тело цикла - не выполняется.

  
while логическое_выражение loop

    -- инструкции тела цикла

end loop;

Необходимо заметить, что результат вычисления логического выражения должен иметь предопределенный тип 'Standard.Boolean'

Цикл for

Еще одним распространенным случаем является ситуация когда необходимо выполнить некоторые действия заданное количество раз, то есть организовать счетный цикл. Для этого Ада предусматривает конструкцию цикла 'for'.

Конструкция цикла for Ады аналогична конструкции цикла 'for', представленной в языке Паскаль.

Существует несколько правил использования цикла for:

тип переменной-счетчика цикла for определяется типом указываемого диапазона значений счетчика, и должен быть дискретного типа, вещественные значения - недопустимы счетчик не может быть модифицирован в теле цикла, другими словами - счетчик доступен только по чтению область действия переменной-счетчика распространяется только на тело цикла Примечательно также, что тело цикла не будет выполняться если при указании диапазона значений переменной-счетчика величина значения "нижней границы" будет больше чем величина значения "верхней границы".

 
for счетчик in диапазон_значений_счетчика loop

    -- инструкции тела цикла

end loop;


for  Count in 1..20 loop
    Put (Count);
end loop; 

Возможен перебор значений диапазона в обратном порядке:

  
for счетчик in reverse диапазон_значений_счетчика loop

    -- инструкции тела цикла

end loop;


for Count in reverse 1..20 loop
    Put (Count);
end loop;

Любой дискретный тип может использоваться для указания диапазона значений переменной-счетчика.

  
declare
    subtype List is Integer range 1..10;

begin
    for Count in List loop
        Put (Count);
    end loop;
end;

Здесь, тип 'List' был использован для указания диапазона значений переменной-счетчика 'Count'. Подобным образом также можно использовать любой перечислимый тип.

Инструкции exit и exit when

Инструкции 'exit' и 'exit when' могут быть использованы для преждевременного выхода из цикла. При этом, выполнение программы будет продолжено в точке непосредственно следующей за циклом. Два варианта, показанных ниже, имеют одинаковый эффект:

  
loop

    -- инструкции тела цикла

    if логическое_выражение then
        exit;
    end if;
end loop;


loop

    -- инструкции тела цикла

    exit when логическое_выражение;
end loop;

Именованые циклы

Инструкции преждевременного выхода из цикла 'exit' и 'exit when', обычно, осуществляют выход из того цикла, который непосредственно содержит данную инструкцию. Однако, мы можем именовать циклы и модифицировать инструкцию выхода из цикла так, чтобы осуществлять выход сразу из всех вложенных циклов. Во всех случаях, следующая выполняемая инструкция будет следовать сразу за циклом из которого был осуществлен выход.

  
outer_loop:
loop

    -- инструкции

    loop

        -- инструкции

        exit outer_loop when логическое_выражение;
    end loop;
end loop outer_loop;

Примечательно, что в случае именованого цикла 'end loop' также необходимо именовать меткой.

Инструкция перехода goto

Инструкция перехода goto предусмотрена для использования в языке Ада, в исключительных ситуациях, и имеет следующий вид:

  
goto Label;

<<Label>>

Использование инструкции goto очень ограничено и четко осмысленно. Вы не можете выполнить переход внутрь условной инструкции 'if', внутрь цикла '(loop)', или, как в языке Паскаль, за пределы подпрограммы.

Стандартизация

Язык обзавелся стандартом ANSI в 1983 (ANSI / MIL-STD 1815), и стандартом ИСО в 1987 (ISO-8652: 1987). Эта версия языка широко известна как Ada 83 (исходя из даты его принятия ANSI).

Ada 95, совместим с ISO / ANSI стандарт (ISO-8652: 1995), это последний стандарт для Ады. Он был принят в феврале 1995 года (выпущен Ada 95 - первый стандарт по ИСО для объектно-ориентированного языка программирования). ВВС США финансировали развитие GNAT компилятора для языка Ада, чтобы помочь ему стать стандартом разработки программного обеспечения для военных целей.

Используемая литература

  1. А.Гавва "Адское программирование" : 2004г.
  2. Ада (язык программирования):Материал из Википедии — свободной энциклопедии