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

ЯП из курса: 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|методичке]]):

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

 

 

 

 

 

 

 

 

 

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

*** Беззнаковый 16-битный: char (код символа в UTF-16<ref>Была правка UTF-16 → Unicode. Откатил. Пояснил на странице обсуждения.</ref>).

Объектом в Java считается экземпляр класса или массив. Значением ссылочного типа является ссылка на объект (или специальное значение null). Значение переменной ссылочного типа можно изменить, в отличии от C++.

 

Все объекты (включая массивы) обладают методами класса Object (java.lang.Object) (иначе говоря, с т. з. Java-программиста все объекты *наследуют* методы класса Object). Строковые литералы (например, "Hello world!") являются объектами типа String (иначе говоря, экземплярами класса String).

=== C++ ===

; Целые типы:

: char - размер как для хранения символа, определяется машиной (обычно байт)

: short - размер, соответствующий целой арифметике на данной машине (обычно, слово)

: int

: long

: long long

Для всех целых типов есть unsigned аналоги. По умолчанию - знаковые (так что, например, signed int - то же самое, что int).

Исключение - char. Его знаковость/беззнаковость зависит от реализации.

; С плавающей точкой:

: float

: double

: long double

1 = sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long)<br>

sizeof(float) <= sizeof(double) <= sizeof(long double)

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

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

; Aрифметические операции:

: + (плюс, унарный и бинарный)

: - (минус, унарный и бинарный)

: * (умножение)

: / (деление)

: Над целыми - операция % получения остатка: 7%2 = 1

; Операции сравнения:

: == (равно)

: != (не равно)

: <, >, <=, >=

Также логические операции ( &&, || ), побитовые операции(&, |, ^, <<, >>), а так же сокращённые формы многих операций: +=, -=, %=, &&=, ||=, &=, ++, -- (последние два имеют префиксные и постфиксные формы) и им подобные.

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

; Производные типы:

: * - указатель на

: *const - константный указатель на

: & - ссылка на

: [] - вектор (одномерный массив), индексация с 0

: () - функция, возвращающая

: Унарное & - операция взятия адреса

Например:<br>

char* p // указатель на символ<br>

char *const q // константный указатель на символ<br>

char v[10] // вектор из 10 символов<br>

char c; p = &c; // p указывает на c

; Встроенные типы:

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

;Типы значений (хранятся на стеке, если не являются полем класса):

: Все базовые, кроме object и string.

 

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

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

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

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

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

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

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

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

void f(int N) {

byte [] dynArray = new byte [N];

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

}

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

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

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

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

Преобразование типов называется ''неявным'', если оно не указывается программистом, но, тем не менее, выполняется (в языках со статической типизацией — соответствующие конструкции подставляются на этапе компиляции). В языках '''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>

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

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

 

"A" .. "Z": ReadIdentifier |

"0" .. "9": ReadNumber |

"'", '"': ReadString

END.

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

END.

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

LOOP

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

END.

WITH

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

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

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

END.

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

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

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

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

 

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

Для каждой подпрограммы указывается набор формальных параметров. Можно рассматривать формальные параметры как локальные переменные тела подпрограммы. При вызове подпрограммы указывается список фактических параметров. Соответствие между фактическими и формальными параметрами выполняется по позиции в списке: первый фактический параметр соответствует первому формальному параметру и т. д. Такой способ называется ''позиционным''. Язык С#, начиная с версии 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) состоит во-первых, в том, что перегрузка обрабатывается статически (на этапе трансляции) (а замещение?), в во-вторых, при замещении речь идет о разных областях видимости: базовый класс с объявлением виртуального метода (объемлющая область видимости) и производный класс с замещающим методом (вложенная область видимости).

PROCEDURE log2 (x: INTEGER): INTEGER;

VAR y: INTEGER; (*предполагается x>0*)

BEGIN

y := 0; WHILE x > 1 DO x := x DIV 2; INC(y) END;

RETURN y

END log2

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

=== Namespace в C# ===

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

namespace SampleNamespace

{

class SampleClass { }

interface SampleInterface { }

struct SampleStruct { }

enum SampleEnum { a, b }

delegate void SampleDelegate(int i);

namespace SampleNamespace.Nested

{

class SampleClass2 { }

}

}

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

 

 

 

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

* Запрет копирования объекта: определить конструктор копирования в приватной части класса.

* Запрет создания экземпляровобъекта — глобальных и локальных переменных, иначе говоря данные запрещено размещать в секциях .data/.bss и на стеке, разрешено только в динамической памяти. Нужно определить декструктор в приватной части класса. Освобождение ресурсов объекта при таком подходе осуществляется через метод данного класса.

* Запрет присваивания одного объекта другому: определение операции присваивания в приватную часть класса.

* Запрет неявного вызова конструктора копирования, конструктора преобразования (иначе говоря, конструкторов с одним параметром) или операции преобразования (последнее — только в C++11). Нужно добавить в начало заголовка ключевое слово explicit.

==== Статические классы ====

 

''Статический класс'' — это, в общем случае, достаточно неформальное понятие. Обычно так называют класс, все члены которого объявлены статическими. Для работы с таким классом не требуется создавать экземпляр и часто, говоря о статическом классе, подразумевают невозможность создания экземпляра. Такой класс, как правило, не имеет конструкторов и деструкторов, либо они объявлены приватными (в зависимости от языка).<ref>Стоит уточнить, что статический класс в C# может иметь статический конструктор, см. далее раздел про C#.</ref>

 

 

 

===== В C++ =====

 

 

===== В Java =====

 

 

 

 

 

 

 

 

 

* http://stackoverflow.com/questions/3584113/java-static-class

 

===== В C# =====

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

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

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

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

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

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();

}

}

=== C# и Java ===

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

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

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

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

ООП в Аде является вполне полноценным 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#''' к динамическому полиморфизму имеют отношение 3 важных ключевых слова (модификатора):

