Простые типы 8 страница

...
end
то две подпрограммы будут использовать различные имена и различные типы
для доступа к одной и той же памяти! Отображение common-блоков друг на
друга делается по их расположению в памяти, а не по именам переменных. Если
для переменной типа real выделяется столько памяти, сколько для двух пере-
менных типа integer, speed(80) в подпрограмме S2 размещается в той же са-
мой памяти, что и половина переменной distance(40) в S1. Эффект подобен
неаккуратному использованию типов union в языке С или вариантных запи-
сей в языке Pascal.
Независимая компиляция и общие блоки вряд ли создадут проблемы для
отдельного программиста, который пишет небольшую программу, но с боль-
шой вероятностью вызовут проблемы в группе из десяти человек; придется
Организовать встречи или контроль, чтобы гарантировать, что интерфейсы реализованы правильно. Частичное решение состоит в том, чтобы использовать
включаемые (include) файлы, особенно дли общих блоков, но нам всё
равно придется проверять, что вы используете последнюю версию включае-
мого файла, и удостовериться, что какой-нибудь умный программист не иг-
норирует объявления в файле.

Раздельная компиляция в языке С
Язык С отличается от других языков программирования тем, что понятие
файла с исходным кодом появляется в определений языка и, что существенно,
в терминах области действия и видимости идентификаторов. Язык С поощря-
ет раздельную компиляцию до такой степени, что по умолчанию к каждой
подпрограмме и каждой глобальной переменной можно обращаться отовсю-
ду в программе.
Вначале немного терминологии: объявление вводит имя в программу:
void proc(void);
Имя может иметь много (идентичных) объявлений, но только одно из них бу-
дет также и определением, которое создает объект этого имени: отводит память
для переменных или задает реализацию подпрограммы.
Следующий файл содержит главную программу main, а также определение
глобальной переменной и объявление функции, имена которых по умолчанию
подлежат внешнему связыванию:
/* File main.с */
int global; /* Внешняя по умолчанию */
int func(int); /* Внешняя по умолчанию */
int main(void)
{
global = 4;
return func(global);
}
В отдельном файле дается определение (реализация) функции; переменная
global объявляется снова, чтобы функция имела возможность к ней обратиться:
/* File func.c *./
extern int global; /* Внешняя, только объявление */

int func(int parm)
{
return parm + global:
}

