]]> ]]>
Править | Обсудить | История

Ada

Русское название:
Ада
Дата создания:
1983
Создан под влиянием:
Повлиял на:
Парадигма:
Типизация:
Принятые расширения файлов:
.adb, .ads, .ada
Диалекты:
Реализации и версии (свернуть все | развернуть все):
Язык программирования

Ada — мощнейший модульный объектно–ориентированный язык общего назначения, ориентированный на разработку надёжного программного обеспечения.

Ada был создан в 1979–1980 годах па заказу Министерства Oбороны США. Целью проекта было уменьшение количества различных языков, используемых в Министерстве для различных целей (на 1983 год — свыше 450) путем разработки единого языка, удовлетворяющего требованиям Министерства. Для этого была создана рабочая группа HOLWG, которая прежде всего составила набор требований к высокоуровневому языку разработоки для встроенных систем. Эти требования были известны как “стальные” (Steelman language requirements) и делали упор на надежности, поддерживаемости и эффективности. Среди прочего в них входили обработка исключений, проверка ошибок в процессе выполнения и возможность параллельных вычислений.

После формулирования требований к языку была проведен анализ существующих языков, который показал, что ни один из них не удовлетворяет требованиям в достаточной мере. Был проведен конкурс на разработку нового языка, который выиграл Жан Ишбиа (Jean Ichbiah) из CII Honeywell Bull. В 1979-80 годах проект языка был завершен и одобрен Министерством. Он был основан на Pascal и заимствовал элементы синтаксиса из ALGOL. Первым компилятором языка, прошедшим валидацию, был NYU Ada/Ed translator, сертифицированный в 1983 году.

В том же 1983 году был принят первый стандарт языка ANSI/MIL-STD 1815A, в 1987 году перекочевавший в ISO-8652:1987. Следующим стандартом стал ISO-8652:1995, в котором в Ada (впервые среди всех ISO-стандартизированных языков) была включена поддержка объектно-ориентированного программирования; кроме того, область применимости языка была расширена до численного, финансового и системного программирования.

Особенности языка:

  • строгая типизация. Работа с объектами, не имеющими типов, невозможна, а автоматические преобразования типов сведены к абсолютному минимуму.
  • механизм модульности включает три типа программных единиц: задания (единицы параллельного выполнения), пакеты (единицы модульной стурктуры, использующиеся, например, для реализации абстрактных типов данных) и процедуры.
  • богатый инструментарий отслеживания и обработки ошибок как на этапе компиляции, так и во время выполнения программы. Язык построен таким образом, чтобы как можно большее количество ошибок обнаруживалось на этапе компиляции. Сообщения компилятора об ошибках сделаны максимально информативными. Механизм исключений позволяет обрабатывать ошибки, возникающие на этапе выполнения программы.
  • динамическая работа с памятью, без обобщенных указателей, зато с объявленными в явном виде типами доступа (access types). Семантика языка позволяет реализовать автоматический сбор мусора, но большинство реализаций по умолчанию не поддерживают его.
  • одним из требований при разработке языка была максимально лёгкая читаемость текстов программ, даже в ущерб лёгкости написания. Результатом такого подхода стал несколько «тяжеловесный» синтаксис: ключевые слова и операторы (за исключением арифметических) используют слова английского языка без сокращений.
  • поддержка обобщенного программирования.
  • параллельное программирование реализовано через механизм рандеву (rendezvous).

В настоящее время существуют компиляторы Ada под практически любую операционную систему, плюс компиляторы в Java и .NET байткод. Язык Ada используется в США и Европе при разработке сложных больших проектов, требующих повышенной безопасности и надежности, причём не только в военных, а в любых критических приложениях.

Элементы синтаксиса:

Комментарий до конца строки --
Регистрозависимость нет
Регулярное выражение идентификатора переменной [a-zA-Z](_?[a-zA-Z0-9])*
Присваивание значения переменной :=
Объявление переменной variable: type
Группировка выражений ( ... )
Блок begin ... end или foo ... end foo where foo in { if, do, ... }
Тождественное равенство =
Тождественное неравенство /=
Сравнение < > <= >=
Определение функции function f(p1 : type1; p2 : type2; ... ) return returntype is begin ... end f;
Вызов функции f(a, b, ...)
Вызов функции без параметров f
Последовательность ;
Если - то if condition then ... end if
Если - то - иначе if condition1 then ... elsif condition2 then ... else ... end if
Бесконечный цикл loop ... end loop
Цикл с предусловием while condition loop ... end loop
Цикл с постусловием loop ... exit when condition end loop
Цикл for - next для диапазона целых чисел с инкрементом на 1 for i in 1 .. 10 loop ... end loop
Цикл for - next для диапазона целых чисел с декрементом на 1 for i in reverse 1 .. 10 loop ... end loop

Редактирование Ада в SciTE
Редактирование Ада в SciTE

IDE/Редакторы:

Примеры:

Hello, World!:

Пример для версий gnat 3.4.5
with Ada.Text_IO; 
 
procedure HelloWorld is
begin
  Ada.Text_IO.Put_Line("Hello, World!");
end HelloWorld;

Факториал:

Пример для версий gnat 3.4.5

В этом примере используется рекурсивное определение факториала.

