лекции (2008) (Фингеров Александр_ Кононов Алексей_ Кузин Сергей), страница 10

IMPORT InOut;

InOut.WriteInt(x);

InOut.Writeln;

п.3 Логические модули в языке Ада.

Логический модуль здесь называется пакетом.

package имя is

объявления; -спецификация пакета

endl имя;

package body имя is

опр-я; -реализация

end имя;

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

package STANDARD

об-я из STANDARD

об-я пользовательских пакетов

end STANDARD

Правила видимости теперь работают очень хитрым образом. В Модуле-2 подгружаем соответствующую таблицу имён и подгружаем модуль определений.

STANDARD

...

package P is

package P1 is

..

end P1;

end P;

...

package PP is

package P2 is

..

end P2;

package P3 is

..

end P3;

end PP;

Вложенность тел пакета точно такая же, что и у вложенностей спецификаций. Непосредственно видимы все имена из модуля STANDARD. Имя становится видимым сразу после своего определения и кончаются в конце пакета. Все имена становятся видимыми потенциально. Что касается тел, все имена, которые объявлены на верхнем уровне видны, остальные имена доступны через полное уточнение.

Лекция 20.

Понятия Логического модуля.

Модуль некая конструкция, которая объединяет данные и действия над ними.

В различных языках логический модуль определяется по разному:

Библиотечный модуль –Модула 2, модуль – Оберон, Unit – Делфи, Package –спецификация и тело пакета. (Ада)

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

STANDARD

[куча других пакетов]

[ ]

[ ]

[ ]

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

Package P is

…. Z

Package P1 is

X

Package P12 is

End P12

End P1

/*Z, P1 – доступны.

Чтобы достать до Y надо писать P1.Y и так далее.*/

END P

Если в одном из вложенных пакетов есть тело то и пакеты, содержащие его, тоже должны содержать тело. Все что описано в Package body P1 это реализационная часть, которая не доступна снаружи.

Для проектирования структурных программ рассматривается 2 подхода:

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

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

Чаще всего используется некоторая совмещенная схема. В системах программирования, где не используется вложенность удобно использовать bottom-up (снизу вверх) программирование. В языках с вложенностью чаще всего используется смешанная технология.

Структура программы лучше представлена в Аде, за счет вложенности пакетов, сразу видна иерархия. Но за это приходится платить, из-за этого язык становится намного сложнее.

Перегрузка операций – это частный случай полиморфизма – много форм одного и тоже.

