М. Бен-Ари - Языки программирования. Практический сравнительный анализ (2000) (1160781), страница 38
Текст из файла (страница 38)
type Ptr is access Airplane_Package.Airplanes;
-- Тип с компонентом ADT
procedure Display(Parm: in Airplane_Package.Airplanes);
-- Параметр ADT
A: Airplane_Package.Airplane_Data;
Index: Integer;
begin
A .:=... ;
Airplane_Package.New_Airplane(Airplane, A, Index);
Display(Airplane);
end Air_Traffic_Control;
За использование ADT вместо абстрактных объектов данных придется заплатить определенную цену: так как в теле пакета больше нет ни одного неявного объекта, каждая интерфейсная процедура должна содержать дополнительный параметр, который явно сообщает подпрограмме, какой именно объект нужно обработать.
Вы можете спросить: а как насчет «абстракции»? Поскольку тип Airplaines теперь объявлен в спецификации пакета, мы потеряли все абстракции; больше нельзя изменить структуру данных, не повлияв на другие единицы, использующие пакет. Кроме того, кто-нибудь из группы программистов может скрытно проигнорировать процедуры интерфейса и написать «улучшенный» интерфейс. Мы должны найти решение, в котором имя типа находится в спецификации так, чтобы его можно было использовать, а детали реализации инкапсулированы — что-нибудь вроде следующего:
package Airplane_Package is
type Airplane_Data is ... end record;
type Airplanes; -- Неполное объявление типа
end Airplane_Package;
package body Airplane_Package is
type Airplanes is -- Полное объявление типа
record
Database: array(1..1000) of Airplane_Data;
Current_Airplanes: Integer 0...Database'Last;
end record;
…
end Airplane_Package;
Потратьте несколько минут, чтобы проанализировать этот вариант самостоятельно перед тем, как идти дальше.
Что касается пакета, то с этими объявлениями нет никаких проблем, потому что спецификация и тело формируют одну область объявлений. Проблемы начинаются, когда мы пробуем использовать пакет:
with Airplane_Package;
procedure Air_Traffic_Control is
Airplane_1: Airplane_Package.Airplanes;
Airplane_2: Airplane_Package.Airplanes;
…
end Air_Traffic_Control;
Язык Ada задуман так, что компиляции спецификации пакета достаточно, чтобы сделать возможной компиляцию любой единицы, использующей пакет. Фактически, не нужно даже, чтобы существовало тело пакета, когда компилируется использующая единица. Но чтобы откомпилировать приведенную выше программу, компилятор должен знать, сколько памяти нужно выделить для Airplane_1 и Airplane_2; аналогично, если эта переменная используется в выражении или передается как параметр, компилятор должен знать размер переменной. Таким образом, если представление ADT инкапсулировано в тело пакета, откомпилировать программу будет невозможно.
Приватные (private) типы
Поскольку мы имеем дело с реальными языками программирования, которые должны компилироваться, не остается ничего другого, кроме как вернуть полную спецификацию типа в спецификацию пакета. Чтобы достичь абстракции, используется комбинация самообмана и правил языка:
package Airplane_Package is
type Airplane_Data is ... end record;
type Airplanes is private;
-- Детали будут заданы позже
procedure New_Airplane(Data: in Airplane_Data; I: out Integer);
procedure Get_Airplane(I: in Integer; Data: out Airplane_Data);
private
type Airplanes is -- Полное объявление типа
record
Database: array(1 ..1000) of Airplane_Data;
Current_Airplanes: Integer 0.. Database'Last;
end record;
end Airplane_Package;
Сам тип первоначально объявлен как приватный (private), в то время как полное объявление типа записано в специальном разделе спецификации пакета, который вводится ключевым словом private. Тип данных абстрактный, потому что компилятор предписывает правило, по которому единицам, обращающимся к пакету через with, не разрешается иметь доступ к информации, записанной в закрытой (private) части. Им разрешается обращаться к приватному типу данных только через подпрограммы интерфейса в открытой (public) части спецификации; эти подпрограммы реализованы в теле, которое может иметь доступ к закрытой части. Так как исходный код использующих единиц не зависит от закрытой части, можно изменить объявления в закрытой части, не нарушая правильности исходных текстов использующих единиц; но, конечно, нужно будет сделать перекомпиляцию, потому что изменение в закрытой части могло привести к изменению выделяемого объема памяти.
Поскольку вы не можете явно использовать информацию из закрытой части, вы должны «сделать вид», что не можете ее даже видеть. Например, нет смысла прикладывать особые усилия в написании чрезвычайно эффективных алгоритмов, зная, что приватный тип реализован как массив, а не как список, потому что руководитель проекта может, в конечном счете, изменить реализацию.
Ограниченные типы
Достаточно объявить объект (переменную или константу) приватного типа, и над ним можно будет выполнять операции присваивания и проверки на равенство, так как эти операции выполняются поразрядно независимо от внутренней структуры. Существует, однако, концептуальная проблема, связанная с разрешением присваивания и проверки равенства. Предположим, что в реализации массив заменен на указатель:
package Airplane_Package is
type Airplanes is private;
…
private
type Airplanes_jnfo is
record
Database: array(1..1000) of Airplane_Data;
Current_Airplanes: Integer O..Database'Last;
end record;
type Airplanes is access Airplanes_info;
end Airplane_Package;
Мы обещали, что при изменении закрытой части не потребуется менять использующие единицы, но здесь это не так, потому что присваивание делается для указателей, а не для указуемых объектов:
with Airplane_Package;
procedure Air_Traffic_ControI is
Airplane_1: Airplane_Package.Airplanes;
Airplane_2: Airplane_Package.Airplanes;
begin
Airplane_1 := Airplane_2; -- Присваивание указателей
end Air_Traffic_Control;
Если присваивание и проверка равенства не имеют смысла (например, при сравнении двух массивов, которые реализуют базы данных), язык Ada позволяет вам объявить приватный тип как ограниченный (limited). Объекты ограниченных типов нельзя присваивать или сравнивать, но вы можете явно написать свои собственные версии для этих операций. Это решит только что описанную проблему; при преобразовании между двумя реализациями можно изменить в теле пакета явный код для присваивания и равенства, чтобы гарантировать, что эти операции по-прежнему имеют смысл. Неограниченными приватными типами следует оставить лишь «небольшие» объекты, которые, вероятно, не подвергнутся другим изменениям, кроме добавления или изменения поля в записи.
Обратите внимание, что если приватный тип реализован с помощью указателя, то в предположении, что все указатели представлены одинаково, уже не важно, каков тип указуемого объекта. В языке Ada такое предположение фактически делается и, таким образом, указуемый тип может быть определен в теле пакета. Теперь изменение структуры данных благодаря косвенности доступа не требует даже перекомпиляции единиц с конструкцией with:
package Airplane_Package is
type Airplanes is private;
…
private
type Airplanes_info; -- Незавершенное объявление типа
type Airplanes is access Airplanes_info;
end Airplane_Package;
package body Airplane_Package is
type Airplanes_info is -- Завершение в теле
record
Database: array(1..1000) of Airplane_Data;
Current_Airplanes: Integer O..Database'Last;
end record;
end Airplane_Package;
ADT является мощным средством структурирования программ благодаря четкому отделению спецификации от реализации:
• Используя ADT, можно делать серьезные изменения в отдельных компонентах программы надежно, не вызывая ошибок в других частях программы.
• ADT может использоваться как инструмент управления разработкой: архитектор проекта разрабатывает интерфейсы, а каждый член группы программистов реализует один или несколько ADT.
• Можно выполнить тестирование и частичную интеграцию, применяя вырожденные реализации отсутствующих тел пакетов.
В главе 14 мы подробнее поговорим о роли ADT как основы объектно-ориентированного программирования.
13.5. Как писать модули на языке C++
Язык C++ — это расширение языка С, и поэтому здесь тоже существует понятие файла как единицы структурирования программ. Наиболее важным расширением является введение классов (classes), которые непосредственно реализуют абстрактные типы данных, в отличие от языка Ada, который использует комбинацию из двух понятий: пакета и приватного типа данных. В следующей главе мы обсудим объектно-ориентированное программирование, которое основано на классах; а в этом разделе объясним основные понятия клас-
сов и покажем, как они могут использоваться для определения модулей.
Класс аналогичен спецификации пакета, которая объявляет один или не-
сколько приватных типов:
class Airplanes {
public:
struct Airplane_Data {
char id[80];
int speed;
int altitude;
};
void new_airplane(const Airplane_Data & a, int & i);
void get_airplane(int i, Airplane_Data & a) const;
private:
Airplane_Data database[1000];
int current_airplanes;
int find_empty_entry();
};
Обратите внимание, что имя класса, которое является именем типа, также служит в качестве имени инкапсулирующей единицы; никакого самостоятельного имени модуля не существует. Класс имеет общую и закрытую части. По умолчанию компоненты класса являются приватными, поэтому перед общей частью необходим спецификатор public. Фактически, при помощи спецификаторов public и private можно задать несколько открытых и закрытых частей вперемежку, в отличие от языка Ada, который требует, чтобы для каждой части был только один список объявлений:
class С {
public:
…
private:
…
public:
….
private:
…..
};
Объявления в общей части доступны любым модулям, использующим этот класс, в то время как объявления в закрытой части доступны только внутри класса. Спецификатор const в get_airplane — это следующее средство управления, он означает, что подпрограмма не изменяет никакие данные внутри объекта класса. Такие подпрограммы называются инспекторами (inspectors).
Поскольку класс является типом, могут быть объявлены объекты (константы и переменные) этого класса, так называемые экземпляры класса:
Airplanes Airplane; // Экземпляр класса Airplanes
int index;
Airplanes::Airplane_Data a;
Airplane.new_airplane(a, index); // Вызов подпрограммы для экземпляра
Классом может быть и тип параметра. Для каждого экземпляра будет выделена память всем переменным, объявленным в классе, точно так же, как для переменной типа запись выделяется память всем полям.
Синтаксис вызова подпрограммы отличается от синтаксиса, принятого в языке Ada, из-за различий в исходных концепциях. Вызов в языке Ada:
Airplane_Package.New_Airplane(Airplane, A, Index);
рассматривает пакет как применение ресурса — процедуры New_Airplane, которой должен быть задан конкретный объект Airplane. Язык C++ полагает, что объект Airplane — это экземпляр класса Airplanes, и, если вы посылаете объекту сообщение (message) new_airplane, для этого объекта будет выполнена соответствующая процедура.
Обратите внимание, что даже такие подпрограммы, как find_empty_entry, которые используются только внутри класса, объявлены в определении класса. Язык C++ не имеет ничего похожего на тело пакета, представляющее собой единицу, которая инкапсулирует реализацию интерфейса и других подпрограмм. Конечно, внутренняя подпрограмма недоступна другим модулям, потому что она объявлена внутри закрытой части. В языке C++ проблема состоит в том, что, если необходимо изменить объявление find_empty_entry или добавить другую приватную подпрограмму, придется перекомпилировать все модули программы, которые используют этот класс; в языке Ada изменение тела пакета не воздействует на остальную часть программы. Чтобы достичь на языке C++ реального разделения интерфейса и реализации, следует объявить интерфейс как абстрактный класс, а затем получить конкретный производный класс, который содержит реализацию
![](https://s.studizba.com/z.php?f=/templates/si/i/noavatar.png&w=100&h=100&t=1"){kind=avatar}