: 1. '''virtual'''

: 2. '''override'''

: 3. '''new'''

==== virtual ====

Ключевое слово '''virtual''' используется для изменения объявлений методов, свойств, индексаторов и событий и разрешения их переопределения в производном классе. Например, этот метод может быть переопределен любым производным классом. Модификатор '''virtual''' нельзя использовать с модификаторами '''static, abstract, private''' или '''override.'''

public virtual double Area()

{

return x * y;

}

==== override ====

Модификатор '''override''' требуется для расширения или изменения абстрактной или виртуальной реализации унаследованного метода, свойства, индексатора или события. Иными словами, модификатор '''override''' ''расширяет'' метод базового класса. Метод, переопределенный c использованием '''override,''' называется переопределенным базовым методом. Переопределенный базовый метод должен иметь ту же сигнатуру, что и метод '''override.''' Невиртуальный или статический метод нельзя переопределить. Переопределенный базовый метод должен иметь тип '''virtual, abstract''' или '''override.''' Объявление '''override''' не может изменить уровень доступа метода '''virtual.''' Методы '''override''' и '''virtual''' должны иметь одинаковый модификатор уровня доступа.

Модификаторы '''new, static''' и '''virtual''' нельзя использовать для изменения метода '''override.'''

Переопределяющее объявление свойства должно задавать такие же модификаторы уровня доступа, тип и имя, как и имеющиеся у унаследованного свойства, а переопределенное свойство должно иметь тип '''virtual, abstract''' или '''override.'''

class BaseClass

{

public virtual void Method1()

{

Console.WriteLine("Base - Method1");

}

public void Method2()

{

Console.WriteLine("Base - Method2");

}

}

class DerivedClass : BaseClass

{

public override void Method1()

{

Console.WriteLine("Derived - Method1");

}

public void Method2()

{

Console.WriteLine("Derived - Method2");

}

}

// ...

BaseClass bc = new BaseClass();

DerivedClass dc = new DerivedClass();

BaseClass bcdc = new DerivedClass();

bc.Method1();

bc.Method2();

dc.Method1();

dc.Method2();

bcdc.Method1();

bcdc.Method2();

// Output:

// Base - Method1

// Base - Method2

// Derived - Method1

// Derived - Method2

// Derived - Method1

// Base - Method2

==== new ====