Есть объявление (определяющее вхождение) имени и есть использование. Во многих языках было сделано, что может быть только одно объявление, но в современных языках в одной области видимости может быть несколько объявлений имени. Но это распространяется только на функции и процедуры. (Оберон и Модула не имеют перегрузку, все современные языки: С++, С# и т.д. имеют перегрузку функций) Перегрузка процедур и функций происходит в большинстве случаев по параметрам функции ( в некоторых языках еще по возвращаемому параметру, например в Аде bool f(); int f(); , в некоторых языках есть указатели типа F’boolean которые указывают какую именно функцию надо вызвать ).

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

Тут языки разделяются на 2 течения:

1 течение - Ада, С#, C++. В них некоторые стандартные операции считаются функциями и их можно перегружать. В современных языках перегрузка стандартных операций не должна влиять на синтаксис программы, т.е если можно перегружать плюс то должно быть два варианта 1 местный и 2 местный. В языке С++ можно перегружать почти все операции. (наибольший набор среди этого течения)

2 течение – Делфи, Джава. В этих языках перегружать стандартные операции нельзя.

Почему рассказ так резко перешел с пакетов на перегрузку:

Классический пример - матричные операции. Для определения пакета матриц в нем надо перегрузить стандартные операции такие как +, - и т.д. Его беда в том, что эти функции можно использовать как традиционную (инфиксную) форму, так и общую префиксную форму

{в пакете матрисес описан тип данных матрикс и описана функция “+”}

X, y , z matrises.matrix;

Z:= X+Y; - такую форму использовать нельзя из-за видимости.

Z := “+”(x, y); - надо писать matrices.”+”

Но правила видимости не позволяют нам использовать плюс нормально. (см. пример выше)

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

Способы хранения имен:

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

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

П.4. Инкапсуляция и абстрактные типы данных.

Понятие защиты абстракции тесно связано с инкапсуляцией. Впервые понятие инкапсуляции появилось в 1970 годах (т.е упрятывание данных, скрытие информации). Тогда же появилось понятие абстрактного типа данных, это тип у которого все данные инкапсулированы.

У объектно-ориентированных ЯП должны поддерживаться 3 понятия:

1. Инкапсуляция.

2. Наследование

3. Динамический полиморфизм.

Инкапсуляция - это скрытие, т.е. скрытие каких-то деталей. Вопрос «что скрывать?» – тоже самое что вопрос «что показывать?», а это уже тесно связано с проектированием интерфейса. А понятие интерфейса не возможно без инкапсуляции.

Существует понятие единица защиты, что фактически означает «тип». Это означает, что все экземпляры одного типа данных имеют одну и ту же систему инкапсуляции.

Атомом защиты называется либо тип, либо часть типа (переменная, член класса и т.д.) В Модуле-2 и Ада либо все открываем, либо все закрываем ( конечно исключая операции). В Обероне + языки с классами, атомом является член класса.

Модула-2:

DEFENITION MODULE M;

…….. –все что тут видим снаружи.

END M.

IMPLEMENTATION MODULE M;

…….. – тут все закрыто, то есть является реализацией инкапсуляции.

END M;

Все что определено в IMPLEMENTATION части не видно в других модулях.

Что же такое абстрактный тип данных?

Тип данных – это множество операций + множество значений, Абстрактный тип данных – это только множество операций.

В Модуле-2 понятие абстрактного типа данных моделируется с помощью скрытого типа данных. Это тип данных, который объявлен в модуле определений как TYPE T; . (если описан TYPE T = …. То он станет доступен для других модулей)

DEFENITION MODULE stacks;

TYPE STACK; - не доступны сами данные.

…множество процедур…

END stacks;

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

Лекция 21.

Принцип РОРИ — Разделение, Определение, Реализация, Использование.

Возьмём структуру Модула-2, Ада, Оберон — там мы чётко видим, что у нас есть определение (DEF MOD), реализация (IMPL MODULE) и использование. В языке Модула-2 модули определения и реализации — разные единицы компиляции. С точки зрения раздельной трансляции, компилятору необходимо знать только часть, которая относится к определению, поэтому эта часть вынесена в отдельную языковую конструкцию. На самом деле компилятору (есть модуль, который импортирует другой модуль) для того чтобы откомпилировать клиентский модуль, ему необходимо предоставить только definition модуль. Если поменялся модуль определений, нужно перекомпилировать все модули, которые включают в себя предложение import. То же самое касается и языка Ада. В C/C++ утилита make отслеживает изменение header-файла и заставляет перетранслировать всю программу. Если мы возьмём Delphi, при замене только implementation части или добавлении комментария, модуль перетранслируется, но больше ничего не произойдёт. Компилятор смотрит, осталась ли неизменной таблица в начале модуля.

Возвращаемся к реализации Абстрактных типов данных с помощью скрытого типа. Допустим, компилятор встречает import service и подгружает таблицу имён, и тут выясняется, что есть TYPE HANDLE; после чего компилятор видит VAR H:HANDLE;. Информации о реализации у него нет, как ему распределять память? Поэтому введено, что это может быть либо целый тип, либо указатель, для которых известны операции и размеры. Референциально-ссылочная память. Создатели языка Ада понимали эту дилемму, в результате чего скрытый тип не совсем абстрактный, он лишь моделирует абстрактный. 2 концепции: приватный тип данных и ограниченный приватный тип данных, который полностью моделирует абстрактный тип данных. Основной недостаток с точки зрения инкапсуляции — он заставляет программиста употреблять референциальную модель объекта. В языке Ада спецификация приватного типа данных выглядит так:

package Stacks is