Следует отметить, что для вывода на печать текста, целых и длинных целых чисел используются разные пакеты. Команда put в общем случае принимает несколько аргументов, изменяющих формат вывода: Item — это число, которое выводится на печать, Width — количество позиций, которые следует использовать при выводе, Fore и Aft — количества десятичных цифр, которые следует вывести до и после запятой и т.д. Если передается только один аргумент, он считается значением Item. Установив Width равным 1 или другому числу, меньшему, чем количество цифр в выводимом числе, можно вывести его без пробелов в начале (что является умолчательным способом для языка Ada).

Кроме того, отметим, что Ada не поддерживает неявные преобразования типов, так что для вычисления N*Fact(N-1) сначала следует явно преобразовать N к типу Long_Long_Integer.

with Ada.Text_IO, Ada.Integer_Text_IO, Ada.Long_Long_Integer_Text_IO;

procedure Factorial is
begin
   declare 
      function Fact (N: Integer) return Long_Long_Integer is
      begin
         if N=0 then
            return 1;
         else 
            return Long_Long_Integer(N)*Fact(N-1);
         end if;
      end Fact;
   i: Integer := 0;
   begin
      loop
         Ada.Integer_Text_IO.Put (Item => i, Width => 1);
         Ada.Text_IO.Put ("! = ");
         Ada.Long_Long_Integer_Text_IO.Put (Item => Fact(i), Width => 1);
         Ada.Text_IO.New_Line;
         i := i + 1;
         exit when i=17;
      end loop;
   end;
end Factorial;

Числа Фибоначчи:

Пример для версий gnat 3.4.5

В этом примере используется рекурсивное определение чисел Фибоначчи.

with Ada.Text_IO, Ada.Integer_Text_IO;

procedure Fibonacci is
begin
   declare 
      function Fib (N: Integer) return Integer is
      begin
         if N<3 then
            return 1;
         else 
            return Fib(N-1) + Fib(N-2);
         end if;
      end Fib;
   i: Integer := 1;
   begin
      loop
         Ada.Integer_Text_IO.Put (Item => Fib(i), Width => 1);
         Ada.Text_IO.Put (", ");
         i := i + 1;
         exit when i=17;
      end loop;
      Ada.Text_IO.Put ("...");
   end;
end Fibonacci;

Квадратное уравнение:

Пример для версий gnat 3.4.5

Ada предоставляет тип данных для работы с комплексными числами, который требует использования пакетов Generic_Complex_Types и Generic_Complex_Elementary_Functions с предварительной инициализацией их типом данных для хранения комплексных чисел (в данном случае — Float). Ada не поддерживает неявные преобразования типов, поэтому все преобразования выполняются в явном виде.

with Ada.Text_IO, 
     Ada.Integer_Text_IO,
     Ada.Float_Text_IO,
     Ada.Numerics.Elementary_Functions,
     Ada.Text_IO.Complex_IO, 
     Ada.Numerics.Generic_Complex_Types,
     Ada.Numerics.Generic_Complex_Elementary_Functions;
use Ada.Text_IO, Ada.Integer_Text_IO, Ada.Float_Text_IO;

procedure QuadraticEquation is
    package Complex_Types is new Ada.Numerics.Generic_Complex_Types (Float);
    package Complex_Functions is new Ada.Numerics.Generic_Complex_Elementary_Functions(Complex_Types);
    package Complex_IO is new Ada.Text_IO.Complex_IO (Complex_Types);

    use Complex_Types, Complex_Functions, Complex_IO;

    A,B,C,D: Integer;
    A2f, Bf, S: Float;
    Dc: Complex;
begin
    Put("A = ");
    Get(Item => A);
    if A = 0 then
        Put_Line("Not a quadratic equation.");
        return;
    end if;
    Put("B = ");
    Get(B);
    Put("C = ");
    Get(C);
    A2f := Float(2*A);
    Bf := Float(B);

    D := B*B-4*A*C;
    if D = 0 then
        Put("x = ");
        Put(-Bf/A2f);
    elsif D > 0 then
        S := Ada.Numerics.Elementary_Functions.Sqrt(Float(D));
        Put("x1 = ");
        Put((-Bf+S)/A2f);
        Put_Line("");
        Put("x2 = ");
        Put((-Bf-S)/A2f);
    else
        Dc := Compose_From_Cartesian (Re => Float(D), Im => 0.0);
        Put("x1 = ");
        Put((-Bf+Complex_Functions.Sqrt(Dc))/A2f);
        Put_Line("");
        Put("x2 = ");
        Put((-Bf-Complex_Functions.Sqrt(Dc))/A2f);
    end if;
end QuadraticEquation;

CamelCase:

Пример для версий gnat 3.4.5
with Ada.Text_IO,
     Ada.Characters.Handling; 
 use Ada.Text_IO,
     Ada.Characters.Handling;

procedure CamelCase is
   Text: String(1..100);
   Length: Natural;
   Was_Space: Boolean := True;
   I: Integer := 1;
begin
   Get_Line(Text, Length);
   Text := To_Lower(Text);
   loop
      if Character'Pos(Text(I)) > 96 and Character'Pos(Text(I)) < 123 then
         if Was_Space then
            Put(To_Upper(Text(I)));
         else
            Put(Text(I));
         end if;
         Was_Space := False;
      else
         Was_Space := True;
      end if;
      I := I + 1; 
      exit when I > Length;
   end loop;
end;

Комментарии

]]>

blog comments powered by Disqus

]]>

Работа программистам