Модификатор '''new''' ''скрывает'' члены, унаследованные от базового класса. При сокрытии унаследованного члена его производная версия заменяет версию базового класса. (На самом деле, члены можно скрыть и без модификатора '''new,''' но в результате возникнет предупреждение. Если же для явного скрытия члена используется '''new,''' то модификатор отключает вывод предупреждений и документирует тот факт, что производная версия предназначена для замены.

class BaseClass

{

public void Method1()

{

Console.WriteLine("Base - Method1");

}

public void Method2()

{

Console.WriteLine("Base - Method2");

}

}

class DerivedClass : BaseClass

{

public override void Method1()

{

Console.WriteLine("Derived - Method1");

}

public new void Method2()

{

Console.WriteLine("Derived - Method2");

}

}

// ...

BaseClass bc = new BaseClass();

DerivedClass dc = new DerivedClass();

BaseClass bcdc = new DerivedClass();

bc.Method1();

bc.Method2();

dc.Method1();

dc.Method2();

bcdc.Method1();

bcdc.Method2();

// Output:

// Base - Method1

// Base - Method2

// Base - Method1

// Derived - Method2

// Base - Method1

// Base - Method2

Абстрактный тип данных (АТД) — это тип с полностью инкапсулированной структурой. Использовать объекты АТД возможно только при помощи явно определенных в интерфейсе типа операций. Абстрактный класс (АК) — это класс, содержащий хотя бы один абстрактный метод. Он предназначен только для того, чтобы быть базовым классом.

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

;В объектно-ориентированных языках программирования абстрактный класс реализуются следующими тремя способами

: 2. Класс содержит хотя бы один абстрактный метод. В C# и Java абстрактный метод обозначается модификатором abstract перед объявлением метода. В C++ абстрактные методы называются чистыми виртуальными. Примеры:

virtual void draw() = 0; // C++

: 3. Если в классе, производном от абстрактного класса с абстрактными методами, не замещен хотя бы один абстрактный метод, то класс тоже является абстрактным. В C# и Java незамещенные абстрактные методы должны быть явно объявлены как абстрактные.

В языке C# абстрактными могут быть и свойства:

Пример абстрактного класса ('''Java''' или '''C#'''):

abstract class ShapesClass

{

abstract public int Area();

}

Абстрактные методы (функции) есть в C++, Java, Delphi, C#, Ада 95.

=== Абстрактный тип данных ===

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

В Ада используется ключевое слово '''limited:'''

type Stack is limited private;

В ОБЕРОН И ОБЕРОН-2 АТД позволяют открывать поля структуры.

=== Пример абстрактного ТД и абстрактных функций в Ада95 ===

Мы продемонстрируем абстрактные классы, описывая несколько реализаций одной и той же абстракции; абстрактный класс будет определять структуру данных Set, и производный класс — реализовывать множество в виде булевого массива. В языке Ada 95 слово abstract обозначает абстрактный тип и абстрактные подпрограммы, связанные с этим типом:

'''package''' Set_Package '''is '''

'''type''' Set '''is abstract tagged null record''';

'''function''' Union(S1, S2: Set) '''return''' Set '''is abstract''';

'''function''' Intersection(S1, S2: Set) '''return''' Set '''is abstract''';

'''end''' Set_Package;

Вы не можете объявить объект абстрактного типа и не можете вызвать абстрактную подпрограмму. Тип служит только каркасом для порождения конкретных типов, а подпрограммы должны замещаться конкретными подпрограммами.

Рассмотрим производный тип, в котором множество представлено булевым массивом:

'''with''' Set_Package;

'''package''' Bit_Set_Package '''is'''

'''type''' Set '''is new''' Set_Package.Set '''with private''';

'''function''' Union(S1, S2: Set) '''return''' Set;

'''function''' lntersection(S1, S2: Set) '''return''' Set;

'''private'''

'''type''' Bit_Array is '''array'''(1..100) '''of''' Boolean;

'''type''' Set '''is new''' Set_Package.Set '''with'''

'''record'''

Data: Bit_Array;

'''end record''';

'''end''' Bit_Set_Package;

Конечно, необходимо тело пакета, чтобы реализовать операции.

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

Пример моделирования интерфейса на C++:

class Set {

==== Явная и неявная реализация интерфейса ====

Явная реализация интерфейса означает, что вызов метода

интерфейса может происходить только через ссылку на интерфейс, но не

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

вызовом интерфейсного метода необходимо явно преобразовать ссылку на

объект реализующего класса к ссылке на интерфейс. Концепция явной

реализации полезна, например, при конфликте имен между унаследованными

интерфейсами. Используется только в С#.

Явная реализация всегда статична, неявная же может быть виртуальной.

Неявная реализация может быть абстрактной и реализовываться только в

классе-потомке. Явная реализация не может быть абстрактной, но

сам класс может иметь другие абстрактные методы и сам быть абстрактным.

interface ISomeInterface

{

void F();

}

class CoClass: ISomeInterface

{

void ISomeInterface.F() { //в случае неявного интерфейса, здесь стояло бы public void F() {

System.Console.WriteLine(“Явно реализованный метод”);

}

// ...

}

// ...

CoClass c = new CoClass();

c.F(); // ошибка: нельзя вызывать явно реализованный метод

// интерфейса через ссылку на объект

((ISomeInterface)c).F(); // все нормально

Полностью реализовано только в C++. В Ada, C#, Delphi, Java множественное наследование поддерживается только для интерфейсов<ref>По крайней мере в контексте Java более корректно будет говорить не о наследовании ('''extends'''), а реализации ('''implements''') или частичной реализации интерфейса (последнее возможно только для абстрактных классов)</ref>.

=== ADA ===

В Аде для определения типа существует ключевое слово '''in''' работающее аналогично '''is''' в, скажем, Oberon-2.

После этого можно приводить типы, пользуясь мощным механизм конвертирования Ады (в аде вместо понятия приведения типов/type casting используется понятие конвертирование типов/type conversion):

Derived_Object: Derived := Derived (Base_Object) ''-- Здесь будет производится проверка в run-time''

Note to C++ programmers: generic units are similar to C++ templates.

 

=== C# ===

В C# используется конструкция where для определения

ограничений на параметры родовых (другое название - обобщенных)

конструкций.

Ее вид: where имя_типа : список_ограничений.

;Виды ограничений

: интерфейс — означает, что параметр-тип должен реализовывать этот интерфейс;

: имя класса (может быть только одно такое ограничение в списке) означает, что параметр-тип должен быть наследником этого класса;

: struct или class – означает, что параметр-тип должен быть структурой или классом;

: new() - означает, что параметр-тип должен иметь конструктор умолчания (без параметров).

Пример универсального шаблона (generic), реализующего односвязный список.

// type parameter T in angle brackets

public class GenericList<T>

{

// The nested class is also generic on T.

private class Node

{

// T used in non-generic constructor.

public Node(T t)

{

next = null;

data = t;

}

private Node next;

public Node Next

{

get { return next; }

set { next = value; }

}

// T as private member data type.

private T data;

// T as return type of property.

public T Data

{

get { return data; }

set { data = value; }

}

}

private Node head;

// constructor

public GenericList()

{

head = null;

}

// T as method parameter type:

public void AddHead(T t)

{

Node n = new Node(t);

n.Next = head;

head = n;

}

public IEnumerator<T> GetEnumerator()

{

Node current = head;

while (current != null)

{

yield return current.Data;

current = current.Next;

}

}

}

== Параллельное программирование ==

=== ADA ===

Ада реализует концепцию так называемых задач ('''task'''), что по сути является синонимом потока. Задача оформляется совершенно аналогично модулю, но может быть объявлена и описана где угодно, даже в теле подпрограммы:

'''package''' Tasked '''is'''

'''procedure''' Tasked_proc '''is'''

'''task''' Untyped_task_1 '''is'''

''Some declarations'' ''-- Здесь объявляем все так, как будто объявляем пакет''

'''end''' task;

'''task''' Untyped_task_2; ''-- Мы можем ничего и не открывать в задаче внешнему миру''

''-- Мы можем объявлять как отдельные задачи''

'''task''' '''type''' Task_Type '''is''' ''-- Так и целые типы задач''

''Some declarations''

'''end''' Task_Type;

Typed_task_1, Typed_task_2 : Task_Type; ''-- Две одинаковые задачи''

'''task''' '''body''' Untyped_task_1 '''is''' '''separate'''; ''-- Можно описать задачу отдельно''

'''task''' '''body''' Untyped_task_2 '''is'''

'''something''' '''is''' '''separate'''; ''-- Или часть задачи отдельно''

'''begin'''

'''...''' ''-- Собственно то, что будет делать задача''

'''end''';

'''end''' Untyped_task_2;

'''task''' '''body''' Task_Type '''is'''

'''...''' ''-- Тело типа задачи''

'''end''' Task_Type;

''-- Тут начинают работать наши 4 задачи параллельно: Untyped_task_1, Untyped_task_2, Typed_task_1, Typed_task_2''

''-- На самом деле их 5, так как главный процесс рассматривается как неявная задача''

'''begin''' ''-- Tasked_proc''

Do_Something;

'''...'''

''-- Здесь задача, запустившая потомков будет ожидать их завершения''

'''end''' Tasked_proc;

'''end''' Tasked;

В Аде есть множество методов синхронизации задач. Рассмотрим один из них - ''entry''. Это что-то на подобии точек входа в задачу извне. По своему объявлению, это - самые обычные процедуры, однако описываются и работают они по-другому. Когда одна задача хочет запросить у другой какую-либо услугу, она вызывает '''entry''', которая реализовывает данную услугу. В теле задачи (непосредственно в выполняемом коде), реализующей услугу есть участки кода, описывающих тела '''entry'''. Описание начинается со слова '''accept''' . Задача, вызвавшая '''entry''' будет ожидать, когда задача, реализующая этот '''entry''' дойдет до его тела. Этот момент называется '''Rendezvou''' (рандеву, свидание). Если несколько задач, одновременно (это слово, естественно, не стоит воспринимать буквально) вызвали '''entry''', то они становятся в очередь (тут уже речь идет, наверное, о названии Orgy хD ). Как это все выглядит:

'''task''' '''type''' Service ''is''

'''type''' Some_Type '''is''' '''range''' -10 .. 10;

'''entry''' Plus ( X: '''in''' Some_Type );

'''entry''' Minus ( X: '''in''' Some_Type );

'''entry''' Get ( X: '''out''' Some_Type ); ''-- Повторюсь, entry - те же процедуры у которых могут быть in/out параметры.''

'''end''' Service;

Кроме того для того чтобы задача не простаивала, тела '''accept''' можно объединить в блок '''select''', который будет выбирать запрошенные entry,

'''task''' '''body''' Service ''is''

Some_Var: Some_Type;

'''begin'''

Some_Var := 0;

'''loop'''

'''accept''' Get ( X: '''out''' Some_Type ) '''do''' ''-- Здесь будем простаивать, пока кто-нибудь не запросит Get;

X := Some_Var;

'''end''' Get;

'''select''' ''-- Здесь либо сразу выполняем одно из запрошенных (Plus, Minus), либо ждем, пока придет запрос на один из этих '''entity''' ''

'''accept''' Plus ( X: '''in''' Some_Type ) '''do'''

Some_Var := Some_Var + X;

'''end''' Plus;

'''or'''

'''accept''' Minus ( X: '''in''' Some_Type ) '''do'''

Some_Var := Some_Var - X;

'''end''' Minus;

'''end select''';

'''end loop''';

'''end''' Service;

В этом примере, естественно лучше было все 3 '''accept''' запихнуть в '''select''' - было бы меньше простоев, но для примера я оставил так.

=== Modula-2 ===

В языке Modula-2 есть низкоуровневый механизм ''сопрограмм''.

Отличия сопрограммы от процесса:

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

# Переключение процессора от одной сопрограммы к другой осществляется явным ''оператором передачи управления''. Выполнение сопрограммы, которой передаётся управление, возобновляется с той точки, где она была приостановлена последним таким оператором.

public static void main(String[] args)

break label2; // прервать внешний цикл

=== Примеры на C++, Ада и Java с использованием шаблонов ===

Стек:

GENERIC

TYPE T IS PRIVATE; SIZE : INTEGER;

PACKAGE Stacks IS

TYPE Stack IS LIMITED PRIVATE;

PROCEDURE Push(S: IN OUT Stack; X : IN T);

PROCEDURE Pop(S: IN OUT Stack; X : OUT T);

FUNCTION IsEmpty(S : IN Stack) RETURN BOOLEAN;

FUNCTION IsFull(S : IN Stack) RETURN BOOLEAN;

PRIVATE

TYPE Stack is RECORD

Body : ARRAY (1..SIZE) OF T;

Top : INTEGER := 1;

END RECORD;

END Stacks;

template <typename T, int size> class Stack

{

public:

Stack() {top = 0;}

void Push(T x);

T Pop(T& x);

bool IsEmpty();

bool IsFull();

private:

Stack (const Stack& s);

T body[N];

int top;

};

Очередь:

generic

type T is private;

Size : integer;

package G_Queue is

type Queue is limited private;

procedure Enqueue(Q: inout Queue; X:T);

procedure Dequeue(Q: inout Queue; X:T);

procedure Init(Q: out Queue);

procedure Destroy(Q: inout Queue);

function IsFull(Q: Queue);

function IsEmpty(Q: Queue);

–- другие процедуры ...

private

type Queue is record

Left, Right: integer;

body : array(1..Size) of T;

end record;

end G_Queue;

Дек:

generic

type T is private;

package G_Deque is

type Deque is limited private;

procedure PushRight(Deq: inout Deque; X:T);

procedure PushLeft(Deq: inout Deque; X:T);

procedure PopRight(Deq: inout Deque; X: out T);

procedure PopLeft(Deq: inout Deque; X: out T);

procedure Init(Deq: out Deque);

procedure Destroy(Deq: inout Deque);

function IsFull(Deq: Deque);

function IsEmpty(Deq: Deque);

–- другие процедуры ...

private

type PLink is access;

type Link is record inf : T; next, prev : PLink; end record;

type PLink is access Link;

type Deque is record Left, Right: PLink; end record;