Обратите внимание, что еще одно объявление func не нужно, потому что оп-|
ределение функции в этом файле служит также и объявлением, и по умолча-
нию она внешняя. Однако для того чтобы func имела доступ к глобальной пе ременной, объявление переменной дать необходимо, и должен использовать-
ся спецификатор extern. Если extern не используется, объявление переменной
global будет восприниматься как второе определение переменной. Произой-
дет ошибка компоновки, так как в программе запрещено иметь два определе-
ния для одной и той же глобальной переменной.
Компиляция в языке С независима в том смысле, что результат одной ком-
пиляции не сохраняется для использования в другой. Если кто-то из вашей
группы случайно напишет:
/* File func.c */
extern float global; /* Внешняя, только объявление */
int func(int parm) /* Внешняя по умолчанию */
{
return parm + global;
}
программа все еще может быть откомпилирована и скомпонована, а ошибка
произойдет только во время выполнения. На моем компьютере целочисленное
значение 4, присвоенное переменной global в main, воспринимается в файле
func.c как очень малое число с плавающей точкой; после обратного преобразо-
вания к целому числу оно становится нулем, и функция возвращает 4, а не 8.
Как и в языке Fortran, проблему можно частично решить, используя вклю-
чаемые файлы так, чтобы одни и те же объявления использовались во всех
файлах. И объявление extern для функции или переменной, и определение
могут появиться в одном и том же вычислении. Поэтому мы помещаем все
внешние объявления в один или несколько включаемых файлов, в то время
как единственное определение для каждой функции или переменной будет
содержаться не более чем в одном файле «.с»:
/* File main.h */
extern int global; /* Только объявление */
/* File func.h */
extern int func(int parm); /* Только объявление */
Г File main.c */
#include "main.h"
#include "func.h"
int global; /* Определение */
int main(void)
{
return func(global) + 7;
i
/* File func.c */
#include "main.h"
#include "func.h"
int func(int parm) /* Определение */
{
return parm + global;

}

Спецификатор static
Забегая вперед, мы теперь покажем, как и языке С можно использовать свой-
ства декомпозиции для имитации конструкции модуля других языков. В фай-
ле, содержащем десятки глобальных переменных и определений подпро-
грамм, обычно только некоторые из них должны быть доступны вне файла.
Каждому определению, которое не используется внешним образом, должен
предшествовать спецификатор static (статический), который указывает ком-
пилятору, что объявленная переменная или подпрограмма известна только
внутри файла:
static int g1; /* Глобальная переменная только в этом файла */
int g2; /* Глобальная переменная для всех файлов */
static intf1(int i) {...}; /* Глобальная функция только в этом файле */
int f2(int i) {...}; /* Глобальная функция для всех файлов */
Здесь уместно говорить об области действия файла (file scope), которая
выступает в роли области действия модуля (module scope), используемой в
других языках. Было бы, конечно, лучше, если бы по умолчанию принимался
спецификатор static, а не extern; однако нетрудно привыкнуть приписывать я
каждому глобальному объявлению static.
Источником недоразумений в языке С является тот факт, что static имеет
другое значение, а именно он определяет, что время жизни переменной явля-
ется всем временем выполнения программы.
Глобальные переменные, однако, имеют статическое время жизни, то есть они распределяются, когда программа начинается, и не освобождаются, пока программа не завершится. Статическое время жизни — нормальный режим для глобальных переменных; на самом деле, глобальные переменные, объявленные с extern, также имеют статическое время жизни!
Спецификатор static также можно использовать для локальных перемен-
ных, чтобы задать статическое время жизни:
void proc(void)
{
static bool first_time = true;
if (firstjime) {
/* Операторы, выполняемые при первом вызове proc */
first_time = false;
}

...

}

Подведем итог: все глобальные переменные и подпрограммы в файле должны
быть объявлены как static, если явно не требуется, чтобы они были доступны
вне файла. В противном случае они должны быть определены в одном файле без какого-либо спецификатора и экспортироваться через объявление их во включаемом файле со спецификатором extern.

9.10.12. Почему необходимы модули?
Стандартным термином для механизма структурирования больших
программ является модуль (module), хотя два языка, на которых мы сосредоточили внимание, используют другие термины: пакеты (packages) в языке Ada и классы (classes) в языке C++. В стандарте языка Pascal не определено никакого метода раздельной компиляции или декомпозиции программ. Например первый Pascal-компилятор был единой программой, содержащей свыше 8000 строк кода на языке Pascal. Вместо того чтобы изменять Pascal, Вирт разработал новый (хотя и похожий) язык, названный Modula, так как центральным понятием в нем является модуль. К сожалению, многие поставщики расширили язык Pascal несовместимыми модульными конструкциями, поэтому Pascal не годится для написания переносимого програмного обеспечения.
Поскольку модули очень важны для разработки программного обеспечения,
мы сосредоточим обсуждение на языке Ada, в котором разработана изящная
модульная конструкция — так называемые пакеты.

9.10.13. Пакеты в языке Ada
Основной идеей, лежащей в основе модулей вообще и пакетов Ada в частно-
сти, является то, что такие вычислительные ресурсы, как данные и подпро-
граммы, должны быть инкапсулированы в некий единый модуль. Доступ к
компонентам модуля разрешается только в соответствии с явно специфи-
цированным интерфейсом. На рисунке 1.1 показана графическая запись
(называемая диаграммой Буча — Бухера), применяемая в разработках на языке Ada. Большой прямоугольник обозначает пакет Airplane_Package, содер-
жащий скрытые вычислительные ресурсы, а малые прямоугольники — ок-
на, которые дают пользователю пакета доступ к скрытым ресурсам, овал
обозначает, что экспортируется тип; а два прямоугольника — что экспор-
тируются подпрограммы. Из каждого модуля, использующего ресурсы па-
кета, выходит стрелка, которая указывает на пакет.

Рис. 1.1. Диаграмма пакета

Объявление пакета

Пакет состоит из двух частей: спецификации и тела. Тело инкапсулирует вы-
числительные ресурсы, а спецификация определяет интерфейс для этих ре-
сурсов. Пакет из следующего примера предназначается для представления
компонента системы управления воздушным движением, который хранит описание всех самолётов в контролируемом воздушном пространстве. Спецификация пакета объявляет тип и две подпрограммы интерфейса:
package Airplane_Package is
type Airplane_Data is

record
ID: String(1..80);
Speed: Integer range 0..1000;
Altitude: Integer range 0..100;
end record;
procedure New_Airplane(Data: in Airplane_Data; I: out Integer);
procedure Get_Airplane(l: in Integer; Data: out Airplane_Data);
end Airplane_Package;
Спецификация пакета содержит не тела, а только объявления процедур,
заканчивающиеся точкой с запятой и вводимые зарезервированным словом.
Объявление служит только в качестве спецификации вычислительного ресурса, который предоставляет пакет.
В теле пакета должны быть обеспечены все ресурсы, которые были заявлены. В частности, для каждого объявления подпрограммы должно существовать тело подпрограммы с точно тем же самым объявлением:
package body Airplane_Package is
Airplanes: array(1..1000) of Airplane_Data;
Current_Airplanes: Integer range 0.. Airplanes'Last;
function Find_Empty_Entry return Integer is
.
begin
end Find_Empty_Entry;
procedure New_Airplane(Data: in Airplane_Data; I: out Integer) is

Index: Integer:= Find_Empty_Entry;
begin

Airplanes(lndex):= Data;

I:= Index;
end New_Airplane;

procedure Get_Airplane(l: in Integer; Data: out Airplane_Data) is
begin

Data:= Airplanes(l);
end Get_Airplane;
end Airplane_Package;

Структура, применяемая для хранения данных о самолётах (здесь это массив фиксированного размера), инкапсулирована в тело пикета. Правило языка Ada состоит в том, что изменение в теле пакета не требу ет изменений ни спецификации пакета, ни любого другого компонента про-
граммы, использующею пакет. Более того, не нужно даже их перекомпилировать. Например, если впоследствии вы должны заменить массив связанным списком, не нужно изменять никаких других компонентов системы при условии, что интерфейс, описанный в спецификации пакета, не изменился:

package body Airplane_Package is
type Node;

type Ptr is access Node;
type Node is
record
Info: Airplane__Data;
Next: Ptr;
end record;

Head: Ptr;. -- Начало связанного списка

procedure New_Airp!ane(Data: in Airplane_Data; I: out Integer) is

begin
-- Новая реализация
end New_Airplane;
procedure Get_Airplane(l: in Integer; Data: out Airplane_Data) is
begin
-- Новая реализация
end Get_Airplane;
end Airplane_Package;
Инкапсуляция делается не только для удобства, но и для надежности. Пользо-
вателям пакета не разрешен непосредственный доступ к данным или внутрен-
ним подпрограммам (таким, как Find_Empty_Entry) тела пакета. Таким обра-
зом, никакой другой программист из группы не может случайно (или предна-
меренно) изменить структуру данных способом, который не был предусмот-
рен. Ошибка в реализации пакета обязательно локализована внутри кода тела
пакета и не является результатом некоторого кода, написанного членом груп-
пы, не ответственным за пакет.
Спецификация и тело пакета — это разные модули, и их можно компили-
ровать раздельно. Однако в терминах объявлений они рассматриваются как
одна область действия, например, тип AirplainJData известен внутри тела па-
кета. Это означает, конечно, что спецификация должна компилироваться пе-
ред телом. В отличие от языка С, здесь нет никакого понятия «файла», и объ-
явления в языке Ada существуют только внутри такой единицы, как подпро-
грамма или пакет. Несколько компилируемых модулей могут находиться в од-
ном файле, хотя обычно удобнее хранить каждый модуль в отдельном файле. I
Соглашение для написания программ на языке С, предложенное в преды-
дущем разделе, пытается имитировать инкапсуляцию, которая предостав-
пяется пакетами в языке Ada.

Использование пакета

Программа на языке Ada (или другой пакет) может получить доступ к вычис-
лительным ресурсам пакета, задав контекст (context clause) перед первой стро-
кой программы:
with Airplane_Package;
procedure Air_Traffic_Control is
A: Airplane_Package.Airplane_Data;
Index: Integer;
begin
while... loop

A:=...; — Создать запись

Airplane_Package. New_Airplane(A, Index):

-- Сохранить в структуре данных

end loop;

end Air_Traffic_Control;
With-конструкция сообщает компилятору, что эта программа должна компи-
лироваться в среде, которая включает все объявления пакета Airplain_Package.
Синтаксис для именования компонентов пакета аналогичен синтаксису для
выбора компонентов записи. Поскольку каждый пакет должен иметь уни-
кальное имя, компоненты в разных пакетах могут иметь одинаковые имена, и
никакого конфликта не возникнет. Это означает, что управление пространст-
вом имен, т. е. набором имен, в программном проекте упрощено, и необходи-
мо осуществлять контроль только на уровне имен пакетов. Сравните это с языком С, где идентификатор, который экспортируется из файла, видим во всех других файлах, потому недостаточно только обеспечить различие имён файлов.
With-конструкция добавляет составные имена к пространству имен компиляции; также можно включить use-конструкцию, чтобы открыть пространство имен и разрешить прямое именование компонентов, встречающихся в спецификации:
with Airplane_Package;
use Airplane Package;
procedure Air_Traffic_Control is
A: Airplane_Data; -- Непосредственно видима
Index: Integer; begin
New_Airpiane(A, Index): -- Непосредственно видима
end Air-Traffic-Control;
•
Одна трудность, связанная с use-конструкциями, состоит в том, что вы можете столкнуться с неоднозначностью, если use-конструкции для двух пакетов
открывают одно и то же имя или если существует локальное объявление с тем
же самым именем, что и в пакете. Правила языка определяют, каким в случае
неоднозначности должен быть ответ компилятора.
Важнее, однако, то, что модуль, в котором with- и use-конструкции связаны с множеством пакетов, может стать практически нечитаемым. Такое имя,
как Put_Element, могло бы исходить почти из любого пакета, в то время как
местоположение Airplane_Package.Put_Element вполне очевидно. Ситуация
аналогична программе, написанной на языке С, в которой много включаемых
файлов: у вас просто нет удобного способа отыскивать объявления, и единственное решение — использовать внешний программный инструмент или cjглашения о наименованиях.
Программистам, пишущим на языке Ada, следует использовать преимущества самодокументирования модулей за счет with, а use-конструкции применять только в небольших сегментах программы, где все вполне очевидно, а полная запись была бы чересчур утомительна. К счастью, можно поместить use-конструкции внутри локальной процедуры:
procedure Check_for_Collision is
use Airplane_Package;
A1: Airplane-Data;
begin
Get_Airplane(1, A1);
end Check_for_Collision;
В большинстве языков программирования импортирующий модуль автоматически получает все общие (public) ресурсы импортированного модуля. В некоторых языках, подобных языку Modula, импортирующему модулю разрешается точно определять, какие ресурсы ему требуются. Этот метод позволяет избежать перегрузки пространства имен, вызванной включающим характером use-конструкции в языке Ada.

Порядок компиляции

With-конструкции определяют естественный порядок компиляции: спецификация пакета должна компилироваться перед телом и перед любым модулем, который связан с ней через with. Однако упорядочение является частичным, т.е. порядок компиляции тела пакета и единиц, которые используют пакет, может быть любым. Вы можете исправить ошибку в теле пакета или в использующей по единице, перекомпилировав только то, что изменилось, но изменение спецификации пакета требует перекомпиляции как тела, так и всех использующих его единиц. В очень большом проекте следует избегать изменений спецификации пакетов, потому что они могут вызвать лавину перекомпиляций:И используется в Р2, который используется в РЗ, и т. д.
Тот факт, что компиляция одной единицы требует результатов компиля-
ции других единиц, означает, что в языке Ada компилятор должен содержать
библиотеку для хранения результатов компиляции. Библиотека может быть
просто каталогом, содержащим порожденные файлы, или сложной базой
данных. При использовании любого метода библиотечный администратор
является центральным компонентом реализации языка Ada, а не просто не-
обязательным программным инструментом. Библиотечный администратор
языка Ada проводит в жизнь правило, согласно которому при изменении спе-
цификации пакета необходимо перекомпилировать тело и использующие его
единицы. Таким образом, компилятор языка Ada уже включает инструмент
сборки программы (make) с перекомпиляцией измененных модулей, который
в других средах программирования является необязательной утилитой, а не
мастью языковых средств.

9.10.14. Абстрактные типы данных в языке Ada
Airplane_Package — это абстрактный объект данных. Он является абстракт-
ным, потому что пользователь пакета не знает, реализована ли база данных са-
молетов как массив, список или как дерево. Доступ к базе данных осуществ-
ляется только через объявленные в спецификации пакета интерфейсные
процедуры, которые позволяют пользователю абстрактно создавать и отыскивать значение типа Airplane_Data, не зная, в каком виде оно хранится.
Пакет является объектом данных, потому что он действительно содержит
данные: массив и любые другие переменные, объявленные в теле пакета. Пра-
вильно рассматривать Airplane_Package как особую* переменную: для нее
должна быть выделена память и есть некоторые операции, которые могут из-
менить ее значение. Это объект не первого класса, потому что он не имеет
всех преимуществ обычных переменных: нельзя делать присваивание пакету
пли передавать пакет как параметр.
Предположим теперь, что мы нуждаемся в двух таких базах данных: одни
для смоделированного пульта управления воздушным движением и одна для
администратора сценария моделирования, который вводит и инициализирует
новые самолеты. Можно было бы написать два пакета с незначительно отли-
чающимися именами или написать родовой пакет и дважды его конкретизировать, но это очень ограниченные решения. Что мы действительно хотели бы сделать, так это объявить столько таких объектов, сколько нам нужно, также как мы объявляем целые числа. Другими словами, мы хотим иметь возможность конструировать абстрактный тип данных (Abstract Data Type -ADT), который является точно таким же, как и абстрактный объект данных, за исключением того что он не содержит никаких «переменных». Вместо этого, подобно другим типам, ADT определяет набор значений и набор операций на этих значениях, а фактическое объявление переменных этого типа может быть сделано в других компонентах программы.

ADT в языке Ada — это пакет, который содержит только объявления констант, типов и подпрограмм. Спецификация пакета включает объявление типа так, что другие единицы могут объявлять один или несколько объектов типа Airplains (самолеты):
package Airplane_Package is
type Airplane_Data is... end record;
type Airplanes is
record
Database: array(1..1000) of Airplane_Data;
Current_Airplanes: Integer 0.. Database'Last;
end record;
procedure New_Airplane(
A: in out Airplanes; Data: in Airplane_Data: I: out Integer);
procedure Get_Airplane(
A: in out Airplanes; I: in Integer; Data: out Airplane_Data);
end Airplane_Package;
Тело пакета такое же, как и раньше, за исключением того что в нем нет никаких глобальных переменных:
package body Airplane_Package is
function Find_Empty_Entry...;
procedure New_Airplane...;
procedure Get_Airplane...;
end Airplane_Package;
Программа, которая использует пакет, может теперь объявить одну или несколько переменных типа, поставляемого пакетом. Фактически тип является обычным типом и может использоваться в последующих определениях типов и как тип параметра:
with Airplane Package;
procedure Air_Traffic_Control is
Airplane: Airplane_Package.Airplanes;
-- Переменная ADT
type Ptr is access Airplane_Package.Airplanes;
-- Тип с компонентом ADT
procedure Display(Parm: in Airplane_Package.Airplanes);
-- Параметр ADT
A: Airp!ane_Package.Airplane_Data;
Index: Integer;
begin
A:=...;
Airplane_Package.New_Airp!ane(Airplane, A, Index);
Display(Airplane);
end Air_Traffic_Control;
Зa использование 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 O..Database'Last;
end record;
end Airplane_Package;

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

9.10.15. Ограниченные типы
Достаточно объявить объект (переменную или константу) приватного типа, и
над ним можно будет выполнять операции присваивания и проверки на равенство, так как эти операции выполняются поразрядно независимо от внутренней структуры. Существует, однако, концептуальная проблема, связанная с разрешением присваивания и проверки равенства. Предположим, что в реализации массив заменен на указатель:
package Airplane_Package is
type Airplanes is private;
.
private

type Airplanesjnfo is
record

Database: array(1..1000) of Airplane_Data;
Current_Airplanes: Integer O..Database'Last;
end record;

type Airplanes is access Airplanesjnfo;
I end Airplane_Package;
Мы обещали, что при изменении закрытой части не потребуется менять использующие единицы, но здесь это не так, потому что присваивание делается для указателей, а не для указуемых объектов:
with Airplane_Package;
procedure Air_Traffic_Control 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 Airplanesjnfo; -- Незавершенное объявление типа I
type Airplanes is access Airplanesjnfo;
end Airplane_Package;
package body Airplane_Package is
type Airplanesjnfo is -- Завершение в теле
record
Database: array(1..1000) of Airplane_Data;
Current_Airplanes: Integer 0..Database'Last;
end record;
end Airplane_ckage;
ADT является мощным средством структурирования программ благодаря четкому отделению спецификации от реализации:
• Используя ADT, можно делать серьезные изменения в отдельных компнентах программы надежно, не вызывая ошибок в других частях программы.
• ADT можем использоваться как инструмент управления разработкой:
архитектор проекта разрабатывает интерфейсы, а каждый член группы
программистов реализует один или несколько ADT.
• Можно выполнить тестирование и частичную интеграцию, применяя
вырожденные реализации отсутствующих тел пакетов.

9.10.16. Как писать модули на языке 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, который требует, чтобы для каждой части