Редактирование: Сравнение Языков Программирования

ЯП из курса: C, C++, Java, C#, Pascal, Delphi, Оберон-2, Модула-2, Ада (83 и 95 стандарты).

* [[w:Сравнение языков программирования|Сравнение ЯП в википедии]]

* [http://progopedia.ru/ Энциклопедия языков программирования]

* [http://citforum.ru/programming/cpp/aglav.shtml Книжка Страуструпа]

* [https://habrahabr.ru/post/161205/ Ликбез по типизации в языках программирования / Хабрахабр]

План (краткий, взят из методички Головина, подробный см. в самой [[Media:pl.exam.variants.pdf|методичке]]):

== Базисные типы данных в языках программирования: простые и составные типы данных, операции над ними ==

; Character: Как я понял, существует несколько разновидностей (зависит от размера) и является особым перечислимым типом (Enumeration)

; Floating point: Эти типы обычно определяются вручную в виде конструкции, где Num_Digits указывает максимальную погрешность:

 

A1 := '''new''' Entity;

A1 := '''new''' Entity; ''-- Образовался мусор''

A2 := A1;

Free_Entity (A1); ''-- A1 теперь '''null''' ''

 

 

 

 

 

 

 

Кроме того типы указателей различаются уровнями доступа (read-only и read-write):

 

 

 

=== ОБЕРОН и ОБЕРОН-2 ===

 

: + объединение

: - разность (x - y = x * (-y))

: * пересечение

: / симметрическая разность множеств (x / y = (x-y) + (y-x))

=, # (неравенство), <, <=, >, >=, IN (принадлежность множеству), IS (проверка типа)

=== Modula-2 ===

Битовое множество BITSET (Величина может зависеть от реализации. Например, 32 бита) <br>

Плавающая точка: REAL LONGREAL (Подчиняются IEEE, но зависят от реализации. К примеру, возможно REAL = LONGREAL = double) <br>

 

 

 

 

 

 

 

 

 

 

 

'''const''' <тип> <имя_переменной> = <значение>;

// Значение переменной не может изменяться после инициализации (инициализация обязательна).

 

 

 

 

 

 

 

: 8. decimal - 128-битный точный дробный или целочисленный, который может представлять десятичные числа с 29 значащими цифрами.

 

 

: 1. Структура не может быть явно унаследована ни от какого класса или структуры, при этом все структуры неявно наследуют object.

 

: Структуры (struct).

;Ссылочные типы<ref>Иногда говорят «референциальные типы», здесь использован вариант перевода из msdn.</ref> (значения, на которые указывает ссылочный тип (в частности, экземпляры классов), располагаются в куче):

: Класс.

: Массив (является объектом, экземпляром абстрактного класса Array).

: Интерфейс.

: И некоторые другие.

== Массивы ==

=== Длина массива — статический или динамический атрибут ===

'''Си++''': длина массива - только статический атрибут. <br>

'''Оберон''', '''Модула-2''': динамический атрибут только для формальных параметров, в остальных случаях - статический. <br>

'''Ада''', '''Java''', '''C#''': может быть и тем и другим. <br>

<br>

'''Замечание из методички''': <br>

в языках Оберон и Модула-2 длина формальных параметров — открытых массивов является динамическим атрибутом. <br>

В других случаях длина массива — статический атрибут. <br>

В Аде формальные параметры неограниченных типов-массивов также имеют динамический атрибут-длину (равно как и динамические массивы-локальные переменные). <br>

<br>

'''Пример''' динамического массива в языке Java (или C#):

void f(int N) {

byte [] dynArray = new byte [N];

// ...обработка ...

}

Массивы, объявленные без указания длины, называются открытыми массивами. Они могут использоваться только в качестве базового типа указателя, типа элементов открытых массивов и типа формального параметра.

 

 

 

 

 

 

 

Ада, C, C++, C#, Delphi, Оберон, Модула

В Modula-2 можно объявлять указатель на что угодно. При том как на переменные в динамической памяти, так и в статической.

Есть адресная арифметика (ADDADR, SUBADR, DIFADR), преобразование типов указателей (CAST), разыменование (^), функция взятия адреса (ADR), аллокация и деаллокация (NEW-DISPOSE или ALLOCATE-DEALLOCATE - два варианта), размер типа в байтах (TSIZE) и NIL. В случае получения невалидного адреса, разыменования NIL и т.п. выдаётся ошибка.

TYPE

TreePtr = POINTER TO TreeGlue;

TreeGlue = RECORD

key : KeyType;

left : TreePtr; (* left child *)

right : TreePtr; (* right child *)

END;

== Преобразование типов ==

=== Явное преобразование типов ===

Преобразование типов называется ''явным,'' если оно указано программистом в исходном коде.

=== Неявное преобразование типов ===

Преобразование типов называется ''неявным'', если оно не указывается программистом, но, тем не менее, выполняется (в языках со статической типизацией — соответствующие конструкции подставляются на этапе компиляции). В языках '''C'''<ref>Если не считать (T *) → (void *).</ref>, '''C#''', '''Java''', '''Pascal''', '''Delphi''', '''Modula-2''', '''Оберон''', '''Оберон-2''' неявными могут быть только расширяющие преобразования (иначе говоря, преобразования, к более общему типу<ref>Следует иметь ввиду, что в случае простых типов не всегда более общий тип может отобразить менее общий. К примеру, вещественный тип single стандарта IEEE 754 не может точно представить число 16777217, в то время как 32-битный целочисленный тип может.</ref>); в '''С++''' — любые преобразования. В языке '''Ада''' неявных преобразований почти<ref>Исключение составляет, например, неявное приведение числового литерала к конкретному типу. Подробнее: [http://www.adaic.org/resources/add_content/standards/05rm/html/RM-4-6.html#I2822].</ref> нет.

==== Неявное преобразование для пользовательских классов ====

Язык Java запрещает любые неявные преобразования между объектами классов (исключение составляют только неявные преобразования к стандартному типу String, разрешенные в некоторых

контекстах).

Языки C++ и C# разрешают неявные преобразования для классов, определяемых пользователем.

В '''C++''' преобразования определяются специальными функциями-членами: конструкторами преобразования и функциями преобразования. Конструктор преобразования имеет прототип вида:

Х(Т) // или Х(Т&) или X (const Т&)

Функция преобразования имеет вид:

class X {

operator Т();

};

В языке '''C#''' область применения пользовательских преобразований уже, чем в языке C++. Можно

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

static operator Y (X х) { ... }

Функция преобразования может быть только статическим методом либо класса х, либо класса Y. Если такая функция преобразования есть, то она вызывается с использованием обычного синтаксиса преобразований: (Y) х. Компилятор вставляет неявное преобразование из X в Y только, если соответствующая функция преобразования снабжена модификатором implicit:

static implicit operator Y (X x) { ... }

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

ошибки.

В '''Delphi''' есть неявное преобразование типов, работает для функций. Пример (не работает для Writeln, потому что это не функция, а конструкция языка):

program Overloads;

{$APPTYPE CONSOLE}

type

TRec = record

private

function GetOrd: Integer;

public

class operator Implicit(const Value: TRec): Integer;

property ord: Integer read GetOrd;

end;

class operator TRec.Implicit(const Value: TRec): Integer;

begin

Result := 0;

end;

function TRec.GetOrd: Integer;

begin

Result := 0;

end;

procedure Foo(i: Integer);

begin

end;

var

R: TRec;

a: array[0..0] of Integer;

begin

Writeln(R);//E2054 Illegal type in Write/Writeln statement

Writeln(Integer(R));//explicit cast, provided by class operator Implicit

Writeln(R.ord);//my preferred option, a property

a[R] := 0;//E2010 Incompatible types: 'Integer' and 'TRec'

a[Integer(R)] := 0;//again, explicit cast is fine

a[R.ord] := 0;//or using a property

Foo(R);//implicit cast used for actual parameters

end.

=== Понятия ''conversion'' и ''casting'' ===

В большинстве языков, основанных на базе '''Algol''' и обладающих механизмом вложенных функций - например, в '''Ada, Delphi, Modula 2''' и '''Pascal,''' понятия ''conversion'' и ''casting'' принципиально различны. Понятие ''conversion'' относится к явному или неявному изменению значения одного типа данных на значение другого типа данных (например, расширение 16-битного целого до 32-битного). В этом случае, могут измениться требования к объёму выделенной памяти; могут возникнуть потери точности или округления. Понятие ''casting,'' напротив, обозначает ''явное'' изменение интерпретации ''последовательности бит.'' Например, последовательность из 32 бит может быть интерпретирована как целое без знака, как массив из 32 значений типа boolean или как вещественное число c одинарной точностью, соответствующее стандарту IEEE.

В '''C-подобных''' языках, понятием ''casting'' обозначается явное приведение типа в независимости от того, является ли оно изменением интерпретации последовательности бит, либо же настоящим преобразованием типа.

=== Упаковка и распаковка ===

Данные понятия определены для языков '''C#''' и '''Java.'''

: ''Упаковкой (boxing)'' называется процесс преобразования значения простого типа значения в экземпляр соответствующего класса-оболочки.

: ''Распаковкой (unboxing)'' называется, очевидно, процесс преобразования экземпляра класса-оболочки в значение соответствующего простого типа.

==== C# ====

В '''C#''' упаковка и распаковка выполняются автоматически.

Пример упаковки и распаковки:

int i = 123;

// The following line boxes i.

object o = i;

o = 123;

i = (int) o; // unboxing

==== Java ====

В '''Java''' автоупаковка и автораспаковка поддерживаются начиная с J2SE 5.0 (сентябрь 2004 года).

Пример упаковки и распаковки:

int i = 123;

Integer boxedI = Integer.valueOf(i); // boxing

Integer boxedI = Integer.valueOf(123);

int i = boxedI.intValue(); // unboxing

==== Другие языки ====

В некоторых языках упаковка и распаковка отсутствуют. Например, в '''Smalltalk''' любое значение принадлежит некоторому классу (т.е. даже значения простых типов являются экземплярами классов).

В JavaScript ситуация несколько иная. Например, есть примитивный тип ''Number'' для чисел. В отличие от Java и C#, это тип является полноценным (к объектам этого типа можно применить операцию <code>typeof</code>). Однако при вызове методов примитивный тип упаковывается в объект, прототипом которого является <code>Number.prototype</code> (это не тот же самый ''Number''-примитивный тип!), и в котором уже определены нужные методы. Пример кода, который это демонстрирует:

<pre>

Number.prototype.test = function() { return this; }

var x = 5;

alert(x + " " + typeof x);

x = x.test();

alert(x + " " + typeof x);

</pre>

=== ADA ===

Примечание: в отличие от нижеследующих языков (таких как Pascal / Delphi и Modula-2), в ADA конструкция '''with''' не входит в операторный базис, а служит для подключения пакетов; см. [[#anchor_ada_with|раздел 7]].

'''if''' condition '''then'''

statement;

'''elseif''' enother_condition '''then'''

enother_statement;

'''...'''

'''else'''

last_one_statement;

'''end if''';

'''case''' X '''is'''

'''when''' constant1 =>

stetement1;

'''when''' constant2 | constant3 =>

statement2_and3;

...

'''when''' '''others''' =>

other_statement;

'''end''' '''case''';

'''return'''; ''-- for procedures''

'''return Value'''; ''-- for functions''

'''goto''' Label

Dont_Do_Smth;

'''<nowiki><<</nowiki>'''Label'''<nowiki>>></nowiki>'''

Циклы устроены посложнее:

Endless_Loop :

'''loop'''

Do_Something;

'''end''' '''loop''' Endless_Loop;

While_Loop :

'''while''' X <= 5 '''loop'''

X := Calculate_Something;

'''end''' '''loop''' While_Loop;

Until_Loop :

'''loop'''

X := Calculate_Something;

'''exit''' Until_Loop '''when''' X > 5;

'''end''' '''loop''' Until_Loop;

Exit_Loop :

'''loop'''

X := Calculate_Something;

'''exit''' Exit_Loop '''when''' X > 5;

Do_Something (X);

'''end''' '''loop''' Exit_Loop;

For_Loop :

'''for''' I '''in''' Integer '''range''' 1 .. 10 '''loop'''

Do_Something (I)

'''end''' '''loop''' For_Loop;

''(Замечание: именовать циклы необязательно.)''

=== ОБЕРОН И ОБЕРОН-2 ===

Операторы в последовательности операторов идут через точку с запятой. В конце последовательности должна стоять точка.

Пайп-символы «|» — это обязательная деталь конструкций CASE и WITH (они разделяют альтернативные варианты, за исключением умолчательного, задаваемого после ключевого слова ELSE).

IF Выражение THEN ПоследовательностьОператоров

{ELSIF Выражение THEN ПоследовательностьОператоров}

[ELSE ПоследовательностьОператоров]

END.

CASE ch OF

"A" .. "Z": ReadIdentifier |

"0" .. "9": ReadNumber |

"'", '"': ReadString

ELSE SpecialCharacter

END.

WHILE Выражение DO

ПоследовательностьОператоров

END.

REPEAT

ПоследовательностьОператоров

UNTIL Выражение.

FOR v := начало TO конец BY шаг DO

ПоследовательностьОператоров

END.

''(* Присутствует только в Оберон-2 *)''

LOOP

ПоследовательностьОператоров

END.

''(* Вечный цикл; для выхода используется ключевое слово EXIT *)''

WITH

Дискриминант: Значение1 DO ПоследовательностьОператоров1 |

Дискриминант: Значение2 DO ПоследовательностьОператоров2

ELSE ПоследовательностьОператоров3

END.

''(* Является подобием оператора CASE-OF по дискриминанту''

'' размеченного объединения; присутствует только в Оберон-2 *)''

=== Modula-2 ===

Полностью совпадает с Обероном-2, за исключением WITH, определяемого так:

WITH ПеременнаяСтруктурногоТипа DO

ПоследовательностьОператоров

Поле1:= Значение1;

ПоследовательностьОператоров

Поле2:= Значение2;

…

END.

''(* Поле1, Поле2, итд. — поля переменной «ПеременнаяСтруктурногоТипа»;''

'' конструкция с аналогичным поведением есть в Pascal и Delphi *)''

=== Pascal и Delphi ===

'''if''' condition1 '''then begin'''

statement1;

statement2;

…

'''end''' ''{ заметьте, точки с запятой нет }''

'''else if''' condition2 '''then begin'''

…

'''end'''

'''else begin'''

…

'''end'''; ''{ if-блок закончен, точка с запятой есть }''

'''case''' value1 '''of'''

constant1: '''begin'''

statement1;

statement2;

…

'''end''';

constant2: '''begin'''

…

'''end''';

…

'''else begin'''

…

'''end''';

'''end''';

'''goto''' label1; ''{ да, в стандарте Паскаля это было }''

never_executed_statement1;

never_executed_statement2;

…

label1:

'''for''' variable1 := constant1 '''to''' constant2 '''do begin'''

statement1;

statement2;

…

'''end'''; ''{ если constant1 > constant2, используется '''downto''' }''

'''while''' continuation '''do begin'''

statement1;

statement2;

…

'''end''';

'''repeat'''

statement1;

statement2;

…

'''until''' discontinuation;

''{ здесь, discontinuation означает условие останова, а не''

'' продолжения (как, например, в цикле предыдущего типа);''

'' также заметьте, что скобки '''begin''' / '''end''' тут не нужны }''

'''with''' struct1.substruct1.subsubstruct1 '''do begin'''

field1 = value1;

field2 = value2;

…

'''end;'''

''{ field1 и field2 — это поля структуры struct1.substruct1.subsubstruct1;''

'' в этом блоке они перекрывают собой любые переменные с теми же именами }''

=== C и C++ ===

if (condition1) {

statement1;

statement2;

…

}

else if (condition2) {

…

}

else {

…

}

return; ''// возврат из void-функции''

return value1; ''// возврат из функции, отдающей значение''

switch (value1) {

case constant1:

statement1;

statement2;

…

break;

case constant2:

…

break;

…

default:

…

break;

}

''// также вместо break можно использовать return (выходим не только из switch-блока, но и из функции).''

goto label1;

never_executed_statement1;

never_executed_statement2;

…

label1:

for (initializer; continuation; increment) {

statement1;

statement2;

…

}

''// любые из трёх выражений в заголовке цикла могут пустовать.''

''// например, for ( ; ; ) {} даст вечный цикл.''

do {

statement1;

statement2;

…

} while (continuation);

while (continuation) {

statement1;

statement2;

…

}

=== for в C# и Java ===

В '''Java''' используется 2 формы оператора цикла for.

Первая форма полностью соответствует оператору for языка Си++:

for (e1; e2; e3) S

Вторая форма появилась в J2SE 5.0 (вместе с generic'ами) и используется для поэлементного

просмотра коллекций (цикл for-each). Она имеет вид;

for (T v: Coll) S

Здесь Coll — коллекция элементов (типа T или приводимых к типу T).

Переменная v на каждой итерации цикла принимает значение очередного

элемента коллекции.

Для того, чтобы объекты класса-коллекции могли появляться в цикле

for-each, класс должен реализовать интерфейс Iterable.

Для того, чтобы for можно было аналогичным образом использовать в '''C#''', коллекция должна реализовывать интерфейс IEnumerable (конкретно метод GetEnumerator)

// метод класса, который мы хотим сделать итеративным

public System.Collections.IEnumerator GetEnumerator()

{

for (int i = 0; i < 10; i++)

{

yield return i;

}

}

Здесь yield преобразует int в объект класса IEnumerator. Кроме того, внутреннее состояние функции запоминается и в следующий раз выполнение функции будет продолжено с того состояния и места, где функция вышла в прошлый раз. yield может вызываться только в теле for.

=== Передача параметров в подпрограммы ===

Для каждой подпрограммы указывается набор формальных параметров. Можно рассматривать формальные параметры как локальные переменные тела подпрограммы. При вызове подпрограммы указывается список фактических параметров. Соответствие между фактическими и формальными параметрами выполняется по позиции в списке: первый фактический параметр соответствует первому формальному параметру и т. д. Такой способ называется ''позиционным''. Язык С#, начиная с версии 4, предусматривает альтернативный — ''ключевой'' способ отождествления, в котором используются имена формальных параметров, но мы не будем его рассматривать. Существует три вида формальных параметров:

* входные параметры (параметры, от которых требуется только значение). Мы используем только значения фактических параметров, которые не меняются при выходе из тела функции;

* выходные параметры (эти параметры не обязаны иметь начальное значение, но могут быть изменены в теле функции);

* изменяемые параметры (требуется и исходное значение, и возможность его изменения).

С входным параметром может связываться произвольное выражение, а выходным или изменяемым — только объекты, которые могут стоять в левой части оператора присваивания. В большинстве языков программирования вместо указания вида параметра указывается способ (механизм) связывания параметра, называемый способом передачи параметра.

Существует два основных способа передачи параметров: ''по значению'' и ''по ссылке''.

==== Передача параметров по значению ====

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

==== Передача параметров по ссылке ====

Фактически этот способ есть передача ссылки по значению. Формальный параметр — это ссылка на объект. (Существует мнение, что данное «определение» не только не отражает сути явления, но и неверно в корне. В дискуссии вокруг передачи аргументов в Java Dale King [http://www.yoda.arachsys.com/java/passing.html дал] следующее определение. ''Передача по ссылке — это когда lvalue формального параметра устанавливается в lvalue фактического параметра.'') В момент вызова происходит инициализация ссылки фактическим параметром. Преобразования типов в этот момент не происходит: типы формального и фактического параметров должны совпадать. Поскольку ссылка после инициализации отождествляется с объектом, то любые изменения формального параметра подразумевают изменения фактического параметра. Очевидно, что способ передачи по значению соответствует семантике входных формальных параметров. По ссылке можно передавать выходные и изменяемые параметры.

==== Аргументы в C/C++ всегда передаются по значению ====

В C++ есть ссылочный тип. Переменная ссылочного типа может ссылаться на значение любого типа, должна быть инициализирована и не может менять значения. С помощью передачи переменной ссылочного типа можно имитировать все возможности контрукции var из '''Pascal'''. Но можно действовать в стиле C — передавать указатель. В свою очередь, чтобы менять указатель, можно передавать в функцию/метод указатель или ссылку на него.

==== Аргументы в Java всегда передаются по значению ====

Существует распространённое '''заблуждение''' о том, что «объекты передаются по ссылке, а примитивные типы — по значению».

'''На самом деле''' ситуация иная:

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

# Значения переменных всегда примитивы или ссылки (или null), но никак не объекты.

Подробнее см. http://www.yoda.arachsys.com/java/passing.html .

В соответствии с изложенным выше, метод может изменить объект через аргумент-ссылку. С примитивным типом это не пройдёт, так как в Java нет ссылок на значения примитивных типов. Чтобы иметь возможность изменить из метода значение некоторой внешней переменной примитивного типа, нужно чтобы эта переменная была полем некоторого объекта.

В связи с этим для примитивных типов были введены классы-обёртки. Объект такого класса содержит в себе значение примитивного типа, которое можно как прочитать, так и поменять. См. также [[Сравнение_Языков_Программирования#.D0.A3.D0.BF.D0.B0.D0.BA.D0.BE.D0.B2.D0.BA.D0.B0_.D0.B8_.D1.80.D0.B0.D1.81.D0.BF.D0.B0.D0.BA.D0.BE.D0.B2.D0.BA.D0.B0|Упаковка и распаковка]]

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

 

Пример на языке C++:

void f(int)

Отличие перегрузки от замещения (скрытие, англ. hide) состоит во-первых, в том, что перегрузка обрабатывается статически (на этапе трансляции) (а замещение?), в во-вторых, при замещении речь идет о разных областях видимости: базовый класс с объявлением виртуального метода (объемлющая область видимости) и производный класс с замещающим методом (вложенная область видимости).

 

 

 

 

 

 

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

<div id="anchor_ada_with"></div>О подключениях. Подключить пакет можно с помощью конструкции '''with'''.

 

=== Modula-2 ===

Говорят, что тип Т1 совместим с типом Т0, если либо он описан как Т1 = Т0, либо как диапазон Т0, либо если Т0 является диапазоном Т1, либо если и Т0, и Т1 - оба диапазоны одного и того же (базового) типа.

 

 

 

 

 

Обычно выделяют следующие типы конструкторов: конструктор по умолчанию, конструктор копирования и конструктор преобразования. Конструкторы имеют пользовательскую (тело объявленного конструктора) и системную (сгенерированный код) части.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Размеченное объединение типов содержит одно выделенное поле (дискретного типа данных) — общее для всех вариантов. Такое поле называется дискриминантом. Значение дискриминанта определяет, по какому варианту выделена память в переменной-экземпляре размеченного объединения.

 

=== Семантика копирования ===

 

 

 

 

 

 

 

====ОБЕРОН И ОБЕРОН-2====

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

==== Modula-2 ====

Программа представляет собой набор модулей — самостоятельных единиц компиляции, которые могут компилироваться раздельно. При этом программный модуль может быть (но не обязан) разделён на две части: модуль определений и модуль реализации. Модуль определений — это внешний интерфейс модуля, то есть набор экспортируемых им имён констант, переменных, типов, заголовков процедур и функций, которые доступны внешним модулям. Модуль реализации содержит программный код, в частности, конкретизацию описаний всего, что перечислено в модуле определений. Например, некоторый тип «запись» может быть объявлен в модуле определений с указанием лишь его имени, а в модуле реализации — с полной структурой. В этом случае внешние модули могут создавать значения данного типа, вызывать процедуры и функции, работающие с ним, выполнять присваивание переменных, но не имеют прямого доступа к структуре значений, поскольку эта структура не описана в модуле определений. Если для этого же типа описать в модуле определений структуру, то она станет доступна. Помимо модулей глобального уровня в Модуле-2 допускается создавать локальные модули. <br>

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

DEFINITION MODULE ModuleName; (* Модуль определений *)

{Import}

{Declaration}

END ModuleName.

========================

Где Import это:

[FROM ModuleName] IMPORT

identifier {,identifier};

IMPLEMENTATION MODULE ModName; (* Модуль реализаций *)

{Import}

{Declaration}

[ BEGIN

ListOfStatements

[EXCEPT

ListOfStatements]

[

FINALLY

ListOfStatements

EXCEPT

ListOfStatements

]

]

END ModName.

MODULE ModName; (* Должен существовать единственный на весь проект. Это main. *)

{Import}

{Declaration}

BEGIN

ListOfStatements

[EXCEPT

ListOfStatements]

END ModName.

Для обеспечения видимости в других модулях объявления функций, переменных и типов, описанные в модулях определений, можно импортировать. Остановимся на типах. При импортировании их внутренняя структура становится видна импортирующему модулю (т.н. прозрачный экспорт). Существует скрытый экспорт (opaque export), где видно становится только имя типа. Он возможен только для указательного типа (но сделаем указатель на структуру - и вуаля, получим инкапсуляцию и абстракцию данных).

=== ADA ===

Ада, наверное - единственный язык со вложенностью модулей, их раздельной компиляцией и двойной связью одновременно.

Опишем вложенную спецификацию, тут ничего сложного:

'''package''' Outer '''is'''

'''...'''

'''procedure''' some_proc (X: Some_type) '''is private;'''

'''package''' Inner '''is'''

'''...''' ''-- Тут, в общем то видно все, что есть в пакете Outer.

'''end''' Inner;

'''...'''

'''end''' Outer;

Тела этих пакетов, как и тело функции, можно разнести по разным файлам (единицам компиляции), используя "заглушку" '''separate''':

'''package''' '''body''' Outer '''is'''

'''...'''

'''package''' Inner '''is''' '''separate''';

'''...'''

'''procedure''' some_proc (X: some_type) '''is''' '''separate''';

'''end''' Outer;

Теперь опишем тела модуля Inner и процедуры.

'''separate''' (Outer) ''--Тут нет `;' ''

'''package''' '''body''' Inner '''is'''

'''...'''

'''end''' Inner;

'''separate''' (Outer)

'''procedure''' some_proc (X: some_type) '''is'''

'''...'''

'''end''' some_proc;

Вот здесь заглушка '''separate''' и является двойной модульной связью.

; Зачечание

: Кроме перечисленных в итоговой таблице языков исключения поддерживает Visual Basic.

Моделирование семантики возобновления на C++:

bool need_restart = true;

while (need_restart) {

need_restart = false;

try {

// Some code here

} catch (...) {

// C# - просто catch, без круглых скобок

// Java - catch (Throwable e)

need_restart = true;

}

}

'''catch''' (в delphi - '''except''') - то что будет выполнено в случае ошибки в блоке try.

'''finally''' - то что будет выполнено в любом случае, вне зависимости от того что произошло в блоке try.

Конструкция '''try''' ... '''finally''' ... есть в C#, Java, Delphi. Декларируется, что в C++ в '''finally''' нет необходимости в виду RAII и, как следствие, выполнении деструкторов на выходе из блока.

=== throw (C++) и throws (Java) ===

Текст раздела построен с т.з. программиста Java (иначе говоря, обозначены отличия синтаксиса и семантики конструкции C++ от конструкции Java, а не наоборот). Причина — одно из заданий экзамена по ЯПам звучит примерно как «опишите конструкцию throws в Java (зачем нужно и как работает). Как моделируется на C++, Delphi<ref>Видимо, без использования «родных» аналогичных конструкций, нужно уточнить.</ref>?».

Примеры употребления конструкций:

// Java

void someMethod() throws IOException, SomeOtherException { … }

// IOException — стандартный класс исключения, наследник Exception.

// SomeException должен быть наследником Throwable.

void someMethod() { … }

// Запись «не выбрасывает исключения»: отсутствие throws и списка исключений.

// C++

void someMethod() throw (SomeException1, SomeException2) { … }

// SomeException1, SomeException2 — вообще говоря, любые типы.

// Декларациии throw должны совпадать как при определении, так и при описании.

void someMethod() throw () { … }

// Запись «не выбрасывает исключения»: throw ().

void someMethod() { … }

// Может выбрасывать любые исключения.

Данные конструкции служат для того, чтобы показать программисту и компилятору, что данный метод (или, в случае C++, метод или функция) может выбрасывать исключения соответствующих типов. Насколько [[Участник:Totktonada|я]] понимаю, всё это влияет только на статические проверки компилятора и эстетические чувства программиста. В runtime эти декларации никак себя не проявляют, поэтому употребляемые здесь «может / не может выбрасывать исключение данного типа» и тому подобные обороты следует понимать в контексте статических проверок. ''(Замечание: не совсем верно. Исключения могут возникнуть в виртуальной функции или в отдельно оттранслированной. Memento std::unexpected().)''

В Java считается, что метод, выбрасывающий исключение должен обозначить это с помощью конструкции throws. Иначе говоря, считается, что если директивы throws нет, то метод не выбрасывает исключений. Компилятор делает некоторые статические проверки, по крайней мере, запрещает выбрасывать исключения, не перечисленные в throws, явно — с помощью оператора throw.

В C++, в отличие от Java, если директива throw не задана, то считается, что данный метод или функция может выбрасывать любые исключения. Статические (времени компиляции) проверки делаются только для тех методов/функций, для которых указан (возможно пустой) список исключений.

=== Одно из заданий экзамена по ЯПам ===

2004 г, задание 8. Смоделируйте на языке Си++ функцию

void f() throw (E1,E2,E3) { g(); h(); }

предполагая, что конструкция throw<ref>Видимо, подразумевается конструкция throw (…) в заголовке метода/функции, а не выбрасывание (или повторное выбрасывание) исключения с помощью оператора throw.</ref> не допускается компилятором.

void f()

{

try {

g(); h();

} catch (E1) {

throw;

} catch (E2) {

throw;

} catch (E3) {

throw;

} catch (...) {

unexpected();

}

}

=== ADA ===

Создание исключения:

New_Exception: '''exception''';

Поднятие/возбуждение исключения<ref>Терминология отличается от принятой в мире языков с C++-подобным синтаксисом. Там: выбрасывание/выброс (throw), здесь — поднятие/возбуждение (raise).</ref>:

'''raise''' New_Exception;

Отлов исключения:

'''begin'''

Rise_Exception;

'''exception'''

'''when''' New_Exception =>

Do_Smth;

'''end''';

Отлов исключения так же может иметь такой вид:

'''when''' Error: Error_Name =>

Однако, что он означает я до конца не понял, но на экзамене это вряд ли нужно будет. Кому интересно, брал [http://en.wikibooks.org/wiki/Ada_Programming/Exceptions здесь.]

=== C# и Java ===

В C# и Java можно в дочернем классе сослаться на экземпляр родительского с помощью ключевых слов '''base''' (C#) и '''super''' (Java).

Кроме того, в этих языках есть ключевые слова '''sealed''' (C#) и '''final''' (Java). Они могут находиться в заголовке<ref>Вероятно, только перед определением типа.</ref> метода (в случае C# — только виртуального) или класса ('''final''' также может находиться в описании поля, но это «другая песня»).

В C# '''sealed''' в заголовке виртуального метода означает запрет перегрузки (англ. override) метода в производных классах. В заголовке класса — запрет наследования от данного класса.

В Java '''final''' в заголовке метода означает, запрет замещения (скрытия, англ. hide) или перегрузки (англ. override) метода в производных классах. В заголовке класса — запрет наследования от данного класса.

=== ADA ===

Наследование в Аде происходит путем создания нового пакета и расширения в нем базовой записи:

'''package''' Person '''is'''

'''type''' Object '''is''' '''tagged''' '''private''';

'''procedure''' Put (O : Object);

'''private'''

'''type''' Object '''is'''

'''record'''

Name : String (1 .. 10);

Gender : Gender_Type;

'''end record''';

'''end Person''';

'''with''' Person;

'''package''' Programmer '''is'''

'''type''' Object '''is new''' Person.Object '''with private''';

'''private'''

'''type''' Object '''is'''

'''record'''

abuility : Language_List;

'''end record''';

'''end Person''';

ООП в Аде является вполне полноценным c Динамическим полиморфизмом, [http://esyr.org/wiki/%D0%A1%D1%80%D0%B0%D0%B2%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5_%D0%AF%D0%B7%D1%8B%D0%BA%D0%BE%D0%B2_%D0%9F%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F#ADA_8 RTTI], абстрактными типами и интерфейсами.

В объектно-ориентированных языках программирования динамический полиморфизм реализуется с помощью наследования классов и виртуальных функций и/или виртуальных членов. Класс-потомок наследует сигнатуры методов класса-родителя, а реализация, в результате переопределения метода, этих методов может быть другой, соответствующей специфике класса-потомка. Другие функции могут работать с объектом как с экземпляром класса-родителя, но если при этом объект на самом деле является экземпляром класса-потомка, то во время исполнения будет вызван метод, переопределенный в классе-потомке. Это называется поздним связыванием.

Позднее связывание есть в C++, C#, Java, Delphi, Ада 95, Оберон-2.